上手指南 | Dart，随用随查

main(){
  var number = "Hello World";
  printInteger(number);
}
//定义一个函数
printInteger(int aNumber){
  print('The number is $aNumber');
}

dynamic name = "345"; // name 被推断为 String类型
String name = "345";//显式声明

var constantList = const [1, 2, 3];

var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
var names = <String>{};
// Set<String> names = {}; // 这样也是可以的。
// var names = {}; // 这样会创建一个 Map ，而不是 Set 。
var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);

var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

var nobleGases = Map();
nobleGases[2] = 'helium';
nobleGases[10] = 'neon';
nobleGases[18] = 'argon';  

a = b ?? c;

//若 a 为 null，则将 b 赋值给 a
a ?? = b;

//当 x 不为 nul 时，调用 fun 函数
a?.fun();

isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}
//如果只有一句话，可简洁写法
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

const Scrollbar({Key key, @required Widget child,bool bold})

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

// bold 值为 true; hidden 值为 false.
void abc(bool bold = false);

void main(){
}
// 这样运行应用： dart args.dart 1 test
void main(List<String> arguments) {
  print(arguments);
}

main(){
  var list = [];
  list.add(1);
  list.add(2);
  list.add(3);
  list.add(4);
  
  list.forEach((num){
    print('位置：${list.indexOf(num)} ；值：$num');
  });
}

list.forEach((num)=>print('位置：${list.indexOf(num)} ；值：$num'));

main(){
  //将匿名函数赋值给变量
  var one = (num)=>print(' 值：$num');
  one(10);
  
  //将普通函数赋值给变量
  var two = abc;
  two(20);
  
  //将匿名函数传递给普通函数
  abc2((str) => print("abc $str"));
}

void abc2(fun(String str)){
 fun("输出-------》");
}

void abc(num){
  print("哈哈哈：$num");
}

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

/// 返回一个函数，返回的函数参数与 [addBy] 相加。
Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

void main() {
  // 创建一个加 2 的函数。
  var add2 = makeAdder(2);

  // 创建一个加 4 的函数。
  var add4 = makeAdder(4);

  assert(add2(3) == 5);
  assert(add4(3) == 7);
}

void foo() {} // 顶级函数

class A {
  static void bar() {} // 静态方法
  void baz() {} // 示例方法
}

void main() {
  var x;

  // 比较顶级函数。
  x = foo;
  assert(foo == x);

  // 比较静态方法。
  x = A.bar;
  assert(A.bar == x);

  // 比较实例方法。
  var v = A(); // A的1号实例
  var w = A(); // A的2号实例
  var y = w;
  x = w.baz;

  // 两个闭包引用的同一实例（2号）,
  // 所以它们相等。
  assert(y.baz == x);

  // 两个闭包引用的非同一个实例，
  // 所以它们不相等。
  assert(v.baz != w.baz);
}

extension StringExt on String {
  double toDouble() {
    return double.parse(this);
  }
  int toInt() {
    return int.parse(this);
  }
}

Object扩展：
extension ObjectExt on Object {
  bool isNullOrEmpty() {
    if (this is String)
      return (this as String).isEmpty;
    else if (this is Iterable) return (this as Iterable).isEmpty;
    return this == null;
  }
}

泛型扩展：
extension AllExt<T> on T {
  T apply(f(T e)) {
    f(this);
    return this;
  }

  R let<R>(R f(T e)) {
    return f(this);
  }
}

//扩展属性
extension SizeExtension on num {

  double get w => 10.0;

  double get h => 10.0;
}

*condition* ? *expr1* : *expr2*

*expr1* ?? *expr2*

void main() {
  new A()
	  ..a1()
	  ..a2();
}
class A{
	void a1(){
		print('a1');
	}
	
	void a2(){
		print('a2');
	}
}
//a1  a2

final addressBook = (AddressBookBuilder()
      ..name = 'jenny'
      ..email = 'jenny@example.com'
      ..phone = (PhoneNumberBuilder()
            ..number = '415-555-0100'
            ..label = 'home')
          .build())
    .build();

for (var i = 0; i < 5; i++) {
  message.write('!');
}

candidates.forEach((candidate) => candidate.interview());

var collection = [0, 1, 2];
for (var x in collection) {
  print(x); // 0 1 2
}

throw FormatException('Expected at least 1 section');

void distanceTo(Point other) => throw UnimplementedError();

void distanceTo(Point other) => throw UnimplementedError();

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // 一个特殊的异常
  buyMoreLlamas();
} on Exception catch (e) {
  // 其他任何异常
  print('Unknown exception: $e');
} catch (e) {
  // 没有指定的类型，处理所有异常
  print('Something really unknown: $e');
}

try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // Runtime error
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}

void main() {
  try {
    misbehave();
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}

var p = Point(2, 2);

// 为实例的变量 y 设置值。
p.y = 3;

// 获取变量 y 的值。
assert(p.y == 3);

//如果 p 非空，则设置y=8
p?.y = 8

// 调用 p 的 distanceTo() 方法。
num distance = p.distanceTo(Point(4, 4));

class Point {
  num x; // 声明示例变量 x，初始值为 null 。
  num y; // 声明示例变量 y，初始值为 null 。
  num z = 0; // 声明示例变量 z，初始值为 0 。
}

class Point {
  num x, y;

  Point(this.x, this.y);

  // 命名构造函数
  Point.origin() {
    x = 0;
    y = 0;
  }
}

class Person {
  String firstName;

  Person.fromJson(Map data) {
    print('in Person');
  }
}

class Employee extends Person {
  // Person does not have a default constructor;
  // you must call super.fromJson(data).
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

main() {
  var emp = new Employee.fromJson({});

  // Prints:
  // in Person
  // in Employee
  if (emp is Person) {
    // Type check
    emp.firstName = 'Bob';
  }
  (emp as Person).firstName = 'Bob';
}

var p = const ImmutablePoint(2, 2);

// 这里有很多的 const 关键字。
const pointAndLine = const {
  'point': const [const ImmutablePoint(0, 0)],
  'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)],
};

  // 仅有一个 const ，由该 const 建立常量上下文。
const pointAndLine = {
  'point': [ImmutablePoint(0, 0)],
  'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],
};

class ImmutablePoint {
  static final ImmutablePoint origin =
      const ImmutablePoint(0, 0);

  final num x, y;

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

class Logger {
  final String name;
  bool mute = false;

  // 从命名的 _ 可以知，
  // _cache 是私有属性。
  static final Map<String, Logger> _cache =
      <String, Logger>{};

  factory Logger(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final logger = Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }

  Logger._internal(this.name);

  void log(String msg) {
    if (!mute) print(msg);
  }
}

void main() {
  print("start ----------->");
  print(getNetData());
  print("end -------------->");
}

String getNetData() {
  //耗时 3 秒
  sleep(Duration(seconds: 3));
  return "网络数据";
}

start ----------->F
//耗时三秒，打印如下
网络数据
end -------------->

Future<String> getNetData() {
  return Future(() {
    sleep(Duration(seconds: 3));
    return "网络数据";
  });
}

start ----------->
Instance of 'Future<String>'
end -------------->

//getNetData 返回的 future 有返回结果时，就会自动调用 then 中传入的函数
//该函数会被放在事件循环中，被执行
getNetData().then((value) {
  print(value);
});

start ----------->
end -------------->
网络数据

getNetData().then((value) {
  //支持成功到此处
  print(value);
}).catchError((error) {
  //执行失败到此处
  print(error);
});

getNetData().then((value) {
  //支持成功到此处
  print(value);
}).catchError((error) {
  //执行失败到此处
  print(error);
}).whenComplete(() => print("完成"));

//在 them 中可以接继续返回值，该值会在下一个链式的 then 调用中拿到返回的结果
getNetData().then((value) {
  //支持成功到此处
  print(value);
  return "data1";
}).then((value) {
  print(value);
  return "data2";
}).then((value) {
  print(value);
}).catchError((error) {
  //执行失败到此处
  print(error);
}).whenComplete(() => print("完成"));

网络数据
data1
data2
完成

Future.wait([getNetData(), getNetData(), getNetData()]).then((value) {
  value.forEach((element) {
    print(element);
  });
});

 Future.delayed(Duration(seconds: 3), () {
    return "3秒后的信息";
  }).then((value) {
    print(value);
  });

void main() {
  print("start ------
  ----->");

  getNetData().then((value) => print(value));

  print("end -------------->");
}

Future<String> getNetData() async {
  var result1 = await Future.delayed(Duration(seconds: 3), () {
    return "网络数据1";
  });
  var result2 = await Future.delayed(Duration(seconds: 3), () {
    return "网络数据2";
  });
  return result1 + "-----" + result2;
}

在 getNetData 中，拿到两个结果进行拼接，然后一起返回
  
  返回值会被包装在一个 Futter 中，在调用处就可以使用 them 直接拿到结果

---

> 参考文献：官方文档，Flutter实战，[Dart 异步](https://juejin.cn/post/6844903942795558919#heading-11)



## 下面让我们一起

> happy codeing