dart基础(粗总结)

缺乏、安全感 2021-12-18 20:37 174阅读 0赞

### 重要的概念 ###

*  每个变量都是一个对象，每个对象是一个类的实例。甚至数字，函数，和null都是对象。所有对象都继承自Object类
 *  Dart动态类型语言, 尽量给变量定义一个类型，会更安全，没有显示定义类型的变量在 debug 模式下会类型会是 dynamic(动态的)。
 *  Dart 在 running 之前解析你的所有代码，指定数据类型和编译时的常量，可以提高运行速度。
 *  Dart中的类和接口是统一的，类即接口，你可以继承一个类，也可以实现一个类（接口），自然也包含了良好的面向对象和并发编程的支持。
 *  Dart 提供了顶级函数(如：main())。
 *  与Java不同，Dart不具备关键字public，protected和private。如果一个标识符以下划线（\_）开始，那么它和它的库都是私有的。
 *  没有初始化的变量都会被赋予默认值 null。
 *  指定静态类型（如num前面的例子中）讲清意图，用 tools 开启静态检查，但它是可选的。 （可能注意到当你调试代码，没有指定类型的变量会得到一个特殊的类型： dynamic ）
 *  final的值只能被设定一次。const 是一个编译时的常量，可以通过 const 来创建常量值，var c=const\[\];，这里 c 还是一个变量，只是被赋值了一个常量值，它还是可以赋其它值。实例变量可以是 final，但不能是 const。
 *  Dart有两种运行模式：生产 (production) 和检查 (checked) 。我们建议在检查模式开发和调试，并将其部署到生产模式。
 *  Production mode是Dart程序一个速度优化的默认运行模式。Production mode忽略 断言语句（assert statements） 和静态类型。
 *  Checked mode 是开发人员友好的方式，可以帮助你在运行时捕捉一些类型的错误。例如，如果分配一个非数字来声明为一个 num 变量，然后在检查模式会抛出异常。
 *  编程语言并不是孤立存在的，Dart也是这样，他由语言规范、虚拟机、类库和工具等组成：
 *   *  SDK：SDK 包含 Dart VM、dart2js、Pub、库和工具。
 *   *  Dartium：内嵌 Dart VM 的 Chromium ，可以在浏览器中直接执行 dart 代码。
 *   *  Dart2js：将 Dart 代码编译为 JavaScript 的工具。
 *   *  Dart Editor：基于 Eclipse 的全功能 IDE，并包含以上所有工具。支持代码补全、代码导航、快速修正、重构、调试等功能。

### [Keywords][] ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpcGhvbjM2NTA_size_16_color_FFFFFF_t_70]

### 注释 `// 、 /* */` ###

### 变量声明 ###

// 声明
    var name = 'qiphon'
    
    // dynamic 声明的变量可以是任何类型
    dynamic name = 'qiphon'
    
    // 声明一个String类型的变量
    String name = 'qiphon'

##### final & const #####

*  如果变量不想被改变请使用 final 或 const 替代 var
 *  final 变量只能被初始化一次; const变量是一个编译时常量，(Const变量是隐式的final)
 *  final的顶级或类变量在第一次使用时被初始化。

// 被final或者const修饰的变量，变量类型可以省略，建议指定数据类型。
    //可以省略String这个类型声明
     final name = "Bob";
     final String name1  = "张三";
     
     const name2 = "alex";
     const String name3 = "李四";
    
    // 常量如果是类级别的，请使用 static const
    static const String name3 = 'Tom';

### 数据类型 ###

> number （int 、double）、String 、boolean 、List(也可以叫array) 、Map 、set 、rune 、 symbol

1.  number

*  number 有2个子类 ，int（）、double
 *  int 根据平台不同，整数值不大于64位。在dart VM上，取值范围（-263 ～ 263-1），编译成JavaScript的dart使用JavaScript代码，取值范围 （-253 ～ 253 -1）
 *  double 64位 \*（双精度）浮点数
 *  无论int和double是num的子类型。该数字类型包括基本运算符，如+， - ，/和\*，以及位运算符，例如 >>。
 *  num的类型也是在那里你会发现 abs()，ceil()，和 floor() ，以及其他的方法。如果num及其亚型没有你要找的内容，Math库可能有。

如何把字符串转换成一个数字，反之亦然：

// String -> int
    var one = int.parse('1');
    assert(one == 1);
    
    // String -> double
    var onePointOne = double.parse('1.1');
    assert(onePointOne == 1.1);
    
    // int -> String
    String oneAsString = 1.toString();
    assert(oneAsString == '1');
    
    // double -> String
    String piAsString = 3.14159.toStringAsFixed(2);
    assert(piAsString == '3.14');

int 类型规定了传统按位移位（<<，>>），与（＆）和或（|）运算符。例如：

assert((3 << 1) == 6);  // 0011 << 1 == 0110
    assert((3 >> 1) == 1);  // 0011 >> 1 == 0001
    assert((3 | 4)  == 7);  // 0011 | 0100 == 0111

1.  String

> Dart字符串是UTF-16编码单元的序列。可以使用单或双引号来创建一个字符串：

var s1 = 'Single quotes work well for string literals.';
    var s2 = "Double quotes work just as well.";
    var s3 = 'It\'s easy to escape the string delimiter.';
    var s4 = "It's even easier to use the other delimiter.";
    
    String singleString = 'aaa';
     String doubleString = "bbb";
    // 双引号嵌套单引号
     String dsString = "${singleString.toUpperCase()} abc 'aaa' $doubleString.toUpperCase()";
    
    // 多行字符串写法 
    var s1 = '''
    You can create
    multi-line strings like this one.
    ''';
    
    var s2 = """This is also a
    multi-line string.""";
    
    // 等号判断字符串，+ 号连接字符串
    var s1 = 'String '
        'concatenation'
        " works even over line breaks.";
    assert(s1 ==
        'String concatenation works even over '
            'line breaks.');
    
    var s2 = 'The + operator ' + 'works, as well.';
    assert(s2 == 'The + operator works, as well.');

1.  Boolean

*  当Dart需要一个布尔值，仅值 true 被视为真。所有其他值被视为假。不像在 JavaScript 中，值，如1，“aString”，someObject 都视为假的。
 *  只有在生产模式，而不是检查模式，前面的两个示例工作。在检查模式下，一个例外是，当需要一个boolean值，而此时一个非布尔时使用，异常会被抛出。 Dart针对布尔值的设计是为了避免可能出现的时候许多值可以被视为真而产生怪异的行为。这意味着，不能使用代码像if（nonbooleanValue），应该明确检查值。

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

1.  list

*  Dart列表书面上看起来像JavaScript数组常量。 这里有一个简单的Dart列表：
 *  列表使用从零开始的索引，其中0为第一个元素,list.length-1是最后一个元素的索引。你可以得到一个列表的长度，就像在JavaScript中一样
 *  和java一样list里面的元素必须保持类型一致，不一致就会报错。

var list = [1, 2, 3];
    assert(list.length == 3);
    assert(list[1] == 2)
    
    // list 中的扩展运算符
    var list = [1, 2, 3];
    var list2 = [0, ...list];
    assert(list2.length == 4);
    
     // 使用List的构造函数，也可以添加int参数，表示List固定长度，不能进行添加 删除操作
     var fruits = new List();
     
     // 添加元素
     fruits.add('apples');
     
     // 添加多个元素
     fruits.addAll(['oranges', 'bananas']);
     
     List subFruits = ['apples', 'oranges', 'banans'];
     // 添加多个元素
     fruits.addAll(subFruits);
     
     // 输出： [apples, oranges, bananas, apples, oranges, banans]
     print(fruits);
     
     // 获取List的长度
     print(fruits.length);
     
     // 获取第一个元素
     print(fruits.first);
     
     // 获取元素最后一个元素
     print(fruits.last);
     
     // 利用索引获取元素
     print(fruits[0]);
     
     // 查找某个元素的索引号
     print(fruits.indexOf('apples'));
     
     // 删除指定位置的元素，返回删除的元素
     print(fruits.removeAt(0));
    
     // 删除指定元素,成功返回true，失败返回false
     // 如果集合里面有多个“apples”, 只会删除集合中第一个改元素
     fruits.remove('apples');
    
     // 删除最后一个元素，返回删除的元素
     fruits.removeLast();
    
     // 删除指定范围(索引)元素，含头不含尾
     fruits.removeRange(start,end);
    
     // 删除指定条件的元素(这里是元素长度大于6)
     fruits.removeWhere((item) => item.length >6)；
    
     // 删除所有的元素
     fruits.clear();
    
    
    
    // 为了避免扩展运算符右侧的对象为null，可以使用 （...?）
    var list;
    var list2 = [0, ...?list];
    assert(list2.length == 1);

[更多扩展运算符用法看这里][Link 1]

Dart 2.3 在集合中添加了 if 和 for

var nav = [
      'Home',
      'Furniture',
      'Plants',
      if (promoActive) 'Outlet'
    ];
    
    var listOfInts = [1, 2, 3];
    var listOfStrings = [
      '#0',
      for (var i in listOfInts) '#$i'
    ];
    assert(listOfStrings[1] == '#1');

[更多集合用法看这里][Link 2]

1.  set

*  dart 中的set是一个不包含重复元素的无序的集合（ Dart 2.2 以上 ）
 *  如果设置 `Set<String>` 若set集合中含有string外的值，（analyzer or runtime ）阶段会报错

set实例：

1.  Map

*  map 是一个含有key 和value的对象，key 不能重复，value可以重复
 *  Dart 2.0以后 ，map 的new关键字是可选的，所以 new Map() 等同 Map()
 *  Dart 2.3 以后，map支持 扩展运算符（ …和 …? ）
 *  如下面的例子 ，gifts has the type `Map<String, String>` and nobleGases has the type `Map<int, String>`，如若类型错误，就会在analyzer or runtime时报错

1.  Rune

*  Rune 是UTF-32编码的字符串，通常是 `\uxxxx` 这个样子的，超过或不足4位的时候用花括号包起来

♥ is \u2665
    ? is \u{1f600}

1.  Symbol

*  一个符号对象表示在Dart程序中声明的操作符或标识。你可能不会需要使用这些符号，但他们对于由名字指向的API是很有用的，因为时常要改变的是标识符的名字，而不是标识符的符号。

// 使用符号的文本，只是＃后跟标识符：
    #radix
    #bar

### 运算符 ###

*  在之前的操作符表中，操作符的优先级由其所在行定义，上面行内的操作符优先级大于下面行内的操作符。例如，乘法类型操作符%的优先级比等价操作符`==`要高，而`==`操作符的优先级又比逻辑与操作符&&要高。这些操作符的优先级顺序将在下面的两行代码中体现出来

<table> 
 <thead> 
  <tr> 
   <th>描述</th> 
   <th>操作符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>一元后置操作符</td> 
   <td>expr++ expr-- () [] . ?.</td> 
  </tr> 
  <tr> 
   <td>一元前置操作符</td> 
   <td>-expr !expr ~expr ++expr --expr</td> 
  </tr> 
  <tr> 
   <td>乘法类型</td> 
   <td>* / % ~/</td> 
  </tr> 
  <tr> 
   <td>加法类型</td> 
   <td>+ -</td> 
  </tr> 
  <tr> 
   <td>位操作符</td> 
   <td>&lt;&lt; &gt;&gt;</td> 
  </tr> 
  <tr> 
   <td>按位与</td> 
   <td>&amp;</td> 
  </tr> 
  <tr> 
   <td>按位异或</td> 
   <td>^</td> 
  </tr> 
  <tr> 
   <td>按为或</td> 
   <td><code>|</code></td> 
  </tr> 
  <tr> 
   <td>比较和类型测试</td> 
   <td>&gt;= &lt;= &gt; &lt; as is is!</td> 
  </tr> 
  <tr> 
   <td>等价</td> 
   <td>== !=</td> 
  </tr> 
  <tr> 
   <td>逻辑与</td> 
   <td>&amp;&amp;</td> 
  </tr> 
  <tr> 
   <td>逻辑或</td> 
   <td><code>||</code></td> 
  </tr> 
  <tr> 
   <td>条件运算符</td> 
   <td>expr1 ? expr2 : expr3</td> 
  </tr> 
  <tr> 
   <td>级联运算符</td> 
   <td><code>..</code></td> 
  </tr> 
  <tr> 
   <td>赋值</td> 
   <td>= *= /= += -= &amp;= ^= etc.</td> 
  </tr> 
 </tbody> 
</table>

a++
    a + b
    a = b
    a == b
    c ? a : b
    a is T

算术运算符  
Dart 支持一些常规的算术运算符，具体如下表所示：

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减</td> 
  </tr> 
  <tr> 
   <td>-expr</td> 
   <td>一元减号，也被命名为负号（使后面表达式的值反过来）</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除</td> 
  </tr> 
  <tr> 
   <td>~/</td> 
   <td>返回一个整数值的除法</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余，除法剩下的余数</td> 
  </tr> 
 </tbody> 
</table>

assert(2 + 3 == 5);
    assert(2 - 3 == -1);
    assert(2 * 3 == 6);
    assert(5 / 2 == 2.5); // 结果是double类型
    assert(5 ~/ 2 == 2); // 结果是一个整数
    assert(5 % 2 == 1); // 余数
    
    print('5/2 = ${5~/2} r ${5%2}'); // 5/2 = 2 r 1

Dart 同时也支持前缀和后缀自增以及自减运算符。

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>++var</td> 
   <td>var = var + 1（表达式中相当于var + 1）</td> 
  </tr> 
  <tr> 
   <td>var++</td> 
   <td>var = var + 1（表达式中相当于var）</td> 
  </tr> 
  <tr> 
   <td>–var</td> 
   <td>var = var - 1（表达式中相当于var - 1）</td> 
  </tr> 
  <tr> 
   <td>var–</td> 
   <td>var = var - 1（表达式中相当于var）</td> 
  </tr> 
 </tbody> 
</table>

var a, b;
    
    a = 0; 
    b = ++a; // 在b获得其值前先自增a
    assert(a == b); // 1 == 1
    
    a = 0;
    b = a++; // 在b获得其值后自增a
    assert(a != b); // 1 != 0
    
    a = 0;
    b = --a; // 在b获得其值前自减a
    assert(a == b); // -1 == -1
    
    a = 0;
    b = a--; // 在b获得其值后自减a
    assert(a != b); // -1 != 0

等价和关系操作符

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>等价；后面讨论中会有详细说明</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等价</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
  </tr> 
 </tbody> 
</table>

如果想测试两个对象 x 和 y 是不是同一个对象，使用==运算符。
    （在少数情况下如果你想比较两个对象是否相等，需要使用 identical 来替代==。)
    接下来将会说明==操作符是怎样起作用的：
    
    如果 x 或者 y 为 null，两者都为 null 则返回 true， 
    只有其中一个为 null 则返回 false。
    返回一个函数调用的结果：x.==(y)。
    （这个调用是正确的，像==这样的运算符实际上是由第一个操作数所调用的一个方法。
    你可以重写大部分运算符，关于这部分的内容你将在 重载操作符 中看到。
    
    assert(2 == 2);
    assert(2 != 3);
    assert(3 > 2);
    assert(2 < 3);
    assert(3 >= 3);
    assert(2 <= 3);

类型测试操作符

as、is 和 is! 操作符在运行时用于检查类型非常便捷。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>as</td> 
   <td>类型转换</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>当对象是相应类型时返回 true</td> 
  </tr> 
  <tr> 
   <td>as</td> 
   <td>当对象不是相应类型时返回 true</td> 
  </tr> 
 </tbody> 
</table>

如果obj实现了T所定义的接口，那么obj is T将返回 true。
    比如，obj is Object必然返回 true。
    
    使用as操作符可以把一个对象转换为特定类型。
    一般来说，如果在is测试之后还有一些关于对象的表达式，
    你可以把as``当做是is测试的一种简写。考虑下面这段代码：
    
    if (emp is Person) {
      // Type check
      emp.firstName = 'Bob';
    }
    
    (emp as Person).firstName = 'Bob';

注意：上面两段代码并不相等。如果emp的值为 null 或者不是 Person 的一个对象，第一段代码不会做任何事情，第二段代码将会报错 。

赋值运算符

=	-=	/-	%=	>>=	^=
    +=	*=	~/=	<<=	&=	|
    
    
    var a = 2;           // 赋值运算符 =
    a *= 3;              // 赋值并相乘： a = a * 3
    assert(a == 6);

位操作与移位运算符

*  在 Dart 中，你可以直接操作数字的每一个字位。一般来说，你会使用位操作与移位运算符来对整数进行操作。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>&amp;</code></td> 
   <td>与</td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td>或</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或</td> 
  </tr> 
  <tr> 
   <td>~expr</td> 
   <td>二元按位取补（1变成0，0变成1）</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移</td> 
  </tr> 
 </tbody> 
</table>

final value = 0x22;
    final bitmask = 0x0f;
    
    assert((value & bitmask)  == 0x02);  // 与
    assert((value & ~bitmask) == 0x20);  // 与非
    assert((value | bitmask)  == 0x2f);  // 或
    assert((value ^ bitmask)  == 0x2d);  // 异或
    assert((value << 4)       == 0x220); // 左移
    assert((value >> 4)       == 0x02);  // 右移

其他运算符

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>名称</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>（）</td> 
   <td>函数应用</td> 
   <td>表示函数调用</td> 
  </tr> 
  <tr> 
   <td>[]</td> 
   <td>目录</td> 
   <td>列表中制定索引处的值</td> 
  </tr> 
  <tr> 
   <td>expr1 ? expr2 : expr3</td> 
   <td>条件运算符</td> 
   <td>expr1 为真则返回 expr2，否则返回 expr3</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>成员访问</td> 
   <td>表达式的属性，例如：foo.bar从foo中选择了bar属性</td> 
  </tr> 
  <tr> 
   <td><code>..</code></td> 
   <td>级联</td> 
   <td>允许你在单个对象的成员上执行多个操作，具体可见 类</td> 
  </tr> 
 </tbody> 
</table>

querySelector('#confirm') // Get an object.
      ..text = 'Confirm' // Use its members.
      ..classes.add('important')
      ..onClick.listen((e) => window.alert('Confirmed!'));

##### 以上笔记参考 #####

*  网友 [GuoDongW][]
 *  [dart Home][]
 *  [极客学院][Link 3]

[Keywords]: https://dart.dev/guides/language/language-tour#keywords
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpcGhvbjM2NTA_size_16_color_FFFFFF_t_70]: /images/20211219/2b8aec50018a43d38f4a33f9f60c5c66.png
[Link 1]: https://github.com/dart-lang/language/blob/master/accepted/2.3/spread-collections/feature-specification.md
[Link 2]: https://github.com/dart-lang/language/blob/master/accepted/2.3/control-flow-collections/feature-specification.md
[GuoDongW]: https://www.jianshu.com/p/9e5f4c81cc7d
[dart Home]: https://dart.dev/guides/language/language-tour
[Link 3]: http://wiki.jikexueyuan.com/project/dart-language-tour/variables.html