鸿蒙仓颉语言

一.仓颉标识符命名规则

1.小驼峰命名法

两个单词之间，第二个首字母大写，如schoolName，studentAge等

1. package  cjproject1.chapter1
3. //类名、变量名、函数名、自定义数据类型首字母是可以字母或下划线（数字为开头不可以），
4. //后面可以是任意长度的字母或下划线、数组
5. var  age : Int64 = 100   // 全局变量
7. //两个单词之间，第二个单词的首字母大写，小驼峰命名法
8. var schoolName : String   = "balala"
10. public  class  Stu{
12.     public  var  age : Int64 = 100   //类的局部变量
14. }
16. public  struct  Index{
17.      public  var  age : Int64 = 100  //自定义数据类型的局部变量
18. }
20. //函数命名
21. public   func   Fun()
22. {
23.      var  age : Int64 = 100  // 函数的局部变量
24. }
26. //函数和变量的命名方法一致, 两个单词之间，第二个单词的首字母大写，小驼峰命名法
27. public   func   exceFun()
28. {
30. }

复制代码

 2.大驼峰命名法

大驼峰命名法重要实用于常量的命名法

1. const   MAX_VALUE : Int64  = 100//常量命名

复制代码

当然普通标识符与仓颉的关键字不能相同
 二、常量以及变量的定义

1.常量的定义

定义常量关键字为：const

1. const   MAX_VALUE : Int64  = 100//常量命名，其值不可改变

复制代码

2.变量的定义

变量的定义格式为：修饰符  变量名： 变量类型  =  初始值
变量分为可变变量和不可变变量
可变变量修饰符：var，不可变变量修饰符：let

1. package cjproject315
2. main(): Int64 {
3.    //使用let关键字定义变量，这个变量为不可变变量,定义时可以不赋值，可读不可写
4.      let  value1 :Int64
5.      value1 = 30   // 只能赋值一次
6.      println(value1)  // 输出，可读
8.     //使用var关键字定义变量，这个变量为可变变量，可读可写
9.     var  value2 :Int64
10.     value2 = 50
11.     println(value2)
12.     value2 = 60
13.     println(value2)
15.     return 0
16. }

复制代码

 

三、仓颉的数据类型

1.整数类型

整数类型分为有符号（signed）整数类型和无符号（unsigned）整数类型。
有符号数类型包罗Int64、Int32、Int16、Int8和IntNative，分别表现编码长度为64bit、32bit、16bit、8bit宁静台相关巨细的有符号整数值类型
无符号数类型包罗UInt64、UInt32、UInt16、UInt8和UIntNative，分别表现编码长度为64bit、32bit、16bit、8bit宁静台相关巨细的无符号整数值类型
具体长度如下：

1. package cjproject315
2. main(): Int64 {
3.   var value1 : Int64 = 10
5. //自动类型推断   is关键字 判断变量是哪个类型
6.   let  flag   = value1  is  Int64
7.   println(flag)
8.     return 0
9. }

复制代码

2.浮点类型

浮点类型包罗Float64、Float32、Float16，分别对应编码长度为64bit、32bit和16bit的浮点数，例如3.1415、0.12等。Float64的精度约为小数点后15位，Float32的精度约为小数点后6位，Float16的精度约为小数点后3位。

1. package cjproject315
2. import  std.format.*//导入仓颉格式化类
3. main(): Int64 {
4.    let  x1 :Float16  = 0.123456789123456789
5.     let  x2 :Float32  = 0.123456789123456789
6.     let  x3 :Float64  = 0.123456789123456789
8.      // 浮点类型，println默认输出是6位
9.     println(x1)
10.     println(x2)
12.     println(x1.format(".18")) //约为3位
13.     println(x2.format(".18"))  //约为6位
14.     println(x3.format(".18"))  //约为15位
15.     return 0
16. }

复制代码

3.布尔类型

布尔类型使用bool表现，表现逻辑中的真或假，即两个变量true和false
4.字符类型

字符类型使用Rune表现

1. package cjproject315
2. main(): Int64 {
3.     let  r1:Rune  = 'F'
4.     println(r1)
6.     let  r2 :Rune  = '%'
7.     println(r2)
9.     let  r3 :Rune  = '\n'
10.     println("\n你好")
11.     println(r3)
13.     let  r4 :Rune  = '\t'
14.     println("\t你好")
15.     println(r4)
17.     let r5 :Rune  = '\u{4ed3}'
18.     println(r5)
19.     return 0
20. }

复制代码

5.字符串类型

字符串类型用String表现，用于文本数据的表达。其分为单行字符串、多行字符串和多行原始字符串。
单行字符串的内容定义在一对单引号或一对双引号之内，引号中的内容可以是恣意数量的（除了非转义的双引号和单独出现的 \ 之外的）恣意字符。单行字符串字面量只能写在同一行，不能跨越多行。
多行字符串开头末端需各存在三个双引号（"""）或三个单引号（'''）。字面量的内容从开头的三个引号换行后的第一行开始，到末端的三个引号之前为止，之间的内容可以是恣意数量的（除单独出现的 \ 之外的）恣意字符,可以跨越多行。
多行原始字符串以一个或多个井号（#）和一个单引号（'）或双引号（"）开头，后跟恣意数量的合法字符，直到出现与字符串开头相同的引号和与字符串开头相同数量的井号为止。与多行字符串字面量不同的是，转义规则不实用于多行原始字符串字面量，字面量中的内容会维持原样。

1. package cjproject315
2. main(): Int64 {
3.      let  s1 :String  = "你好仓颉"
4.     println(s1)
5.     let s2 :String = """
6.     1111111111
7.     2222222222
8.     3333333333
9.     """
10.    println(s2)
11.    println("大家"+"好")
12.    println("大家好"+'a')
13.     var f1 :Float64 = 20.0008
14.     println("大家好" + 'h')
15.     //使用toString() 进行不同类型和字符串类型拼接
16.     println("大家好:"+ true.toString())
17.     println("大家好:"+ 10.toString())
18.     println("大家好:"+ f1.toString())
19.     //插值字符串 ${}
20.      println("大家好:${true}")
21.      println("大家好:${10}")
22.     println("大家好:${f1}")
23.     let s3: String = ##'好\n'##
24.     println(s3)
25.     return 0
26. }

复制代码

6.元组类型

元组（Tuple）可以将多个不同类型组合到一起，成为新的类型，表达方式为（类型1，类型2，类型3，类型4），可以是恣意类型，类型之间用逗号隔开，元组至少是二元的

1. package cjproject315
2. main(): Int64 {
3.     //定义一个元组类型  初始化赋值后，就不能修改大小和值
4.     var  tup : (String,Int64) = ("ssss",50)
5.     println(tup[0])
6.     println(tup[1])
7.      // 元组必须是二元的
8.     var  tup1 :(String,String) = ("南京","上海")
9.     println(tup1[0])
10.     return 0
11. }

复制代码

7.数组类型

在仓颉中使用Array<T>表现Array类型，此中T表现元素类型，T可以是恣意类型

1. package cjproject315
2. main(): Int64 {
3.     var a : Array<Int64> = [1,2,6]
4.     println(a)
5.     println("第一个数为${a[0]}")
6.     return 0
7. }

复制代码

8.区间类型

区间类型用于表现拥有固定步长的序列，使用Range<T>表现。当T被实例化不同的类型时（要求此类型必须支持关系操纵符，而且可以和Int64类型的值做加法），会得到不同的区间类型，每个区间类型的实例都会包含start、end和step 三个值。此中，start表现序列的起始值，end表现制止值，step表现序列中前后两个元素之间的差值（即步长），start和end的类型相同（即 T 被实例化的类型），step类型是Int64，且不能即是 0。
区间类型分为左闭右开和左闭右闭，“左闭右开”区间的格式是start..end: step；“左闭右闭”区间的格式是start..=end: step

1. package cjproject315
2. main(): Int64 {
3.   //仓颉<>泛型， 区间类型的值都是统一的数据类型
4.    // start..end: step   start:开始，end：结束； step：步长
5.    let  r1 : Range<Int64> = 0..6:1
6.    
7.    //仓颉的for循环的写法：for..in
8.    for(i in r1)
9.    {
10.       println("1.每个值为:${i}")
11.    }
12.     let  r2 : Range<Int64> = 0..=6:1
13.    for(i in r2)
14.    {
15.       println("2.每个值为:${i}")
16.    }
17.     let  r3 : Range<Int64> = 0..=6
18.     for(i in r3)
19.    {
20.       println("3.每个值为:${i}")
21.    }
22.     let  r4 : Range<Int64> = 10..=0:-2
23.     for(i in r4)
24.    {
25.       println("4.每个值为:${i}")
26.    }
27.     let  r5 : Range<Int64> = 10..=0:1  // 空区间
28.     for(i in r5)
29.    {
30.       println("5.每个值为:${i}")
31.    }
32.     return 0
33. }

复制代码

9.unit类型

对于那些只关心副作用而不关心值的表达式，它们的类型是Unit。例如，print函数、赋值表达式、复合赋值表达式、自增和自减表达式、循环表达式，它们的类型都是Unit。Unit类型只有一个值，也是它的字面量：()。除了赋值、判等和判不等外，Unit类型不支持其他操纵。

1. package cjproject315.chapter1
2. public  func  execValue():Unit
3. {
4.     println("输出")
5. }
6. public  func  execFun27()
7. {
8.    let  val  = execValue()
9.     println(val)
11. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。