Dart语法学习-函数、类与运算符学习笔记

且听真言

已于 2023-02-05 15:22:09 修改

阅读量578

点赞数 1

分类专栏： Flutter 文章标签： Functions Symbols Runes Operators

于 2023-02-03 14:43:39 首次发布

本文链接：https://blog.csdn.net/zhangying1994/article/details/128845723

版权

Flutter 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

本文介绍了Dart中的函数用法，包括命名参数、可选参数、函数作为对象以及箭头函数的语法。还讨论了类的概念，如实例化、继承、接口实现和混入。此外，提到了运算符，如?.、??、??=以及算术和逻辑运算符的使用。

摘要由CSDN通过智能技术生成

一、Runes and grapheme clusters

报错：Couldn't resolve the package 'characters' in 'package:characters/characters.dart'.

参考：flutter Error: Could not resolve the package ‘characters‘ in ‘package:characters/characters.dart‘._前进六的博客-CSDN博客_couldn't resolve the package 'characters' in 'pack

报错：This command should be run from the root of your Flutter project.

参考：

Error: No pubspec.yaml file found. This command should be run from the root of your Flutter project.__柒安的博客-CSDN博客

Error: No pubspec.yaml file found.的解决办法 - 灰信网（软件开发博客聚合）

import 'package:characters/characters.dart';

void main() {
  var hi = 'Hi 🇩🇰';
  print(hi);
  print('The end of the string: ${hi.substring(hi.length - 1)}');
  print('The last character: ${hi.characters.last}');
}

二、Symbols

Symbol 对象表示 Dart 程序中声明的运算符或标识符。

#radix
#bar

三、函数

Dart 是一种真正的面向对象的语言，所以即使是函数也是对象并且有一个类型 Function。这意味着函数可以分配给变量或作为参数传递给其他函数。

bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

Dart自定义函数默认是public类型

isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

对于只包含一个表达式的函数，可以使用简写语法：

bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

=> expr 语法是 { return expr; 的简写。 }. => 符号称为箭头语法。

在箭头 (=>) 和分号 (;) 之间只能出现表达式，而不是语句。例如，不能在此处放置 if 语句，但可以使用条件表达式。

Parameters-参数

一个函数可以有任意数量的必需位置参数。这些参数后面可以跟命名参数或可选的位置参数（但不能同时跟两个）。

函数是一段用来独立地完成某个功能的代码。在 Dart 中，所有类型都是对象类型，函数也是对象，它的类型叫作 Function。这意味着函数也可以被定义为变量，甚至可以被定义为参数传递给另一个函数。

bool isZero(int number) {
  return number == 0;
}

void printInfo(int number, Function check) {
  print("$number is Zero: ${check(number)}");
}

void main() {
  Function f = isZero;
  int x = 1;
  int y = 0;
  printInfo(x, f);
  printInfo(y, f);
}

Log
1 is Zero: false
0 is Zero: true

如果函数体只有一行表达式，可以像 JavaScript 语言那样用箭头函数来简化这个函数：

bool isZero(int number) => number == 0;

void printInfo(int number, Function check) =>
    print("$number is Zero: ${check(number)}");

void main() {
  Function f = isZero;
  int x = 1;
  int y = 0;
  printInfo(x, f);
  printInfo(y, f);
}

Log:
1 is Zero: false
0 is Zero: true

当一个函数中可能需要传递多个参数，C++ 与 Java 的做法是，提供函数的重载，即提供同名但参数不同的函数。

但 Dart 认为重载会导致混乱，因此从设计之初就不支持重载，而是提供了可选命名参数和可选参数。

具体方式是，在声明函数时：

给参数增加{}，以 paramName: value 的方式指定调用参数，也就是可选命名参数；
给参数增加[]，则意味着这些参数是可以忽略的，也就是可选参数。

在使用这两种方式定义函数时，可以在参数未传递时设置默认值。

//要达到可选命名参数的用法，那就在定义函数的时候给参数加上 {}
void enable1Flags({required bool bold, required bool hidden}) =>
    print("$bold, $hidden");

void enable1Flags({required bool bold, bool? hidden}) =>
    print("$bold, $hidden");

//定义可选命名参数时增加默认值
void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold ,$hidden");

//可忽略的参数在函数定义时用[]符号指定
void enable3Flags(bool bold, [bool? hidden]) => print("$bold ,$hidden");

//定义可忽略参数时增加默认值
void enable4Flags(bool bold, [bool hidden = false]) => print("$bold ,$hidden");

//可选命名参数函数调用
void main() {
  enable1Flags(bold: true, hidden: false); //true, false
  enable1Flags(bold: true, hidden: null); //true, null
  enable2Flags(bold: false); //false, false
}

void main() {
  //可忽略参数函数调用
  enable3Flags(true, false); //true, false
  enable3Flags(true); //true, null
  enable4Flags(true); //true, false
  enable4Flags(true, true); // true, true
}

Named parameters

命名参数是可选的，除非它们被显式地标记为必选。

定义函数时，使用{param1, param2，…}指定命名形参。如果你没有提供一个默认值或者根据需要标记一个命名参数，它们的类型必须为空，因为它们的默认值将为空:

/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool? bold, bool? hidden}) {...}

在调用函数时，可以使用paramName: value指定命名参数。

enableFlags(bold: true, hidden: false);

要为命名参数定义除null之外的默认值，使用=指定默认值。指定的值必须是编译时常量。

/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold = false, bool hidden = false}) {...}

// bold will be true; hidden will be false.
enableFlags(bold: true);

如果希望命名参数是强制性的，要求调用者为参数提供值，请使用 required 注释它们

const Scrollbar({super.key, required Widget child});

在上面的代码中，如果有人试图在不指定子参数的情况下创建Scrollbar，那么会报错。

注意：标记为必需的参数仍然可以为空：

const Scrollbar({super.key, required Widget? child});

Dart 允许将命名参数放在参数列表中的任何位置

repeat(times: 2, () {
  ...
});

可选位置参数在 [] 中包装一组函数参数将它们标记为可选的位置参数。如果您不提供默认值，则它们的类型必须是可空的，因为它们的默认值将为空：

String say(String from, String msg, [String? device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  } else {
    result = '$result with no device';
  }
  return result;
}

void main() {
  var result1 = say("A", "B");
  print(result1);

  var result2 = say("A", "B", "HUAWEI");
  print(result2);

  var result3 = say("A", "B", null);
  print(result3);
}


Log
A says B with no device
A says B with a HUAWEI
A says B with no device

一个不带可选参数调用此函数

assert(say('Bob', 'Howdy') == 'Bob says Howdy');

使用第三个参数调用此函数

assert(say('Bob', 'Howdy', 'smoke signal') ==
    'Bob says Howdy with a smoke signal');

要为 null 之外的可选位置参数定义默认值，请使用 = 指定默认值。指定的值必须是编译时常量。

String say(String from, String msg, [String device = 'carrier pigeon']) {
  var result = '$from says $msg with a $device';
  return result;
}

assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');

String say(String from, String msg, [String? device = "Xiaomi"]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  } else {
    result = '$result with no device';
  }
  return result;
}

void main() {
  var result1 = say("A", "B");
  print(result1);

  var result2 = say("A", "B", "HUAWEI");
  print(result2);

  var result3 = say("A", "B", null);
  print(result3);
}


Log
A says B with a Xiaomi
A says B with a HUAWEI
A says B with no device

The main() function

每个应用程序都必须有一个顶级 main() 函数，作为应用程序的入口点。 main() 函数返回 void 并有一个可选的 List<String> 参数作为参数。

void main() {
  print('Hello, World!');
}

带有参数的命令行应用程序的 main() 函数

void main(List<String> arguments) {
  print(arguments);

  assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}

Functions as first-class objects

可以将一个函数作为参数传递给另一个函数。

void printElement(int element) {
  print(element);
}

void main() {
  var list = [1, 2, 3];
  list.forEach(printElement);
}

Log
1
2
3

可以将函数分配给变量

var loudify = (msg) => '${msg.toUpperCase()}';
void main() {
  print(loudify('aabbcc'));
}

Log
AABBCC

Anonymous functions（匿名函数）

大多数函数都有名称，例如 main() 或 printElement()。可以创建一个无名函数，称为匿名函数，有时也称为 lambda 或闭包。可以将匿名函数分配给变量，例如，可以将它添加到集合中或从集合中删除它。

匿名函数看起来类似于命名函数——零个或多个参数，用逗号和可选的类型注释分隔，在括号之间。

下面的代码块包含函数的主体：

([[Type] param1[, …]]) {
  codeBlock;
};

定义了一个匿名函数，它带有一个无类型参数 item，并将它传递给 map 函数。为列表中的每个项目调用的函数将每个字符串转换为大写。然后在传递给 forEach 的匿名函数中，每个转换后的字符串都与它的长度一起打印出来。

void main() {
  const list = ['apples', 'bananas', 'oranges'];
  list.map((item){
    return item.toUpperCase();
  }).forEach((item) {
    print('$item:${item.length}');
  });
}

Log
APPLES:6
BANANAS:7
ORANGES:7

如果函数只包含一个表达式或 return 语句，可以使用箭头符号将其缩短。

  const list = ['apples', 'bananas', 'oranges'];
  list.map((item) => item.toUpperCase()).forEach((item) {
    print('$item:${item.length}');
  });

Log
APPLES:6
BANANAS:7
ORANGES:7

Lexical scope

Dart 是一种词法范围语言，这意味着变量的范围是静态确定的，只需通过代码的布局即可。您可以“向外跟随大括号”来查看变量是否在范围内。

下面是一个嵌套函数的例子，在每个范围级别都有变量：

bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

      assert(topLevel);
      assert(insideMain);
      assert(insideFunction);
      assert(insideNestedFunction);
    }
  }
}

请注意 nestedFunction() 可以使用每个级别的变量，一直到顶层。

Lexical closures 词法闭包

闭包是一个函数对象，它可以访问其词法范围内的变量，即使该函数在其原始范围之外使用也是如此。

函数可以关闭周围作用域中定义的变量。在下面的示例中，makeAdder() 捕获变量 addBy。无论返回的函数走到哪里，它都会记住 addBy。

/// Returns a function that adds [addBy] to the
/// function's argument.
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}

void main() {
  // Create a function that adds 2.
  var add2 = makeAdder(2);

  // Create a function that adds 4.
  var add4 = makeAdder(4);

  print(add2(3));
  print(add4(3));
}

Log
5
7

Testing functions for equality

测试顶级函数、静态方法和实例方法是否相等。

void foo() {} // A top-level function

class A {
  static void bar() {} // A static method
  void baz() {} // An instance method
}

void main() {
  Function x;

  // Comparing top-level functions.
  x = foo;
  print(foo == x);

  // Comparing static methods.
  x = A.bar;
  print(A.bar == x);

  // Comparing instance methods.
  var v = A(); // Instance #1 of A
  var w = A(); // Instance #2 of A
  var y = w;
  x = w.baz;

  // These closures refer to the same instance (#2),
  // so they're equal.
  print(y.baz == x);

  // These closures refer to different instances,
  // so they're unequal.
  print(v.baz != w.baz);
}

Log
true
true
true
true

Return values

所有函数都返回一个值。如果没有指定返回值，则语句返回null；隐式附加到函数体。

foo() {}

void main() {
  print(foo() == null);
}


Log
true

四、类

类是特定类型的数据和方法的集合，也是创建对象的模板。与其他语言一样，Dart 为类概念提供了内置支持。

类的定义及初始化

Dart 是面向对象的语言，每个对象都是一个类的实例，都继承自顶层类型 Object。在 Dart 中，实例变量与实例方法、类变量与类方法的声明与 Java 类似。

Dart 中并没有 public、protected、private 这些关键字，我们只要在声明变量与方法时，在前面加上“_”即可作为 private 方法使用。如果不加“_”，则默认为 public。不过，“_”的限制范围并不是类访问级别的，而是库访问级别。

class Point {
  num? x, y;
  static num factor = 0;

  Point(this.x, this.y);

  void printINfo() => print('($x, $y)');

  static void printZValue() => print('$factor');
}

void main() {
  var p = Point(100, 200);
  p.printINfo();
  Point.factor = 10;
  Point.printZValue();
}


Log
(100, 200)
10

类的实例化需要根据参数提供多种初始化方式。除了可选命名参数和可选参数之外，Dart 还提供了命名构造函数的方式，使得类的实例化过程语义更清晰。

此外，与 C++ 类似，Dart 支持初始化列表。在构造函数的函数体真正执行之前，你还有机会给实例变量赋值，甚至重定向至另一个构造函数。

class Point {
  num? x, y, z;

  Point(this.x, this.y) : z = 0; //初始化变量z
  Point.bottom(num x) : this(x, 0); //重定向构造函数
  void printInfo() => print('($x,$y,$z)');
}

void main() {
  var p = Point.bottom(100);
  p.printInfo();
}

Log
(100,0,0)

复用

在面向对象的编程语言中，将其他类的变量与方法纳入本类中进行复用的方式一般有两种：继承父类和接口实现。当然，在 Dart 也不例外。

在 Dart 中，可以对同一个父类进行继承或接口实现：

继承父类意味着，子类由父类派生，会自动获取父类的成员变量和方法实现，子类可以根据需要覆写构造函数及父类方法；
接口实现则意味着，子类获取到的仅仅是接口的成员变量符号和方法符号，需要重新实现成员变量，以及方法的声明和初始化，否则编译器会报错。

在 Dart 中继承和接口的差别：

class Point {
  num x = 0, y = 0;

  void printInfo() => print('($x, $y)');
}

class Vector extends Point {
  num z = 0;

  @override
  void printInfo() => print('($x, $y, $z)');
}

class Coordinate implements Point {
  //成员变量需要重新声明
  @override
  num x = 1;

  @override
  num y = 1;

  //成员函数需要重新声明实现
  @override
  void printInfo() => print('($x, $y)');
}

void main() {
  var vector = Vector();
  vector.x = 100;
  vector.y = 200;
  vector.z = 300;
  vector.printInfo();

  var coordinate = Coordinate();
  coordinate.x = 400;
  coordinate.y = 500;
  coordinate.printInfo();

  print(vector is Point);
  print(coordinate is Point);
}


Log

(100, 200, 300)
(400, 500)
true
true

可以看出，子类 Coordinate 采用接口实现的方式，仅仅是获取到了父类 Point 的一个“空壳子”，只能从语义层面当成接口 Point 来用，但并不能复用 Point 的原有实现。那么，是否能够找到方法去复用 Point 的对应方法实现呢？

让 Coordinate 继承 Point，来复用其对应的方法。但，如果 Coordinate 还有其他的父类，又该如何处理呢？

其实，除了继承和接口实现之外，Dart 还提供了另一种机制来实现类的复用，即“混入”（Mixin）。混入鼓励代码重用，可以被视为具有实现方法的接口。这样一来，不仅可以解决 Dart 缺少对多重继承的支持问题，还能够避免由于多重继承可能导致的歧义（菱形问题）。

备注：继承歧义，也叫菱形问题，是支持多继承的编程语言中一个相当棘手的问题。当 B 类和 C 类继承自 A 类，而 D 类继承自 B 类和 C 类时会产生歧义。如果 A 中有一个方法在 B 和 C 中已经覆写，而 D 没有覆写它，那么 D 继承的方法的版本是 B 类，还是 C 类的呢？

要使用混入，只需要 with 关键字即可。

class Point {
  num x = 0, y = 0;

  void printInfo() => print('($x, $y)');
}

class Vector extends Point {
  num z = 0;

  @override
  void printInfo() => print('($x, $y, $z)');
}

class Coordinate implements Point {
  //成员变量需要重新声明
  @override
  num x = 1;

  @override
  num y = 1;

  //成员函数需要重新声明实现
  @override
  void printInfo() => print('($x, $y)');
}

class CoordinateWith with Point {

}

void main() {
  var coordinateWith = CoordinateWith();
  coordinateWith.printInfo();
  print(coordinateWith is Point);
  print(coordinateWith is CoordinateWith);
}

Log
(0, 0)
true
true

可以看到，通过混入，一个类里可以以非继承的方式使用其他类中的变量与方法。

五、运算符

Dart 多了几个额外的运算符，用于简化处理变量实例缺失（即 null）的情况。

?. 运算符：假设 Point 类有 printInfo() 方法，p 是 Point 的一个可能为 null 的实例。那么，p 调用成员方法的安全代码，可以简化为 p?.printInfo() ，表示 p 为 null 的时候跳过，避免抛出异常。
??= 运算符：如果 a 为 null，则给 a 赋值 value，否则跳过。这种用默认值兜底的赋值语句在 Dart 中我们可以用 a ??= value 表示。
?? 运算符：如果 a 不为 null，返回 a 的值，否则返回 b。在 Java 或者 C++ 中，我们需要通过三元表达式 (a != null)? a : b 来实现这种情况。而在 Dart 中，这类代码可以简化为 a ?? b。

在 Dart 中，一切都是对象，就连运算符也是对象成员函数的一部分。

对于系统的运算符，一般情况下只支持基本数据类型和标准库中提供的类型。而对于用户自定义的类，如果想支持基本操作，比如比较大小、相加相减等，则需要用户自己来定义关于这个运算符的具体实现。

Dart 提供了类似 C++ 的运算符覆写机制，不仅可以覆写方法，还可以覆写或者自定义运算符。

class Vector {
  num x, y;

  Vector(this.x, this.y);

  // 自定义相加运算符，实现向量相加
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);

  bool operator ==(dynamic v) => x == v.x && y == v.y;
}

void main() {
  final x = Vector(3, 3);
  final y = Vector(2, 2);
  final z = Vector(1, 1);
  print(x == (y + z));
}

Log
true

operator 是 Dart 的关键字，与运算符一起使用，表示一个类成员运算符函数。在理解时，我们应该把 operator 和运算符作为整体，看作是一个成员函数名。

Dart 支持下表中显示的运算符。该表从高到低显示了 Dart 的运算符关联性和运算符优先级，这是 Dart 运算符关系的近似值。您可以将许多这些运算符实现为类成员。

注意：上表仅应用作有用的指南。运算符优先级和结合性的概念是语言语法中发现的真理的近似值。你可以在 Dart 语言规范中定义的语法中找到 Dart 运算符关系的权威行为。

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

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

在运算符表中，每个运算符的优先级都高于它后面的行中的运算符。例如，乘法运算符 % 的优先级高于（因此先于）等于运算符 ==，后者的优先级高于逻辑与运算符 &&。该优先级意味着以下两行代码以相同的方式执行：

// Parentheses improve readability.
if ((n % i == 0) && (d % i == 0)) ...

// Harder to read, but equivalent.
if (n % i == 0 && d % i == 0) ...

对于采用两个操作数的运算符，最左边的操作数决定使用哪种方法。例如，如果您有一个 Vector 对象和一个 Point 对象，则 aVector + aPoint 使用矢量加法 (+)。

Arithmetic operators 算术运算符

Dart 支持常用的算术运算符


void main() {
  print(2 + 3 == 5);
  print(2 - 3 == -1);
  print(2 * 3 == 6);
  print(5 / 2 == 2.5); // Result is a double
  print(5 ~/ 2 == 2); // Result is an int
  print(5 % 2 == 1); // Remainder

  print('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');
}

Log
true
true
true
true
true
true
true

Dart 还支持前缀和后缀递增和递减运算符。

void main() {
  int a;
  int b;

  a = 0;
  b = ++a; // Increment a before b gets its value.
  print(a == b); // 1 == 1

  a = 0;
  b = a++; // Increment a AFTER b gets its value.
  print(a != b); // 1 != 0

  a = 0;
  b = --a; // Decrement a before b gets its value.
  print(a == b); // -1 == -1

  a = 0;
  b = a--; // Decrement a AFTER b gets its value.
  print(a != b); // -1 != 0
}

Equality and relational operators

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

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

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

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

Type test operators

The as, is, and is! operators are handy for checking types at runtime.

如果 obj 实现了 T 指定的接口，则 obj is T 的结果为真。例如，obj is Object？总是正确的。

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

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

如果您不确定该对象是 T 类型，那么在使用该对象之前使用 is T 检查类型。

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

Assignment operators 赋值运算符

正如您已经看到的，您可以使用 = 运算符分配值。要仅在分配给变量为 null 时进行分配，请使用 ??= 运算符。

// Assign value to a
a = value;
// Assign value to b if b is null; otherwise, b stays the same
b ??= value;

void main() {
  var a;
  var b = 1;
   a ??= 2;
   b ??= 3;
   print(a);
   print(b);
}

Log
.dart:305:4: Warning: Operand of null-aware operation '??=' has type 'int' which excludes null.
   b ??= 3;
   ^
2
1

+= 等复合赋值运算符将运算与赋值组合在一起。

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

var a = 2; // Assign using =
a *= 3; // Assign and multiply: a = a * 3
assert(a == 6);

Logical operators

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

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

Bitwise and shift operators

在 Dart 中操作数字的各个位。通常，您会对整数使用这些按位运算符和移位运算符。

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
assert((value >>> 4) == 0x02); // Unsigned shift right
assert((-value >> 4) == -0x03); // Shift right
assert((-value >>> 4) > 0); // Unsigned shift right

Conditional expressions

Dart 有两个运算符，可以让您简洁地评估可能需要 if-else 语句的表达式：

condition ? expr1 : expr2

如果条件为真，计算 expr1（并返回它的值）；否则，计算并返回 expr2 的值。

expr1 ?? expr2

如果 expr1 不为空，则返回其值；否则，计算并返回 expr2 的值。

当你需要根据布尔表达式赋值时，考虑使用 ? 和：。

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

如果布尔表达式测试为 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';
  }
}

Cascade notation

Cascades (.., ?..)允许您对同一对象进行一系列操作。除了访问实例成员之外，您还可以在同一个对象上调用实例方法。这通常可以节省您创建临时变量的步骤，并允许您编写更流畅的代码。

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

class Paint {
  var x;
  var y;
}

void main() {
  var p = Paint()
    ..y = 2
    ..x = 3;

  print(('${p.x},${p.y}'));
}

Log
3,2

如果级联操作的对象可以为null，那么第一次操作使用null-shorting级联(?..)。以 ?.. 开头保证不会对该空对象尝试任何级联操作。

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 语法的一部分。

Other operators