Dart学习之基础语法

桃扇骨 2022-01-28 05:57 313阅读 0赞

### 原文地址：[https://www.jianshu.com/p/3d927a7bf020][https_www.jianshu.com_p_3d927a7bf020] ###

### 承接上一篇我们搭建了Dart环境，这一篇我们将学习Dart的基础语法。 ###

![20180531164159349][]

Dart的所有东西都是对象，包括数字，函数等。

它们都继承自Object，默认是都是null（包括数字），所以数字，字符串都可以调用各种方法。

**一、Dart中的关键字（56个）**

33个保留字（不能使用保留字作为标识符）

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>-</th> 
   <th>-</th> 
   <th>-</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>if</td> 
   <td>superdo</td> 
   <td>switch</td> 
   <td>assert</td> 
  </tr> 
  <tr> 
   <td>else</td> 
   <td>in</td> 
   <td>this</td> 
   <td>enum</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>throw</td> 
   <td>true</td> 
   <td>break</td> 
  </tr> 
  <tr> 
   <td>new</td> 
   <td>try</td> 
   <td>case</td> 
   <td>extends</td> 
  </tr> 
  <tr> 
   <td>null</td> 
   <td>typedef</td> 
   <td>catch</td> 
   <td>var</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>false</td> 
   <td>void</td> 
   <td>const</td> 
  </tr> 
  <tr> 
   <td>final</td> 
   <td>rethrow</td> 
   <td>while</td> 
   <td>continue</td> 
  </tr> 
  <tr> 
   <td>finally</td> 
   <td>return</td> 
   <td>with</td> 
   <td>for</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

> 内置标志符有：（17个）

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>-</th> 
   <th>-</th> 
   <th>-</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abstract</td> 
   <td>deferred</td> 
   <td>as</td> 
   <td>dynamic</td> 
  </tr> 
  <tr> 
   <td>covariant</td> 
   <td>export</td> 
   <td>external</td> 
   <td>factory</td> 
  </tr> 
  <tr> 
   <td>get</td> 
   <td>implements</td> 
   <td>import</td> 
   <td>library</td> 
  </tr> 
  <tr> 
   <td>operator</td> 
   <td>part</td> 
   <td>set</td> 
   <td>static</td> 
  </tr> 
  <tr> 
   <td>typedef</td> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

> Dart2相对于Dart1新增的,支持异步功能的关键字有：（6个）

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>-</th> 
   <th>-</th> 
   <th>-</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>async</td> 
   <td>async*</td> 
   <td>await</td> 
   <td>sync*</td> 
  </tr> 
  <tr> 
   <td>yield</td> 
   <td>yield*</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

> **跟java相比，Dart特有的关键字有：（25个）**

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>-</th> 
   <th>-</th> 
   <th>-</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>deferred</td> 
   <td>as</td> 
   <td>assert</td> 
   <td>dynamic</td> 
  </tr> 
  <tr> 
   <td>sync*</td> 
   <td>async</td> 
   <td>async*</td> 
   <td>in</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>await</td> 
   <td>export</td> 
   <td>library</td> 
  </tr> 
  <tr> 
   <td>external</td> 
   <td>typedef</td> 
   <td>factory</td> 
   <td>operator</td> 
  </tr> 
  <tr> 
   <td>var</td> 
   <td>part</td> 
   <td>const</td> 
   <td>rethrow</td> 
  </tr> 
  <tr> 
   <td>covariant</td> 
   <td>set</td> 
   <td>yield</td> 
   <td>get</td> 
  </tr> 
  <tr> 
   <td>yield*</td> 
  </tr> 
 </tbody> 
</table>

**二、变量和常量**

**（一）变量的声明，可以使用 var、Object 或 dynamic 关键字。**

创建变量并初始化变量实例：

1.  `//Dart语言本质上市动态类型语言，类型是可选的`
2.  `//可以使用var声明变量，也可以使用类型（比如String）来直接声明变量`
3.  `//一个变量也可以被赋予不同类型的对象`
4.  `//但是大多数情况，我们不会去改变一个变量的类型`
5.   
6.  `//字符串赋值的时候，可以使用单引号，也可以使用双引号。`
7.  `var str = "this is string vlaues.";`

变量存储引用。

**1.使用Object或dynamic关键字**

dynamic name = "张三";

调用的变量name包含对String值为“张三” 的对象的引用。  
name推断变量的类型是String，但可以通过指定它来更改该类型。

如果对象不限于单一类型（没有明确的类型），请使用Object或dynamic关键字

1.  `Object name1 = "小明";`
2.  `dynamic name2 = "老王";`

**2.显式声明将被推断的类型，比如String,int等。**

1.  `//可以使用String显示声明字符串类型`
2.  `String str1 = "dart str";`

（二）默认值

未初始化的变量的初始值为null（包括数字），因此数字、字符串都可以调用各种方法，这个我们上面有提到。

1.  `//我们先声明一个int类型的变量`
2.  `int intDefaultValue;`
3.  `//assert 是语言内置的断言函数，仅在检查模式下有效`
4.  `//在开发过程中，除非条件为真，否则会引发异常。（断言失败则程序立即终止）`
5.  `assert(intDefaultValue == null);`
6.  `//打印结果为null, 说明数字类型初始化值为null`
7.  `print(intDefaultValue);`

**（三）Final and const**

如果您从未打算更改一个变量，那么使用 final 或 const，不是var，也不是一个类型。  
一个 final 变量只能被设置一次;const 变量是一个编译时常量。(Const变量是隐式的final。)

final的顶级或类变量在第一次使用时被初始化。

**1.被final或者const修饰的变量，变量类型可以省略。**

1.  `//可以省略int类型的声明`
2.  `final test = 111;`
3.  `//等同于上面`
4.  `final int test = 111;`

**2.被 final 或 const 修饰的变量无法再去修改其值。**

1.  `//被final修饰的变量的值无法被改变`
2.  `final test1 = "test";`
3.  `//这样写会提示'test1', a final variable, can only be set once`
4.  `test1 = "test1";`
5.   
6.  `//被const修饰的变量不能被重新赋值`
7.  `const test2 = 20.02;`
8.  `//这样写会提示 Constant variables can't be assigned a value`
9.  `test2 = 23.33;`

**3.注意：flnal 或者 const 不能和 var 同时使用**

1.  `//会提示：Expected an identifier，`
2.  `//因为var是用来修饰变量的，而final修饰的变量称之为常量（不能改变，只能赋值一次），所以不能这么混合使用吧（我是这么理解的）`
3.  `final var test3 = true;`
4.   
5.  `//这一句提示这个：The const variable 'var' must be initialized`
6.  `//The name 'var' is already defined.`
7.  `const var test4 = 'test4';`

**4.常量如果是类级别的，请使用 static const**

1.  `class Test{`
2.  `static const name = "test";`
3.   
4.  `static main(){`
5.  `//这里会报错：Undefined name 'static'`
6.  `//static类型的变量是属于类的所以在类里面，方法之外`
7.  `static const name = "test";`
8.  `}`
9.  `}`

**5.常量的运算**

1.  `final speed = 200;//(km/h)`
2.  `final double distance = 2.5 * speed; // 距离 = 速度 * 时间`
3.   
4.  `const speed1 = 200;`
5.  `const double distance1 = 2.5 * speed1;`

**6.const关键字不只是声明常数变量。也可以使用它来创建常量值，以及声明创建常量值的构造函数。 任何变量都可以有一个常量值。**

1.  `//注意：[] 创建的是一个空的list集合`
2.  `// const[] 创建一个空的、不可变的列表（EIL）`
3.  `var varList = const []; //varList 当前时一个EIL`
4.  `final finalList = const []; //finalList一直是EIL`
5.  `const constList = const []; //constList是一个编译时常量的EIL`
6.   
7.  `//可以更改非final、非const变量的值`
8.  `//即使它曾经具有const值也可以改变`
9.  `varList = [111, 222, 333];`
10.  
11. `// 不能更改final变量或const变量的值`
12. `// 这样写，编译器提示：a final variable, can only be set once`
13. `// finalList = [];`
14. `// 这样写，编译器提示：Constant variables can't be assigned a value`
15. `// constList = [];`

**7.只要任何插值表达式是一个计算结果为null或数字，字符串或布尔值的编译时常量，那么文字字符串就是编译时常量。(关于$表达式和不同的数据类型后面会讲解。)**

1.  `//这些是常量字符串`
2.  `const aConstNum = 0;`
3.  `const aConstBool = true;`
4.  `const aConstString = 'a const string';`
5.   
6.  `//这些不是常量字符串`
7.  `var aNum = 0;`
8.  `var aBool = true;`
9.  `var aString = 'a string';`
10.  
11. `//编译通过`
12. `const validConstString = '$aConstNum $aConstBool $aConstString';`
13. `var validString = '$aNum $aBool $aString';`
14. `var invalidString = '$aNum $aBool $aConstString';`
15.  
16. `//编译器报错`
17. `//报错：Const variables must be initialized with a constant value`
18. `//const常量必须用const类型的值初始化`
19. `const invalidConstString = '$aConstNum $aConstBool $aNum';`

**8.到这里final 和 const我们就介绍完毕了，那么相信有些人肯定会有疑问，final 和 const到底有什么区别呢？带着这个疑问我们先看下面这段代码。**

1.  `//编译器通过`
2.  `var a = 1;`
3.  `final f = 3;`
4.  `const d = 2;`
5.  `final b = a;`
6.  `const c = d;`
7.  `//编译器报错`
8.  `//报错：Const variables must be initialized with a constant value`
9.  `const e = a;`
10. `const g = f;`

**从上面代码我们可以看出，final 和 const的一个区别：**

final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且赋值必需为编译时常量。

**第二个区别是它们初始化的时机不同：**

final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。

![20180601165058817][]

# 三、特殊数据类型 #

Dart中支持以下特殊类型：

1.  `numbers 数字`
2.  `strings 字符串`
3.  `booleans 布尔`
4.  `lists (also known as arrays) list集合（也称为数组）`
5.  `maps map集合`
6.  `runes (for expressing Unicode characters in a string) 字符（用于在字符串中表示Unicode字符）`
7.  `symbols 符号`

（一）num 数字类型

num是数字类型的父类，有两个子类 int 和 double。  
num类型包括基本的运算符，如+,-,/和\*，位运算符，如>>，在int类中定义。

如果num和它的子类没有你要找的东西，math库可能会找到。比如你会发现abs(),ceil()和floor()等方法。

**1.int类型**

int表示整数，int的取值不大于64位，具体取决于平台。在Dart VM上，值可以从 -2的63次方 到 2的63次方减1.

整数是没有小数点的数字。示例如下：

1.  `int intNum1 = 10 ;`
2.  `print(intNum1);`
3.  `int intNum2 = 0xDEADBEEF ;`
4.  `print(intNum2);`

**2.double类型**

64位（双精度）浮点数，如IEEE 754标准所规定。

如果一个数字包含一个小数，那么它就是一个double类型。示例如下：

1.  `double doubleNum1 = 1.1;`
2.  `print(doubleNum1);`
3.  `double doubleNum2 = 1.42e5;`
4.  `print(doubleNum2);`

**3.String类型**

Dart里面的String是一系列 UTF-16代码单元。

**（1）可以使用单引号或双引号来创建一个字符串。**

1.  `String str1 = '单引号基本使用demo.';`
2.  `String str2 = "双引号基本使用demo.";`

**（2）单引号或者双引号里面嵌套使用引号。**

1.  `//单引号里面嵌套单引号，必须在前面加反斜杠`
2.  `String str3 = '双引号里面有单引号it\'s，必须在前面加反斜杠.';`
3.  `//双引号里面嵌套单引号（正常使用）`
4.  `String str4 = "双引号里面有单引号it's.";`
5.  `//单引号里面嵌套双引号（正常使用）`
6.  `String str5 = '单引号里面有双引号，编程开发初学必备语句"hello world"';`
7.  `//双引号里面嵌套双引号，必须在前面加反斜杠`
8.  `String str6 = "双引号里面有双引号，编程开发初学必备语句\"hello world\"";`

**（3）多个字符串相邻中间的空格问题：**

经测试发现，除了单引号嵌套单引号或者双引号嵌套双引号不允许出现空串之外，其余的几种情况都是可以运行的。

示例如下：

1.  `// 这个会报错`
2.  `//String blankStr1 = 'hello''''world';`
3.  `// 这两个运行正常`
4.  `String blankStr2 = 'hello'' ''world'; //结果： hello world`
5.  `String blankStr3 = 'hello''_''world'; //结果： hello_world`
6.   
7.  `// 这个会报错`
8.  `//String blankStr4 = "hello""""world";`
9.  `// 这两个运行正常`
10. `String blankStr5 = "hello"" ""world"; //结果： hello world`
11. `String blankStr6 = "hello""_""world"; //结果： hello_world`
12.  
13. `//单引号里面有双引号，混合使用运行正常`
14. `String blankStr7 = 'hello""""world'; //结果： hello""""world`
15. `String blankStr8 = 'hello"" ""world'; //结果： hello"" ""world`
16. `String blankStr9 = 'hello""_""world'; //结果： hello""_""world`
17.  
18. `//双引号里面有单引号，混合使用运行正常`
19. `String blankStr10 = "hello''''world"; //结果： hello''''world`
20. `String blankStr11 = "hello'' ''world"; //结果： hello'' ''world`
21. `String blankStr12 = "hello''_''world"; //结果： hello''_''world`

**（4）可以使用相邻字符串文字或+ 运算符连接字符串：**

1.  `//直接把相邻字符串写在一起，就可以连接字符串了。`
2.  `String connectionStr1 = '字符串连接'`
3.  `'甚至可以在'`
4.  `'换行的时候进行。';`
5.   
6.  `//用+把相邻字符串连接起来。`
7.  `String connectionStr2 = '字符串连接'`
8.  `+ '甚至可以在'`
9.  `+ '换行的时候进行。';`
10.  
11. `//使用单引号或双引号的三引号：`
12. `String connectionStr3 = '''`
13. `你可以创建`
14. `像这样的多行字符串。`
15. `''' ;`
16.  
17. `String connectionStr4 = """这也是一个`
18. `多行字符串。""";`

**（5）关于转义符号的使用**

声明raw字符串（前缀为r），在字符串前加字符“r”，或者在\\前面再加一个\\，  
可以避免“\\”的转义作用，在正则表达式里特别有用

举例如下：

1.  `print(r"换行符：\n"); //这个结果是 换行符：\n`
2.  `print("换行符：\\n"); //这个结果是 换行符：\n`
3.  `print("换行符：\n"); //这个结果是 换行符：`

**（6）可以使用$\{表达式\}将表达式的值放入字符串中。如果表达式是标识符，则可以跳过\{\}。**

**为了获得对应于object的字符串，Dart调用object的toString()方法。**

1.  `String replaceStr1 = '字符串连接';`
2.  `print('$replaceStr1'`
3.  `+ '甚至可以在换行的时候进行。' == '字符串连接'`
4.  `+ '甚至可以在换行的时候进行。');`
5.   
6.  `String replaceStr2 = 'Android Studio';`
7.  `print('你知道' +`
8.  `'${replaceStr2.toUpperCase()}'`
9.  `+ '最新版本是多少吗？' ==`
10. `'你知道ANDROID STUDIO最新版本是多少吗？');`

注：  
==操作符测试两个对象是否相等。如果两个字符串包含相同的代码单元序列，那么它们是等效的。

（三）bool 布尔值

为了表示布尔值，Dart有一个名为的类型bool。  
只有两个对象具有bool类型：true和false，它们都是编译时常量。

Dart的类型安全意味着您不能使用if（nonbooleanValue）或assert（nonbooleanValue）等代码。

相反，Dart使用的是显式的检查值，如下所示：

1.  `// 检查是否为空字符串`
2.  `var fullName = '';`
3.  `assert(fullName.isEmpty);`
4.   
5.  `// 检查0`
6.  `var hitPoints = 0;`
7.  `assert(hitPoints <= 0);`
8.   
9.  `// 检查是否为null`
10. `var unicorn;`
11. `assert(unicorn == null);`
12.  
13. `// 检查是否为NaN`
14. `var iMeantToDoThis = 0 / 0;`
15. `assert(iMeantToDoThis.isNaN);`

assert 是语言内置的断言函数，仅在检查模式下有效

在开发过程中， 除非条件为真，否则会引发异常。(断言失败则程序立刻终止)。

（四）list 集合（也称为数组）

几乎所有编程语言中最常见的集合可能是数组或有序对象组。  
在Dart中，数组是List对象，因此大多数人只是将它们称为List。

Dart list文字看起来像JavaScript数组文字。 以下是一个简单的Dart列表：

1.  `//创建一个int类型的list`
2.  `List list = [10, 7, 23];`
3.  `print(list);`

要创建一个编译时常量const的list，示例如下：

List constantList = const[10,3,15];

**注意事项：**

1.  `1.可以直接打印list包括list的元素，list也是一个对象。但是java必须遍历才能打印list，直接打印是地址值。`
2.  `2.和java一样list里面的元素必须保持类型一致，不一致就会报错。`
3.  `3.和java一样list的角标从0开始。`

（五）map集合

一般来说，map是将键和值相关联的对象。键和值都可以是任何类型的对象。

每个键只出现一次，但你可以多次使用相同的值。Dart支持map由map文字和map类型提供。

**注意：**

和java一样，map里面的元素必须保持类型一致，不一致就会报错。

（六）runes (for expressing Unicode characters in a string) 字符（用于在字符串中表示Unicode字符）

（七）symbols 符号

### 参考： **[Dart最大的中文教程社区http://www.cndartlang.com/][Dart_http_www.cndartlang.com]** ###

[https_www.jianshu.com_p_3d927a7bf020]: https://www.jianshu.com/p/3d927a7bf020
[20180531164159349]: /images/20220128/0f35ffd69e8e43b9be48409cc4c34e23.png
[20180601165058817]: /images/20220128/9b5172981c6d4011b98971100e62de08.png
[Dart_http_www.cndartlang.com]: http://www.cndartlang.com/