一、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');
}

四、类

类是特定类型的数据和方法的集合，也是创建对象的模板。与其他语言一样，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 和运算符作为整体，看作是一个成员函数名。