Dart 运算符

用户3562254

发布于 2025-02-05 17:00:18

740

Dart 支持下表中所示的运算符。

该表按从高到低的顺序显示了 Dart 的运算符结合性和运算符优先级，这只是 Dart 运算符关系的 近似值 。

您可以将许多这些运算符实现为类成员。

描述	运算符	结合性
一元后缀	`expr``++` `expr``--` `()` `[]` `?[]` `.` `?.` `!`	无
一元前缀	`-``expr` `!``expr` `~``expr` `++``expr` `--``expr` `await` `expr`	无
乘法	`*` `/` `%` `~/`	左结合
加法	`+` `-`	左结合
移位	`<<` `>>` `>>>`	左结合
按位与	`&`	左结合
按位异或	`^`	左结合
按位或	<code>\|</code>	左结合
关系和类型测试	`>=` `>` `<=` `<` `as` `is` `is!`	无
等式	`==` `!=`	无
逻辑与	`&&`	左结合
逻辑或	<code>\|\|</code>	左结合
空值合并	`??`	左结合
条件	`expr1` `?` `expr2` `:` `expr3`	右结合
级联	`..` `?..`	左结合
赋值	`=` `=` `/=` `+=` `-=` `&=` `^=` etc.*	右结合
展开 (参见注释)	`...` `...?`	无

警告上表仅供参考。运算符优先级和结合性的概念是对语言语法中真实情况的近似。您可以在 Dart 语言规范中定义的语法中找到 Dart 运算符关系的权威行为。

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

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); // 结果是 double
assert(5 ~/ 2 == 2); // 结果是 int
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`)

示例：

int a;
int 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

等式和关系运算符

下表列出了等式和关系运算符的含义。

运算符	含义
`==`	等于；见下文讨论
`!=`	不等于
`>`	大于
`<`	小于
`>=`	大于或等于
`<=`	小于或等于

要测试两个对象 x 和 y 是否表示相同的事物，请使用 == 运算符。（在极少数情况下，如果您需要知道两个对象是否是完全相同的对象，请改用 identical() 函数。）以下是 == 运算符的工作原理：

如果 x 或 y 为 null，则如果两者都为 null，则返回 true，如果只有一个为 null，则返回 false。
返回在 x 上调用 == 方法并使用参数 y 的结果。（没错，像 == 这样的运算符是在其第一个操作数上调用的方法。有关详细信息，请参阅运算符。）

以下是使用每个等式和关系运算符的示例：

<?code-excerpt "misc/test/language_tour/operators_test.dart (relational)"?>

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 T 的结果如果 obj 实现 T 指定的接口则为 true。例如， obj is Object? 总是为 true。

仅当您确定对象属于该类型时，才使用 as 运算符将对象转换为特定类型。示例：

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

如果您不确定对象是否为 T 类型，则在使用对象之前使用 is T 检查类型。

if (employee is Person) {
  // 类型检查
  employee.firstName = 'Bob';
}

注意代码不等效。如果 employee 为 null 或不是 Person ，则第一个示例会抛出异常；第二个示例什么也不做。

赋值运算符

如您所见，您可以使用 = 运算符赋值。

要仅在被赋值变量为 null 时赋值，

请使用 ??= 运算符。

// 将值赋给 a
a = value;
// 如果 b 为 null，则将值赋给 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，反之亦然）
<code>\|\|</code>	逻辑或
`&&`	逻辑与

以下是使用逻辑运算符的示例：

if (!done && (col == 0 || col == 3)) {
  // ...执行某些操作...
}

位运算符和移位运算符

您可以操作 Dart 中数字的各个位。通常，您会将这些位运算符和移位运算符与整数一起使用。

运算符	含义
`&`	与
`\|`	或
`^`	异或
`~``expr`	一元按位取反（0 变成 1；1 变成 0）
`<<`	左移
`>>`	右移
`>>>`	无符号右移

备注使用大操作数或负操作数的位运算的行为可能因平台而异。要了解更多信息，请查看位运算平台差异。

以下是使用位运算符和移位运算符的示例：

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); // 右移

// 右移示例，在 Web 上的结果行为不同，
// 因为操作数的值在掩码为 32 位时会发生变化：
assert((-value >> 4) == -0x03);

assert((value >>> 4) == 0x02); // 无符号右移
assert((-value >>> 4) > 0); // 无符号右移

注意版本 >>> 运算符（称为 三元移位 或 无符号移位 ）需要至少 2.14 的语言版本。

条件表达式

Dart 有两个运算符，允许您简洁地计算否则可能需要 if-else 语句的表达式：

condition ? expr1 : expr2

: 如果 condition 为 true，则计算 expr1（并返回其值）；

否则，计算并返回 expr2 的值。

expr1 ?? expr2

: 如果 expr1 不为 null，则返回其值；

否则，计算并返回 expr2 的值。

当您需要根据布尔表达式赋值时，

请考虑使用条件运算符 ? 和 : 。

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

如果布尔表达式测试 null 值，

请考虑使用空值合并运算符 ??

（也称为空值合并运算符）。

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

前面的示例可以用至少另外两种方式编写，

但没有那么简洁：

// 稍长的版本使用 ?: 运算符。
String playerName(String? name) => name != null ? name : 'Guest';

// 很长的版本使用 if-else 语句。
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;

如果级联操作的对象可能为 null，

则对第一个操作使用 空值简写 级联（ ?.. ）。

以 ?.. 开头可以保证不会对该 null 对象尝试任何级联操作。

querySelector('#confirm') // 获取对象。
  ?..text = 'Confirm' // 使用其成员。
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'))
  ..scrollIntoView();

注意版本 ?.. 语法需要至少 2.12 的语言版本。

前面的代码等效于以下代码：

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'); // 错误：方法 'write' 未为 'void' 定义。

sb.write() 调用返回 void，

您不能在 void 上构建级联。

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

展开运算符

展开运算符计算一个产生集合的表达式，

解包结果值，并将它们插入另一个集合中。

展开运算符实际上不是运算符表达式 。

... / ...? 语法是集合字面量本身的一部分。

因此，您可以在

集合页面上了解有关展开运算符的更多信息。

因为它不是运算符，所以语法没有任何“ 运算符优先级 ”。

实际上，它具有最低的“优先级”——任何类型的表达式都可以作为展开目标，例如：

[...a + b]

其他运算符

您已经在其他示例中看到了大多数剩余的运算符：

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