JavaScript 开发者学习 Dart

var a = 2;
var b = 1 + 1;

print(a == b); // 打印 true
print(identical(a, b)); // 打印 true；只有一个“2”对象存在

var rounded = 2.5.round();

var a = 'This is a string.';

final singleQuotes = 'I\'m learning Dart'; // I'm learning Dart
final doubleQuotes = "Escaping the \" character"; // Escaping the " character
final dollarEscape = 'The price is \$3.14.'; // The price is $3.14.
final backslashEscape = 'The Dart string escape character is \\.';
final unicode = '\u{1F60E}'; // 😎，Unicode 标量 U+1F60E

var food = 'bread';
var str = 'I eat $food'; // I eat bread
var str = 'I eat ${food}'; // I eat bread

final s1 = 'String '
    'concatenation'
    " works even over line breaks.";
assert(s1 ==
    'String concatenation works even over '
        'line breaks.');

var isBananaPeeled = false;

// 声明具有特定类型的变量
// 当您不提供初始值时
String name;
// 同时声明和初始化变量
// 并且 Dart 推断
// 类型
var name = 'bob';

var name = 'bob';
name = 5; // 禁止，因为 `name` 的类型为 `String` 。

// 声明一个没有类型或赋值的变量
// Dart 推断为 'dynamic' 类型
var name;
// 初始化变量，类型保持为 `dynamic`
name = 'bob';
name = 5; // 允许，因为 `name` 的类型为 `dynamic` 。

final String name;
// 在此处无法读取 name，未初始化。
if (useNickname) {
  name = "Bob";
} else {
  name = "Robert";
}
print(name); // 在此处已正确初始化。

var foo = const [];
  // foo 不是常量，但它指向的值是常量。
  // 您可以将 foo 重新赋值为不同的列表值，
  // 但其当前的列表值不能更改。

const baz = []; // 等效于 `const []`

// 在空安全的 Dart 中，这些变量永远不可能为 null。
var i = 42; // 推断为 int。
String name = getFileName();
final b = Foo(); // Foo() 调用构造函数

int? aNullableInt = null;

String? returnsNullable() {
  return random.nextDouble() < 0.5
    ? 'Sometimes null!'
    : null;
}

String returnsNonNullable() {
  return 'Never null!';
}

int? a = 5;

int b = a; // 不允许。
int b = a!; // 允许。

myObject!.someProperty;
myObject!.someMethod();

// 在顶层
int multiply(a, b) {
  return a * b;
}

// 作为类字段
class Multiplier {
  multiply(a, b) {
    return a * b;
  }
}

// 在局部作用域中
main() {
  multiply(a, b) {
    return a * b;
  }

  print(multiply(3, 4));
}

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

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

int multiply(int a, int b) {
  return a * b;
}

main() {
  multiply(3, 5); // 有效。所有参数都已提供。
  multiply(3); // 无效。必须提供所有参数。
}

// 有效： `b` 的默认值为 5。 `c` 被标记为可空。
multiply(int a, [int b = 5, int? c]) {
  ...
}
// 无效：必需位置参数位于可选参数之后。
multiply(int a, [int b = 5], int c) {
  ...
}
// 无效：可选位置参数既没有默认值，也没有被标记为可空。
multiply(int a, [int b, int c]) {
  ...
}

multiply(int a, [int b = 5, int? c]) {
  ...
}

main() {
  // 所有这些都是有效的函数调用。
  multiply(3);
  multiply(3, 5);
  multiply(3, 5, 7);
}

// 有效：
// - `a` 已被标记为必需
// - `b` 的默认值为 5
// - `c` 被标记为可空
// - 命名参数位于位置参数之后
multiply(bool x, {required int a, int b = 5, int? c}) {
  ...
}

// 所有这些都是有效的函数调用。
// 除了提供必需的位置参数之外：
multiply(false, a: 3); // 只提供必需的命名参数
multiply(false, a: 3, b: 9); // 重写 `b` 的默认值
multiply(false, c: 9, a: 3, b: 2); // 提供所有命名参数，顺序不限

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

var list = [1, 2, 3];

// 将 printElement 作为参数传递。
list.forEach(printElement);

// 将匿名函数赋值
// 给一个变量。
var blockFunc =
  optionalCallback ?? (int a, int b) {
    return a * b;
};

// 对于只有一个 return 语句的表达式，
// 可以使用箭头语法：
var singleFunc = (int a, int b) => a * b;

// 返回 [4, 5, 6]
[1, 2, 3].map((e) => e + 3).toList();

// 返回 [5, 7, 9]
var list2 = [1, 2, 3].map((e) {
  e *= 2;
  return e + 3;
}).toList();

Iterable<int> naturalsTo(int n) sync* {
  int k = 0;
  while (k < n) {
    yield k++;
  }
}

// 返回一个包含 [0, 1, 2, 3, 4] 的可迭代对象
print(naturalsTo(5).toList());

Iterable<int> doubleNaturalsTo(int n) sync* {
  int k = 0;
  while (k < n) {
    yield* [k, k];
    k++;
  }
}

// 返回一个包含 [0, 0, 1, 1, 2, 2] 的可迭代对象
print(doubleNaturalsTo(3));

for (final element in list) {
  print(element);
}

switch (testEnum) {
  case TestEnum.A:
    print('A');
    continue b;
  b:
  case TestEnum.B:
    print('B');
    break;
}

class Vector {
  final double x;
  final double y;
  final double z;
  Vector(this.x, this.y, this.z);
  Vector operator +(Vector other) => Vector(
    x + other.x, 
    y + other.y,
    z + other.z,
  );
  Vector operator *(double scalar) => Vector(
    x * scalar,
    y * scalar,
    z * scalar,
  );
}

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); // 余数

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

assert(25 == 50.4 ~/ 2);
assert(25 == 50.6 ~/ 2);
assert(25 == 51.6 ~/ 2);

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

(person as Employee).employeeNumber = 4204583;

if (person is Employee) {
   person.employeeNumber = 4204583;
}

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

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); // 左移
assert((value >> 4) == 0x02); // 右移
assert((-value >> 4) == -0x03); // 右移
assert((value >>> 4) == 0x02); // 无符号右移
assert((-value >>> 4) > 0); // 无符号右移

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

// 将值赋给 a
a = value;

var a = 5;
a *= 2; // 将 a 乘以 2 并将结果赋值回 a。
print(a); // a 现在为 10。

var animal = Animal() // 设置多个属性和方法
  ..name = "Bob"
  ..age = 5
  ..feed()
  ..walk();

print(animal.name); // "Bob"
print(animal.age); // 5

var result = maybePerson
    ?..employment = employer
    ..salary = salary;

// 初始化列表并指定完整类型
final List<String> list1 = <String>['one', 'two', 'three'];

// 使用简写类型初始化列表
final list2 = <String>['one', 'two', 'three'];

// Dart 也可以推断类型
final list3 = ['one', 'two', 'three'];

final fruits = <String>['apple', 'orange', 'pear'];
final fruit = fruits[1];

final fruits = <String>['apple', 'orange', 'pear'];
fruits.add('peach');
fruits.addAll(['kiwi', 'mango']);

final fruits = <String>['apple', 'orange', 'pear'];
fruits.insert(0, 'peach');
fruits.insertAll(0, ['kiwi', 'mango']);

final fruits = <String>['apple', 'orange', 'pear'];
fruits[2] = 'peach';

final fruits = <String>['apple', 'orange', 'pear'];
// 从列表中删除值 'pear'。
fruits.remove('pear');
// 从列表中删除最后一个元素。
fruits.removeLast();
// 从列表中删除位置 1 处的元素。
fruits.removeAt(1);
// 从列表中删除位置大于或等于 start (1) 且小于 end (3) 的元素。
fruits.removeRange(1, 3);
// 从列表中删除所有与给定谓词匹配的元素。
fruits.removeWhere((fruit) => fruit.contains('p'));

final fruits = <String>['apple', 'orange', 'pear'];
assert(fruits.length == 3);

var fruits = [];
assert(fruits.isEmpty);

final fruits = <String>['apple', 'orange', 'pear'];
assert(fruits.isNotEmpty);

final list1 = List.filled(3, 'a'); // 创建：['a', 'a', 'a']

// 创建：['a0', 'a1', 'a2']
final list1 = List.generate(3, (index) => 'a$index');

final abc = {'a', 'b', 'c'};

final names = <String>{};
// Set<String> names = {}; // 这也行得通。
// final names = {}; // 创建一个空映射，而不是集合。

final fruits = {'apple', 'orange', 'pear'};
fruits.add('peach');
fruits.addAll(['kiwi', 'mango']);

final fruits = {'apple', 'orange', 'pear'};
// 从集合中删除值 'pear'。
fruits.remove('pear');
// 从集合中删除提供的列表中的所有元素。
fruits.removeAll(['orange', 'apple']);
// 从列表中删除所有与给定谓词匹配的元素。
fruits.removeWhere((fruit) => fruit.contains('p'));

final fruits = {'apple', 'orange', 'pear'};
assert(fruits.length == 3);

var fruits = <String>{};
assert(fruits.isEmpty);

final fruits = {'apple', 'orange', 'pear'};
assert(fruits.isNotEmpty);

final gifts = {
  'first': 'partridge',
  'second': 'turtle doves',
  'fifth': 'golden rings'
};

final nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

final gifts = {'first': 'partridge'};
final gift = gifts['first'];

final gifts = {'first': 'partridge'};
assert(gifts.containsKey('fifth'));

final gifts = {'first': 'partridge'};
gifts['second'] = 'turtle'; // 添加
gifts['second'] = 'turtle doves'; // 更新

final gifts = {'first': 'partridge'};
gifts['second'] = 'turtle doves';
gifts.addAll({
  'second': 'turtle doves',
  'fifth': 'golden rings',
});
gifts.addEntries([
  MapEntry('second', 'turtle doves'),
  MapEntry('fifth', 'golden rings'),
]);

final gifts = {'first': 'partridge'};
gifts.remove('first');
gifts.removeWhere((key, value) => value == 'partridge');

final gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds';
assert(gifts.length == 2);

final gifts = {};
assert(gifts.isEmpty);

final gifts = {'first': 'partridge'};
assert(gifts.isNotEmpty);

final _set = Set<String>.unmodifiable(['a', 'b', 'c']);
final _list = List<String>.unmodifiable(['a', 'b', 'c']);
final _map = Map<String, String>.unmodifiable({'foo': 'bar'});

var list1 = [1, 2, 3];
var list2 = [0, ...list1];　// [0, 1, 2, 3]
// 当要插入的列表可能为 null 时：
list1 = null;
var list2 = [0, ...?list1]; // [0]

// 使用映射的展开运算符
var map1 = {'foo': 'bar', 'key': 'value'};
var map2 = {'foo': 'baz', ...map1}; // {foo: bar, key: value}
// 使用集合的展开运算符
var set1 = {'foo', 'bar'};
var set2 = {'foo', 'baz', ...set1}; // {foo, baz, bar}

var nav = [
  'Home',
  'Furniture',
  'Plants',
  if (promoActive) 'Outlet',
];

var listOfInts = [1, 2, 3];
var listOfStrings = [
  '#0',
  for (var i in listOfInts) '#$i',
]; // [#0, #1, #2, #3]

Future<String> httpResponseBody = func();

httpResponseBody.then((String value) {
  print('Future resolved to a value: $value');
});

httpResponseBody
  .then(...)
  .catchError((err) {
    print(
      'Future encountered an error before resolving.'
    );
  });

String str = 'String Value';
Future<String> strFuture = Future<String>.value(str);

// 返回一个字符串的 future，
// 因为该方法是异步的
Future<String> fetchString() async {
  // 通常在此处会执行其他异步操作。
  return 'String Value';
}

Future<String> stringFuture = fetchString();
stringFuture.then((String str) {
  print(str); // 'String Value'
});

// 我们只能在 async 上下文中等待 future。
Future<void> asyncFunction() async {
  var str = await fetchString();
  print(str); // 'String Value'
}

Stream<int> stream = ...
stream.listen((int value) {
  print('A value has been emitted: $value');
});

stream.listen(
  (int value) { ... },
  onError: (err) {
    print('Stream encountered an error! $err');
  },
  onDone: () {
    print('Stream completed!');
  },
);

StreamSubscription subscription = stream.listen(...);
subscription.cancel();

Future<int> sumStream(Stream<int> stream) async {
  var sum = 0;
  await for (final value in stream) {
    sum += value;
  }
  return sum;
}

try {
  await for (final value in stream) { ... }
} catch (err) {
  print('Stream encountered an error! $err');
}

var listeners = 0;
StreamController<int>? controller;
controller = StreamController<int>(
  onListen: () {
    // 每当流获得新的监听器时，都会发出一个新值。
    controller!.add(listeners++);
    // 在第五个监听器之后关闭流。
    if (listeners > 5) controller.close();
  }
);
// 获取流控制器的流
var stream = controller.stream;
// 监听流
stream.listen((int value) {
  print('$value');
});

Stream<int> asynchronousNaturalsTo(int n) async* {
  var k = 0;
  while (k < n) yield k++;
}

Stream<int> stream = asynchronousNaturalsTo(5);

// 依次打印 0 1 2 3 4 中的每一个。
stream.forEach(print(value));

class Point {
  final double x;
  final double y;

  Point(double x, double y) : this.x = x, this.y = y { }
}

// 创建 Point 类的新的实例
Point p = Point(3, 5);

class Point {
  ...
  Point.fromJson(Map<String, double> json)
      : x = json['x']!,
        y = json['y']! {
    print('In Point.fromJson(): ($x, $y)');
  }
  ...
}

class Point {
  double x;
  double y;

  // 用于在构造函数主体运行之前设置 x 和 y 的语法糖。
  Point(this.x, this.y);
}

// 创建 Point 类的新的实例
Point p = Point(3, 5);

class Point {
  ...
  // 带有一个可选的位置参数
  Point(this.x, [this.y = 5]);
  // 带有命名参数
  Point({ required this.y, this.x = 5 });
  // 带有位置参数和命名参数
  Point(int x, int y, { boolean multiply }) {
    ...
  }
  ...
}

const double xOrigin = 0;
const double yOrigin = 0;

class Point {
  double x = 0;
  double y = 0;

  Point(this.x, this.y);

  // 命名构造函数
  Point.origin()
      : x = xOrigin,
        y = yOrigin;
}

class ImmutablePoint {
  final double x, y;

  const ImmutablePoint(this.x, this.y);
}

class Point {
  double x, y;

  // 此类的主要构造函数。
  Point(this.x, this.y);

  // 委托给主构造函数。
  Point.alongXAxis(double x) : this(x, 0);
}

class Logger {
  static final Map<String, Logger> _cache =
      <String, Logger>{};
 
  final String name;
 
  // 工厂构造函数，返回缓存的副本，
  // 或在尚未可用时创建一个新的副本。
  factory Logger(String name) {
    return _cache.putIfAbsent(
        name, () => _cache[name] ??= Logger._internal(name);
  }

  // 仅供内部使用的私有构造函数
  Logger._internal(this.name);
}

void doSomething() { // 这是一个函数
 // 实现..
}

class Example {
 void doSomething() { // 这是一个方法
   // 实现..
 }
}

class Animal {
  int eyes;
 
  Animal(this.eyes);
 
  makeNoise() {
    print('???');
  }
}

class Cat extends Animal {
  Cat(): super(2);

  @override
  makeNoise() {
    print('Meow');
  }
}
Animal animal = Cat();
print(animal.eyes); // 2
animal.makeNoise(); // Meow

class Cat extends Animal {
  ...
  @override
  makeNoise() {
    print('Meow');
    super.makeNoise();
  }
}
Animal animal = Cat();
animal.makeNoise(); // Meow
                    // ???

class Consumer {
  consume() {
    print('Eating food...');
  }
}
class Cat implements Consumer {
  consume() {
    print('Eating mice...');
  }
}
Consumer consumer = Cat();
consumer.consume(); // Eating mice

class Cat implements Consumer {
  @override
  consume() {
    print('Eating mice...');
    super.consume(); 
    // 无效。超类 `Object` 没有 `consume` 方法。
  }
}

abstract class Consumer {
  consume();
}
// 扩展完整类
class Dog extends Consumer {
  consume() {
    print('Eating cookies...');
  }
}
// 只实现接口
class Cat implements Consumer {
  consume() {
    print('Eating mice...');
  }
}
Consumer consumer;
consumer = Dog();
consumer.consume(); // Eating cookies...
consumer = Cat();
consumer.consume(); // Eating mice...

abstract class Animal {}

// 定义 mixin
class Flyer {
  fly() => print('Flaps wings');
}
class Walker {
  walk() => print('Walks on legs');
}
 
class Bat extends Animal with Flyer {}
class Goose extends Animal with Flyer, Walker {}
class Dog extends Animal with Walker {}

// 正确的调用
Bat().fly();
Goose().fly();
Goose().walk();
Dog().walk();
// 错误的调用
Bat().walk(); // 没有使用 Walker mixin
Dog().fly(); // 没有使用 Flyer mixin

mixin Walker {
  walk() => print('Walks legs');
}
// 不可能，因为 Walker 不再是类。
class Bat extends Walker {}

class Bird extends Animal with Consumer, Flyer {

extension NumberParsing on String {
  int parseInt() {
    return int.parse(this);
  }
}

import 'string_apis.dart'; // 导入扩展所在的的文件
var age = '42'.parseInt(); // 使用扩展方法。

class Person {
  int _age = 0;
 
  int get age {
    return _age;
  }
 
  set age(int value) {
    if (value < 0) {
      throw ArgumentError(
        'Age cannot be negative'
        );
    }
    _age = value;
  }
}

void main() {
  var person = Person();
  person.age = 10;
  print(person.age);
}

class Animal {
  int eyes; // 公有字段
  int _paws; // 私有字段

  void _printEyes() { // 私有方法
    print(this.eyes);
  }

  void printPaws() { // 公有方法
    print(this._paws);
  }
}

class PetOwner {
  final String name;
  late final Pet _pet;
  PetOwner(this.name, String petName) {
    // 循环对象图，在所有者存在之前无法设置 _pet。
    _pet = Pet(petName, this);
  }
  Pet get pet => _pet;
}
class Pet {
  final String name;
  final PetOwner owner;
  Pet(this.name, this.owner);
}

doSomething(int n, bool capture) {
  late List<Foo> captures;
  if (capture) captures = [];
  for (var i = 0; i < n; i++) {
    var foo = something(i);
    if (capture) captures.add(foo);
  }
}

Map<Object?, Object?> _cache = {};
T cache<T>(T value) => (_cache[value] ??= value) as T;

// 定义一个具有多个泛型的的方法。
T transform<T, Q>(T param1, Q param2) {
   ...
}
// 使用显式定义的类型调用该方法。
transform<int, String>(5, 'string value');
// 当分析器可以推断类型时，类型是可选的。
transform(5, 'string value');

class Cache<T> {
  T getByKey(String key) {}
  void setByKey(String key, T value) {}
}
// 为字符串创建缓存
var stringCache = Cache<String>(); // stringCache 的类型为 Cache<String>
stringCache.setByKey('Foo', 'Bar'); // 有效，设置字符串值。
stringCache.setByKey('Baz', 5); // 无效，int 类型与泛型不匹配。

class NumberManager<T extends num> {
   ...
}
// 有效。
var manager = NumberManager<int>();
var manager = NumberManager<double>();
// 无效，String 及其父类不扩展 num。
var manager = NumberManager<String>();

// 自动类型推断
var objList = [5, 2.0]; // 类型：List<num>
// 显式类型定义：
var objList = <Object>[5, 2.0]; // 类型：List<Object>
// 集合的工作方式相同：
var objSet = <Object>{5, 2.0};

// 自动类型推断
var map = {
  'foo': 'bar'
}; // 类型：Map<String, String>
// 显式类型定义：
var map = <String, Object>{
  'foo': 'bar'
}; // 类型：Map<String, Object>

/// 未拆分时此块中的字符数。
int get length => ...