Dart语法汇总

///引入语句
import 'package:flutter/material.dart';
///设置别名
import 'package:flutter/material.dart' as appui;
///隐藏和显示库中某个对象
import 'package:math' show Random;
///延迟加载一个库
import 'package:deferred/hello.dart' deferred as hello;
///给引用该库的文件里聚合一个指定的文件
export 'package:deferred/hello.dart';
///库拆分，该文件和当前文件是一个整体两个部分
part 'LoginBean.g.dart';

/// 注释
/// Created by  
/// 2019-06-13
//
/** */

/// 基本数据类型定义
int a = 1;
double b = 1.0;
String c = 'c';
bool real = true;//false
var list = [0,1,2];//数组
var listString = ['1','2'];

var map = {'key':'value','key1':"value1"};//map
///添加一个元素map['newkey']='newvalue';

///可以不用+连接字符
String d = '字符连加'
    '后续字符';
String e =
'''
这是多行字符串
这是多行字符串
''';

///数据类型转换
String f = a.toString();
int g = int.parse(f);

String h = '这是一个插值演示：$a';
String i = '这是另一个插值演示：${a.toString()}';
String origin = r'这是一个原始字符串\n不换行';

///变量，常量，静态变量
var j = 1;
const k = 0;
final l = 0;
static var name;

///runes 字符串utf-32位表示
var utf32 = '\u1234';
var utf = '\u{19ff}';

///symbols编译时常量用#标识
// If the symbol name is known at compile time.
const className = #MyClass;
// If the symbol name is dynamically determined.
//var userInput = askUserForNameOfFunction();
//var functionName = new Symbol(userInput);

///避免null
var p = new Point(2, 2);
//用？号避免p为null  
p?.y = 4;

///初始化构造器将构造传进来的值赋值给成员变量
class Point {
  num x;
  num y;

  // Syntactic sugar for setting x and y
  // before the constructor body runs.
  Point(this.x, this.y);

  // 命名构造方法
  Point.fromJson(Map json) {
    x = json['x'];
    y = json['y'];
  }
}

///类的继承
class Person {
  String firstName;

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

class Employee extends Person {

  // 在子类：号后调用基类的命名构造函数
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

///在构造函数体执行之前除了可以调用超类构造函数之外，还可以初始化实例参数。使用逗号分隔初始化表达式。
class PointA {
  final num x;
  final num y;
  final num distanceFromOrigin;

//  const PointA(this.x, this.y);常量构造函数

//  factory PointA(int x) {//工厂方法构造函数
//    if(x == 0) {
//      return PointA(1,2);
//    }
//  }

  PointA(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

///抽象类
abstract class BasePage {
  void fromJson();
}

///将类当成方法返回定义call方法
class WannabeFunction {
  call(String a, String b, String c) => '$a $b $c!';
}

main() {
  var wf = new WannabeFunction();
  var out = wf("Hi","there,","gang");
  print('$out');
}

///流程控制语句
void loop() {
    var callbacks = [];
    for (var i = 0; i < 2; i++) {
      callbacks.add(() => print(i));
    }
    callbacks.forEach((c) => c());

    for (var x in callbacks) {
      print(x);
    }

    do {
      print('');
    } while (false);

   while (false) {
     print('');
     if(true) => break;
      if(true) => continue;
   }

    var command = 'OPEN';
    switch (command) {
      case 'CLOSED':
        print('');
        break;
      default:
        print('');
    }

  assert(0 < 100);
}

///异常处理
void misbehave() {
  try {
     foo = "You can't change a final variable's value.";
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }

  try {
    misbehave();
  } catch (e) {
    print('');
  }

///异常链和finally用法
  try {
       //....
  } on OutOfLlamasException {
        // A specific exception
         buyMoreLlamas();
  } on Exception catch (e) {
        // Anything else that is an exception
        print('Unknown exception: $e');
  } catch (e) {
         // No specified type, handles all
        print('Something really unknown: $e');
  } finally {
       cleanLlamaStalls();  // Then clean up.
  }


///方法
enableFlags({bool bold, bool hidden}) {
  // ...
}

///可选位置参数
String say(String from, String msg,[bool bold, bool hidden]) {
  return '';
}

///可选命名参数
void defaultParam({bool bold = false, bool hidden = false}) {
  // ...
}

///一句话声明一个方法
String single(String name) => 'This is a cat';

///方法赋值给变量
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';

///匿名方法
() {
...
}

///静态方法
class A {
  static void bar() {} // A static method
  void baz() {}        // An instance method
}

///一个闭包是一个方法对象，不管该对象在何处被调用，该对象都可以访问其作用域内的变量。
Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

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

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

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

///泛型
T first<T>(List<T> ts) {
 // ...Do some initial work or error checking, then...
  T tmp?= ts[0];
  // ...Do some additional checking or processing...
  return tmp;
}
class Foo<T extends Point> {}

///异步
checkVersion() async {
  var version = await lookUpVersion();
  if (version is Point) {
    // Do something.
 } else {
    // Do something else.
  }
}

///异步for循环
main() async {
  ...
  await for (var request in requestServer) {
    handleRequest(request);
  }
  ...
}

///工厂模式使用
class ImmutablePoint {
  num x;
  num y;
  ImmutablePoint(this.x, this.y);

  factory ImmutablePoint.fromJson(num x,num y) {
    if(x == 0) {
      return ChildA();
    } else {
      return ChildB();
    }
  }
}

class ChildA extends ImmutablePoint{
  String a = '1';
  ChildA():super(0,0);
}

class ChildB extends ImmutablePoint{
  String b = '2';
  ChildB():super(0,0);
}