Dart运算符

Dart汇总请点击这里

Dart 支持的运算符。

该表从最高到最低显示了 Dart 的运算符关联性和运算符优先级，它们是 Dart 运算符关系的近似值。

描述	操作	关联性
一元后缀	expr++ expr-- () [] ?[] . ?. !	没有任何
一元前缀	-expr !expr ~expr ++expr --expr await expr	没有任何
乘法	* / % ~/	左边
累积	+ -	左边
位移	<< >> >>>	左边
按位与	&	左边
按位异或	^	左边
按位或	|	左边
关系和类型测试	>= > <= < as is is!	没有任何
相等	== !=	没有任何
逻辑与	&&	左边
逻辑或	|	左边
如果为空	??	左边
条件	expr1 ? expr2 : expr3	右边
级联	.. ?..	左边
分配	= *= /= += -= &= ^= ETC。	右边
扩展	... ...?	没有任何

使用运算符时，可以创建表达式。以下是一些运算符表达式的示例：

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 支持常用的运算运算符，如下表所示：

操作符	含义
+	加
-	减
-expr	一元减法，也称为否定（反转表达式的符号）
*	乘
/	除
~/	除法，返回整数结果
%	获取整数除法的余数（模数）

示例：

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

Dart 支持前缀和后缀的增量和减量运算符。

操作符	含义
++var	var = var + 1（表达式值为）var + 1
var++	var = var + 1（表达式值为_var_）
--var	var = var - 1（表达式值为）var - 1
var--	var = var - 1（表达式值为_var_）
示例：

var a, b;

a = 0;
b = ++a; // a自加后赋值给b。
assert(a == b); // 1 == 1

a = 0;
b = a++; // a先赋值给b后，a自加。
assert(a != b); // 1 != 0

a = 0;
b = --a; // a自减后赋值给b。
assert(a == b); // -1 == -1

a = 0;
b = a--; // a先赋值给b后，a自减。
assert(a != b); // -1 != 0

关系运算符

下表列出了关系运算符及含义：

操作符	含义
==	相等
!=	不等于
>	大于
<	少于
>=	大于或等于
<=	小于或等于

要测试两个对象x和y是否表示相同的事物， 使用 == 运算符。 (在极少数情况下， 要确定两个对象是否完全相同，需要使用 identical() 函数。)

== 运算符的工作原理：

1. 如果 x 或 y 可以 null，都为 null 时返回 true ，其中一个为 null 时返回 false。

2. 结果为函数 x.==(y) 的返回值。 (如上所见, == 运算符执行的是第一个运算符的函数）

这里列出了每种关系运算符的示例：

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

类型判定运算符

as， is， 和 is! 运算符用于在运行时处理类型检查：

操作符	含义
as	类型转换（也用于指定库前缀)）
is	如果对象具有指定类型则为 True
is!	如果对象不属于指定类型则为 True

例如， obj is Object 总是 true。 但是只有 obj 实现了 T 的接口时， obj is T 才是 true。

当且仅当确定对象属于该类型时，才使用 as 将对象转换为特定类型。例如：

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

如果不确定该对象是否属于类型T，请在is T使用该对象之前检查其类型。

if (employee is Person) {
  // Type check
  employee.firstName = 'Bob';
}

提示： 代码并不等效。如果employee为 null 或不为Person，则第一个例子会引发异常；第二个示例不执行任何操作。

赋值运算符

使用 = 为变量赋值。 使用 ??= 运算符时，只有当被赋值的变量为 null 时才会赋值给它。

// 将值赋值给变量a
a = value;
// 如果b为空时，将变量赋值给b，否则，b的值保持不变。
b ??= value;

复合赋值运算符（如 += ）将算术运算符和赋值运算符组合在了一起。

=	*=	%=	>>>=	^=
+=	/=	<<=	&=	|=
-=	~/=	>>=

复合赋值运算符的工作原理如下：

对于运算符_op_：	a op= b	a = a op b
例子：	a += b	a = a + b

以下示例使用赋值和复合赋值运算符：

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

逻辑运算符

逻辑运算符可以反转或组合布尔表达式。

操作符	含义
!expr	反转以下表达式（将 false 更改为 true，反之亦然）
|	逻辑或
&&	逻辑与

下面是关于逻辑表达式的示例：

if (!done && (col == 0 || col == 3)) {
  // ...Do something...
}

按位和移位运算符

在 Dart 中，可以单独操作数字的某一位。 通常情况下整数类型使用按位和移位运算符来操作。

操作符	含义
&	与
|	或
^	异或
~expr	一元按位补码（0 变为 1；1 变为 0）
<<	左移
>>	右移
>>>	无符号右移

下面是关于按位和移位运算符的示例：

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

// Shift right example that results in different behavior on web
// because the operand value changes when masked to 32 bits:
assert((-value >> 4) == -0x03);

assert((value >>> 4) == 0x02); // Unsigned shift right
assert((-value >>> 4) > 0); // Unsigned shift right

条件表达式

Dart有两个运算符，有时可以替换 if-else 表达式， 让表达式更简洁：

condition ? expr1 : expr2如果条件为 true, 执行 expr1 (并返回它的值)： 否则, 执行并返回 expr2 的值。
expr1 ?? expr2如果 expr1 是 non-null， 返回 expr1 的值； 否则, 执行并返回 expr2 的值。

条件运算符?和:。

var visibility = isPublic ? 'public' : 'private';

布尔表达式测试是否为空，请考虑使用 if-null 运算符?? （也称为空合并运算符）

String playerName(String? name) => name ?? 'Guest';

下面给出了其他两种实现方式， 但并不简洁：

// Slightly longer version uses ?: operator.
String playerName(String? name) => name != null ? name : 'Guest';

// Very long version uses if-else statement.
String playerName(String? name) {
  if (name != null) {
    return name;
  } else {
    return 'Guest';
  }
}

级联运算符 (…)

级联（..，?..）可以实现对同一个对像进行一系列的操作。 除了调用函数， 还可以访问同一对象上的字段属性。 这通常可以节省创建临时变量的步骤， 同时编写出更流畅的代码。

考虑以下代码：

var paint = Paint()
  ..color = Colors.black
  ..strokeCap = StrokeCap.round
  ..strokeWidth = 5.0;

构造函数Paint()返回一个Paint对象。级联表示法后面的代码会对该对象进行操作，忽略可能返回的任何值。

上面的代码等价于：

var paint = Paint();
paint.color = Colors.black;
paint.strokeCap = StrokeCap.round;
paint.strokeWidth = 5.0;

如果级联操作的对象可以为空，则对第一个操作使用 空短 级联 (?.. )。以?..开头可确保不会对该空对象尝试任何级联操作。

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

上述代码等效于下面的代码：

var button = querySelector('#confirm');
button?.text = 'Confirm';
button?.classes.add('important');
button?.onClick.listen((e) => window.alert('Confirmed!'));
button?.scrollIntoView();

还可以嵌套级联。例如：

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: method 'write' isn't defined for 'void'.

该sb.write()调用返回 void，并且您无法在void上构建级联。

严格来说，级联的“双点”符号并不是运算符。它只是 Dart 语法的一部分。

扩展运算符

扩展运算符计算生成集合的表达式，解压结果值，并将它们插入到另一个集合中。

扩展运算符实际上并不是运算符表达式。所以语法没有任何“运算符优先级”。实际上，它具有最低的“优先级”——任何类型的表达式都可以作为扩展目标，例如：

[...a + b]

其他运算符

大多数剩余的运算符，已在示例中使用过：

操作符	名称	含义
()	功能应用	表示函数调用
[]	下标访问	表示对可重写运算符的调用[]；例如：fooList[1]将 int 传递1给fooList访问索引处的元素1
?[]	条件下标访问	类似[]，但最左边的操作数可以为空；例如：fooList?[1]将 int 传递1给fooList以访问索引处的元素，1除非fooList为空（在这种情况下表达式计算结果为空）
.	成员访问	引用表达式的属性；例如：从表达式中foo.bar选择属性bar``foo
?.	有条件成员访问	类似.，但最左边的操作数可以为空；例如：从表达式中foo?.bar选择属性，除非为空（在这种情况下的值为空）bar``foo``foo``foo?.bar
!	非空断言运算符	将表达式转换为其底层不可空类型，如果转换失败，则抛出运行时异常；例如：foo!.bar断言foo为非空并选择属性bar，除非foo为空，在这种情况下会抛出运行时异常