var name = 'Bob';

//指定为动态类型

dynamic name = 'Bob';

//显示指定为字符串类型

String name = 'Bob';

int lineCount;

assert(lineCount == null); //结果为true 

提示： 在生产环境代码中 assert() 函数会被忽略，不会被调用。 在开发过程中, assert(condition) 会在非 true 的条件下抛出异常。

提示： 实例变量可以是 final 类型但不能是 const 类型。 必须在构造函数体执行之前初始化 final 实例变量 —— 在变量声明中，参数构造函数中或构造函数的初始化列表中进行初始化。

final name = 'Bob'; // Without a type annotation

final String nickname = 'Bobby';

//final 不能被修改:

name = 'Alice'; // Error: 一个 final 变量只能被设置一次。

const bar = 1000000; // 压力单位 (dynes/cm2)

const double atm = 1.01325 * bar; // 标准气压

// Const 关键字不仅可以用于声明常量变量。 还可以用来创建常量值，以及声明创建常量值的构造函数。 任何变量都可以拥有常量值。

var foo = const [];

final bar = const [];

const baz = []; // 声明 const 的初始化表达式中 const 可以被省略。 比如上面的 baz。  Equivalent to `const []`

//Const 变量的值不可以修改：

baz = [42]; // Error: 常量变量不能赋值修改。

//非 Final ， 非 const 的变量是可以被修改的，即使这些变量 曾经引用过 const 值。

foo = [1, 2, 3]; // 曾经引用过 const [] 常量值。

const a = {'c': 1};

a['c'] = 2;

// 运行结果 Unsupported operation: Cannot set value in unmodifiable Map

  const a = {'c': 1};

  const b = {'c': 1};

  print(a == b);//true

  final c = {'c': 1};

  final d = {'c': 1};

  print(c == d);//false

// 整数类型不包含小数点。 下面是定义整数类型字面量的例子:

var x = 1;

var hex = 0xDEADBEEF;


// 如果一个数字包含小数点，那么就是小数类型。 下面是定义小数类型字面量的例子:

var y = 1.1;

var exponents = 1.42e5;


// 从 Dart 2.1 开始，必要的时候 int 字面量会自动转换成 double 类型。

double z = 1; // 相当于 double z = 1.0.

//版本提示： 在dart 2.1 之前，在 double 上下文中使用 int 字面量是错误的。

//以下是将字符串转换为数字的方法，反之亦然：

// 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



//数字类型字面量是编译时常量。 在算术表达式中，只要参与计算的因子是编译时常量， 那么算术表达式的结果也是编译时常量。

const msPerSecond = 1000;

const secondsUntilRetry = 5;

const msUntilRetry = secondsUntilRetry * msPerSecond;

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.";

var s = 'string interpolation';

assert('Dart has $s, which is very handy.' ==

    'Dart has string interpolation, ' +

        'which is very handy.');

assert('That deserves all caps. ' +

        '${s.toUpperCase()} is very handy!' ==

    'That deserves all caps. ' +

        'STRING INTERPOLATION is very handy!');

提示： == 运算符用来测试两个对象是否相等。 在字符串中，如果两个字符串包含了相同的编码序列，那么这两个字符串相等。

// 用 + 运算符来把多个字符串连接为一个，也可以把多个字面量字符串写在一起来实现字符串连接：

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.');



// 使用连续三个单引号或者三个双引号实现多行字符串对象的创建：

var s1 = '''

You can create

multi-line strings like this one.

''';

var s2 = """This is also a

multi-line string.""";



// 使用 r 前缀，可以创建 “原始 raw” 字符串：

var s = r"In a raw string, even \n isn't special.";

// const 类型数据

const aConstNum = 0;

const aConstBool = true;

const aConstString = 'a constant string';

// 非 const 类型数据

var aNum = 0;

var aBool = true;

var aString = 'a string';

const aConstList = [1, 2, 3];

const validConstString = '$aConstNum $aConstBool $aConstString'; //const 类型数据

// const invalidConstString = '$aNum $aBool $aString $aConstList'; //非 const 类型数据,error Not a constant expression.

// 检查空字符串。

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);

var list = [1, 2, 3];

var list = [1, 2, 3];

assert(list.length == 3);

assert(list[1] == 2);

list[1] = 1;

assert(list[1] == 1);

//在 List 字面量之前添加 const 关键字，可以定义 List 类型的编译时常量

var constantList = const [1, 2, 3];

// constantList[1] = 1; // 取消注释会引起错误。

var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

var names = <String>{};

// Set<String> names = {}; // 这样也是可以的。

// var names = {}; // 这样会创建一个 Map ，而不是 Set 。

// 使用 add() 或 addAll() 为已有的 Set 添加元素：

var elements = <String>{};

elements.add('fluorine');

elements.addAll(halogens);

// 使用 .length 来获取 Set 中元素的个数：

var elements = <String>{};

elements.add('fluorine');

elements.addAll(halogens);

assert(elements.length == 5);

// 在 Set 字面量前增加 const ，来创建一个编译时 Set 常量：

final constantSet = const {

  'fluorine',

  'chlorine',

  'bromine',

  'iodine',

  'astatine',

};

// constantSet.add('helium'); // Uncommenting this causes an error.

var gifts = {

  // Key:    Value

  'first': 'partridge',

  'second': 'turtledoves',

  'fifth': 'golden rings'

};

var nobleGases = {

  2: 'helium',

  10: 'neon',

  18: 'argon',

};

var gifts = Map();

gifts['first'] = 'partridge';

gifts['second'] = 'turtledoves';

gifts['fifth'] = 'golden rings';

var nobleGases = Map();

nobleGases[2] = 'helium';

nobleGases[10] = 'neon';

nobleGases[18] = 'argon';

// 添加 key-value 对到已有的 Map 中：

var gifts = {'first': 'partridge'};

gifts['fourth'] = 'calling birds'; // Add a key-value pair

// 从一个 Map 中获取一个 value：

var gifts = {'first': 'partridge'};

assert(gifts['first'] == 'partridge');

// 如果 Map 中不包含所要查找的 key，那么 Map 返回 null：

var gifts = {'first': 'partridge'};

assert(gifts['fifth'] == null);

// 使用 .length 函数获取当前 Map 中的 key-value 对数量：

var gifts = {'first': 'partridge'};

gifts['fourth'] = 'calling birds';

assert(gifts.length == 2);

// 创建 Map 类型运行时常量，要在 Map 字面量前加上关键字 const。

final constantMap = const {

  2: 'helium',

  10: 'neon',

  18: 'argon',

};

// constantMap[2] = 'Helium'; // 取消注释会引起错误。

main() {

  var clapping = '\u{1f44f}';

  print(clapping);

  print(clapping.codeUnits);

  print(clapping.runes.toList());

  Runes input = new Runes(

      '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');

  print(new String.fromCharCodes(input));

}

提示： 谨慎使用 list 方式操作 Rune 。 这种方法很容易引发崩溃， 具体原因取决于特定的语言，字符集和操作。

#radix

#bar

a++

a + b

a = b

a == b

c ? a : b

a is T

// 括号可以提高可读性。

if ((n % i == 0) && (d % i == 0)) ...

// 可读性差，但是是等效的。

if (n % i == 0 && d % i == 0) ... 

警告： 对于有两个操作数的运算符，运算符的功能由左边的操作数决定。 例如, 如果有两个操作数 Vector 和 Point， aVector + aPoint 使用的是 Vector 中定义的 + 运算符。

下面就对dart中的运算符进行常规意义的分类简单列举一下：

• 算术运算符：+、-、*、/、~/（整除，结果为整数）、%（求余运算）、++（自增）、--（自减）。（++、--分别有前缀和后缀两种表达形式，大家在学习的过程中要注意他们之间的区别）

  assert(2 + 3 == 5);
  
  assert(2 - 3 == -1);
  
  assert(2 * 3 == 6);
  
  assert(5 / 2 == 2.5); // 结果是双浮点型
  
  assert(5 ~/ 2 == 2); // 结果是整型
  
  assert(5 % 2 == 1); // 余数
  
  assert('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');

• 关系运算符：==、!=、>、<、>=、<=，都是常规符号，不做其他解释，大家要注意的是关系运算符的表达式结果为boolean类型。

  assert(2 == 2);
  
  assert(2 != 3);
  
  assert(3 > 2);
  
  assert(2 < 3);
  
  assert(3 >= 3);
  
  assert(2 <= 3);

• 逻辑运算符：&&（逻辑与，短路运算）、||（逻辑或，短路运算）、!。

  //短路运算，即当左边的表达式结果能确定最终结果时，右边的表达式不再进行运算
  
    var a = 10;
  
    var b = a > 9 || a++ > 10; //a>9成立，又是或运算，所以b的结果为true，右边的 a++ > 10不会进行计算，所以a的值不会加1
  
    print(a); //10

• 赋值运算符：=、+=、-=、*=、/=。。。等一系列的扩展赋值运算符

  var a = 2; // 使用 = 复制
  
  a *= 3; // 复制并做乘法运算： a = a * 3
  
  assert(a == 6);

• 位运算符：&（按位与运算）、|（按位或运算）、^（按位异或运算）、<<（按位左移）、>>（按位右移）。（所有的位运算都是以二进制形式进行的）

  final value = 0x22;
  
  final bitmask = 0x0f;
  
  assert((value & bitmask) == 0x02); // AND
  
  assert((value & ~bitmask) == 0x20); // AND NOT
  
  assert((value | bitmask) == 0x2f); // OR
  
  assert((value ^ bitmask) == 0x2d); // XOR
  
  assert((value << 4) == 0x220); // Shift left
  
  assert((value >> 4) == 0x02); // Shift right

• 条件运算符：
  • condition ? expr1 : expr2 如果条件为 true, 执行 expr1 (并返回它的值)， 否则, 执行并返回 expr2 的值。
  • expr1 ?? expr2 如果 expr1 是 non-null， 返回 expr1 的值； 否则, 执行并返回 expr2 的值。
• 级联运算符（..）：可以实现对同一个对像进行一系列的操作。 除了调用函数， 还可以访问同一对象上的字段属性。 这通常可以节省创建临时变量的步骤， 同时编写出更流畅的代码。严格的来讲， “两个点” 的级联语法不是一个运算符。 它只是一个 Dart 的特殊语法。

  // 第一句调用函数 querySelector() ， 返回获取到的对象。 获取的对象依次执行级联运算符后面的代码， 代码执行后的返回值会被忽略。
  
  querySelector('#confirm') // 获取对象。
  
    ..text = 'Confirm' // 调用成员变量。
  
    ..classes.add('important')
  
    ..onClick.listen((e) => window.alert('Confirmed!'));
  
  // 上面的代码等价于：
  
  var button = querySelector('#confirm');
  
  button.text = 'Confirm';
  
  button.classes.add('important');
  
  button.onClick.listen((e) => window.alert('Confirmed!'));
  
  // 级联运算符可以嵌套，例如：
  
  final addressBook = (AddressBookBuilder()
  
        ..name = 'jenny'
  
        ..email = 'jenny@example.com'
  
        ..phone = (PhoneNumberBuilder()
  
              ..number = '415-555-0100'
  
              ..label = 'home')
  
            .build())
  
      .build();
  
  // 在返回对象的函数中谨慎使用级联操作符。 例如，下面的代码是错误的：
  
  var sb = StringBuffer();
  
  sb.write('foo')
  
    ..write('bar'); // Error: 'void' 没哟定义 'write' 函数。
  
  // sb.write() 函数调用返回 void， 不能在 void 对象上创建级联操作。

• 类型判定运算符：as（）、is（判定是否是指定类型或该类型子类的对象）、is! （跟is相反）。
  • 使用 as 运算符将对象强制转换为特定类型。 通常，可以认为是 is 类型判定后，被判定对象调用函数的一种缩写形式。 请考虑以下代码：

if (emp is Person) {

  // 类型判断

  // emp.firstName = 'Bob';

  // 下面这种写法一般是没问题的，进行类型强转

  (emp as Person).firstName = 'Bob';

}