Dart学习之基础语法

叁歲伎倆 2022-05-23 02:54 234阅读 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 关键字。**

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

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

变量存储引用。

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

dynamic name = "张三";

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

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

Object name1 = "小明";
    dynamic name2 = "老王";

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

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

（二）默认值

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

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

**（三）Final and const**

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

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

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

//可以省略int类型的声明
    final test = 111;
    //等同于上面
    final int test = 111;

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

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

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

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

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

class Test{
      static const name = "test";
    
      static main(){
        //这里会报错：Undefined name 'static'
        //static类型的变量是属于类的所以在类里面，方法之外
        static const name = "test";
      }
    }

**5.常量的运算**

final speed = 200;//(km/h)
    final double distance = 2.5 * speed; // 距离 = 速度 * 时间
      
    const speed1 = 200;
    const double distance1 = 2.5 * speed1;

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

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

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

//这些是常量字符串
    const aConstNum = 0;
    const aConstBool = true;
    const aConstString = 'a const string';
    
    //这些不是常量字符串
    var aNum = 0;
    var aBool = true;
    var aString = 'a string';
    
    //编译通过
    const validConstString = '$aConstNum $aConstBool $aConstString';
    var validString = '$aNum $aBool $aString';
    var invalidString = '$aNum $aBool $aConstString';
      
    //编译器报错
    //报错：Const variables must be initialized with a constant value
    //const常量必须用const类型的值初始化
    const invalidConstString = '$aConstNum $aConstBool $aNum';

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

//编译器通过
    var a = 1;
    final f = 3;
    const d = 2;
    final b = a;
    const c = d;
    //编译器报错
    //报错：Const variables must be initialized with a constant value
    const e = a;
    const g = f;

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

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

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

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

![20180601165058817][]

# 三、特殊数据类型 #

**Dart中支持以下特殊类型：**

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

（一）num 数字类型

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

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

**1.int类型**

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

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

int intNum1 = 10 ;
    print(intNum1);
    int intNum2 = 0xDEADBEEF ;
    print(intNum2);

**2.double类型**

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

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

double doubleNum1 = 1.1;
    print(doubleNum1);
    double doubleNum2 = 1.42e5;
    print(doubleNum2);

**3.String类型**

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

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

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

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

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

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

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

示例如下：

// 这个会报错
    //String blankStr1 = 'hello''''world';
    // 这两个运行正常
    String blankStr2 = 'hello'' ''world'; //结果： hello world
    String blankStr3 = 'hello''_''world'; //结果： hello_world
    
    // 这个会报错
    //String blankStr4 = "hello""""world";
    // 这两个运行正常
    String blankStr5 = "hello"" ""world"; //结果： hello world
    String blankStr6 = "hello""_""world"; //结果： hello_world
    
    //单引号里面有双引号，混合使用运行正常
    String blankStr7 = 'hello""""world'; //结果： hello""""world
    String blankStr8 = 'hello"" ""world'; //结果： hello"" ""world
    String blankStr9 = 'hello""_""world'; //结果： hello""_""world
    
    //双引号里面有单引号，混合使用运行正常
    String blankStr10 = "hello''''world"; //结果： hello''''world
    String blankStr11 = "hello'' ''world"; //结果： hello'' ''world
    String blankStr12 = "hello''_''world"; //结果： hello''_''world

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

//直接把相邻字符串写在一起，就可以连接字符串了。
    String connectionStr1 =  '字符串连接'
    '甚至可以在'
    '换行的时候进行。';
    
    //用+把相邻字符串连接起来。
    String connectionStr2 =  '字符串连接'
      + '甚至可以在'
      + '换行的时候进行。';
    
    //使用单引号或双引号的三引号：
    String connectionStr3 = ''' 
      你可以创建
      像这样的多行字符串。
      ''' ;
    
    String connectionStr4 = """这也是一个
      多行字符串。""";

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

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

举例如下：

print(r"换行符：\n"); //这个结果是 换行符：\n
    print("换行符：\\n"); //这个结果是 换行符：\n
    print("换行符：\n");  //这个结果是 换行符：

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

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

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

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

（三）bool 布尔值

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

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

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

// 检查是否为空字符串
    var fullName = '';
    assert(fullName.isEmpty);
    
    // 检查0
    var hitPoints = 0;
    assert(hitPoints <= 0);
    
    // 检查是否为null
    var unicorn;
    assert(unicorn == null);
    
    // 检查是否为NaN
    var iMeantToDoThis = 0 / 0;
    assert(iMeantToDoThis.isNaN);

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

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

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

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

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

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

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

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

**注意事项：**

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

（五）map集合

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

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

**注意：**

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

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

（七）symbols 符号

### **下一篇我们学习：[Dart学习之函数][Dart]** ###

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

[https_www.jianshu.com_p_3d927a7bf020]: https://www.jianshu.com/p/3d927a7bf020
[20180531164159349]: /images/20220523/34c237e46b14412193ee82f86d05b7cd.png
[20180601165058817]: /images/20220523/077bba56386a475c96a59720c7f38821.png
[Dart]: https://blog.csdn.net/lyh1299259684/article/details/80565419
[Dart_http_www.cndartlang.com]: http://www.cndartlang.com/