Flutter基础--Dart

var greeting = 'hello, dart'; // type inference
String hi = '你好'; // use specific type
int awesome = 666;
dynamic typeVariableVar = 'variable';
typeVariableVar = 233; // assign int to typeVariableVar is OK, cause it's type is dynamic
awesome = '666'; // Error: A value of type 'String' can't be assigned to a variable of type 'int'

const HTTP_OK = 200;
const int errorCode = -1;

final now = DateTime.now();
final numbers = <int>[1, 2, 3];
numbers.add(4); // cannot ressign numbers to other value, but can add value to it
numbers[0] = 0; // this is OK too, cause value in final collection is not final
numbers = [5, 6, 7]; // Error: Can't assign to the final variable 'numbers'

// value in const collection is also const
const otherNumbers = <dynamic>[233, 666, 'awsl'];
otherNumbers[0] = 886; // Uncaught Error: Unsupported operation

var a = 1;
var b = 0xD800;
var c = 1.0;
var d = 1.0e10;
double e = 1; // Dart 2.1版本起 int类型字面量自动转换为double，所以flutter内很多组件属性类型是double但使用时可以自己传int
var one = int.parse('1');
int.parse('666'); // 666
int.parse('36', radix: 16); // 54 parse with radix
int.parse('0x29A'); // 666
double.parse('0.9'); // 0.9
123.456.toStringAsFixed(2) == '123.46');
123.456.toStringAsPrecision(2); // '1.2e+2'
123.456.toStringAsPrecision(4); // '123.5'
double.parse('1.23e+2'); // 123.0

var str1 = 'hello';
var str2 = "hi";
var name = 'world';
var strWithVar = 'hello, $name';
var strWithExpr = 'hello, ${name.toUpperCase()}';
var strConcat = 'String '
    'concatenation'
    " works even over line breaks.";

var strConcat = 'The + operator ' + 'works, as well.';
var multilineStr = """a string break into
multi-line like this.""";
var rawStr = r'In a raw string, not even \n gets special treatment.';
var emojiStr = '😁';
assert(emojiStr.length == 2); // true
var unicodeStr = '\u{1f601}'; // 😁
var surrogateUnicodeStr = '\ud83d\ude00'; // 😁
for (var char in emojiStr.runes) {
  print(char.toRadixString(16)); // 1f600
}

var str1 = 's';
var str2 = 's';
assert(str1 == str2); // true

'' == false // false
// Uncaught Error: Assertion failed: "boolean expression must not be null"
var nullVar;
if (!nullVar) {
  print();
}

''.isEmpty == true // true
nullVar == null // true

var arr = [1, 2, 3];
var constList = const [1, 2, 3];
var newList = [0, ...arr];
var nullArr;
var newArr = [0, ...?nullArr];

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

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

Set<String> countries = {};
var names = <String>{};
var languages = { 'chinese', 'english', 'japanese', 'german' };

var chineseNumbers = {
  0: '零',
  1：'一',
  2: '二'
};
var animals = Map(); // Dart 2开始创建对象时 new 操作符可选
animals['lion'] = '狮子';
animals['tiger'] = '老虎';

enum Color { red, green, blue }

List<Color> colors = Color.values;
assert(colors[0] == Color.red);

assert(Color.red.index == 0);

print(Color.red.toString().split('.').last); // red

bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null; // => expr 等效于 { return expr; } 只有当函数体只包含一条表达式时才能使用

void add(int op1, int op2) => op1 + op2;
// parameters wrapped by [] is optional positional parameters
String greeting(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}
void sayHi({ String name }) {}
void sayHello({ @required String name }) {}
void enableFlags({bool bold = false, bool hidden = false}) {...}

// cascade, perform multiple operations on the members of a single object
querySelector('#sample_text_id')
    ..text = 'Click me!'
    ..onClick.listen(reverseText);

// anonymous function
var list = ['apples', 'bananas', 'oranges'];
list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});

// ?.(conditional member access)
// ??(if null)
// ??=(if null assignment)
// ..(cascade)
// ...(spread operator)
// ...?(null-aware spread operator)
// as(typecast)
true is bool // is(positive typecheck)
3 is! bool // is!(negative typecheck)

class Duration implements Comparable<Duration> {
  ...

  /**
    * Adds this Duration and [other] and
    * returns the sum as a new Duration object.
    */
  Duration operator +(Duration other) {
    return Duration._microseconds(_duration + other._duration);
  }

  /**
    * Subtracts [other] from this Duration and
    * returns the difference as a new Duration object.
    */
  Duration operator -(Duration other) {
    return Duration._microseconds(_duration - other._duration);
  }

  ...
}

// if..else
if (isChinese()) {
  print('你好');
} else if (isJapanese()) {
  print('こんにちは');
} else {
  print('hello');
}

// for
var numbers = [0, 1, 2, 3];
for (var i = 0; i < numbers.length; i++) {
  print(numbers[i]);
}

for (var number in numbers) {
  print(number);
}

// while
var counter = 10;
while (counter > 0) {
  counter--;
  print(counter);
}

// do-while
var counter = 0;
do {
  counter++;
  print(counter);
} while (counter < 10);

// break
var counter = 10;
for (var i = 0; i < counter; i++) {
  if (i == 5) {
    break;
  }
  print(i); // prints 0 - 4
}

// continue
var counter = 10;
for (var i = 0; i < counter; i++) {
  if (i == 5) {
    continue;
  }
  print(i); // prints 0 - 4 6 - 9
}
// switch..case
var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    handleClose();
    break;
  case 'OPEN':
    handleOpen();
    break;
  case 'UNKOWN': // empty case clause is permitted
  case 'PENDING':
    handlePending();
    continue done; // continue with labeled case clause
  done:
  case 'DONE':
    handleDone();
    break;
  default:
    executeUnknown();
}

// assert
assert(text != null);
assert(text != null, 'text should be initialized');

throw SocketException("Socket is closed for reading");
throw ArgumentError('Index inside surrogate pair: $index');
throw UnsupportedError("Directory_SetCurrent");

// handle one exception
try {
  handleOrder();
} on FormatException {
  handleException();
}

// handle multiple exceptions
try {
  handleOrder();
} on Exception catch(e) {
  print('unknown exception: $e');
} catch (e, s) {
  print('yet another unknown exception: $e');
  print('Stack trace:\n $s'); // s stands for stacktrace
} finally {
  cleanUp();
}

var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b))

// 声明了构造函数 Point 类就不存在默认构造函数
class Point {
  double x, y;

  Point(this.x, this.y);

  // Named constructor
  Point.fromMap(Map data) {
    x = data['x'];
    y = data['y'];
  }

  // Redirect constructor, which just delegate to anthor constructor
  Point.alongXAxis(double x) : this(x, 0);
}

// const objects that never change
class ImmutablePoint {
  static final ImmutablePoint origin =
  const ImmutablePoint(0, 0);

  // all instance variables must set to final
  final double x, y;

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

// 调用AppBar构造函数前会先对参数进行校验、设置初始值、调用父类构造函数等一系列操作
AppBar({
  Key key,
  this.leading,
  this.automaticallyImplyLeading = true,
  this.title,
  this.actions,
  this.flexibleSpace,
  this.bottom,
  this.elevation,
  this.shape,
  this.backgroundColor,
  this.brightness,
  this.iconTheme,
  this.actionsIconTheme,
  this.textTheme,
  this.primary = true,
  this.centerTitle,
  this.excludeHeaderSemantics = false,
  this.titleSpacing = NavigationToolbar.kMiddleSpacing,
  this.toolbarOpacity = 1.0,
  this.bottomOpacity = 1.0,
}) : assert(automaticallyImplyLeading != null),
    assert(elevation == null || elevation >= 0.0),
    assert(primary != null),
    assert(titleSpacing != null),
    assert(toolbarOpacity != null),
    assert(bottomOpacity != null),
    preferredSize = Size.fromHeight(kToolbarHeight + (bottom?.preferredSize?.height ?? 0.0)),
    super(key: key);

class Point {
  static const size = 16;

  double x, y;
  Point(this.x, this.y);

  static double distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

assert(Queue.size == 16);
var a = Point(2, 2);
var b = Point(4, 4);
var distance = Point.distanceBetween(a, b);
print(distance);

class People {
  final String firstname;
  final String lastname;

  People({
    @required this.firstname,
    @required this.lastname,
  });

  String get fullname {
    return '$firstname $lastname';
  }
}

var noone = People('john', 'doe');
print(noone.fullname); // 'john doe'

class CallableClass {
  String call(String name) => 'hello $name!';
}

var cc = CallableClass();
var greeting = cc('john');
print(greeting);

class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
}

class SmartTelevision extends Television {
  @override
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
}

mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;

  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}

class Maestro extends Person
    with Musical, Aggressive, Demented {
  Maestro(String maestroName) {
    name = maestroName;
    canConduct = true;
  }
}

int.parse('42');

// lib/string_apis.dart
// extend String class add toInt method
extension String2Number on String {
  int toInt() {
    return int.parse(this);
  }
}

import 'string_apis.dart';
print('42'.toInt());

abstract class Human {
  void read(); // Abstract method.
}

class Person {
  // In the interface, but visible only in this library.
  final _name;

  // Not in the interface, since this is a constructor.
  Person(this._name);

  // In the interface.
  String greet(String name) => 'Hello, $name. I am $_name.';
}

// An implementation of the Person interface.
class Chinese implements Person, Comparable {
  int age;
  get _name => '';

  String greet(String name) => '$name 你好';

  static int compare(Comparable a, Comparable b) => a.age - b.age;
}

// for type safty
var names = List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
var moreNames = <String>['Tom', 'Joe'];
names.add(42); // Error

// reduce duplication
abstract class NumberCache {
  num getByKey(String key);
  void setByKey(String key, Object value);
}
abstract class StringCache {
  String getByKey(String key);
  void setByKey(String key, String value);
}
// When T is String it works the same as StringCache
// When T is num it works the same as NumberCache
abstract class Cache<T> {
  T getByKey(String key);
  void setByKey(String key, T value);
}

// key of map limited to int, value of map limited to Page object
var pages = Map<int, Page>();

// only object that implements Comparable interface allowed
var ranking = List<T implements Comparable>();

// only instances of Animal and it's sub class allowed
var ranking = List<T extends Animal>();

// use dart sdk library
import 'dart:async';
// use third-party package
import 'package:flutter/material.dart';
// import same library code by relative path
import '../utils/helper.dart';

// partial import
import 'package:lib1/lib1.dart' show foo; // import foo only
import 'package:lib2/lib2.dart' hide foo; // import all others except foo

// use alias to resolve conflicts
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// lazy load for dart2js
import 'package:greetings/hello.dart' deferred as hello;

// onError is optional
Future<int> successor = future.then(
  (int value) {
    // Invoked when the future is completed with a value.
    return 42;  // The successor is completed with the value 42.
  },
  onError: (e) {
    // Invoked when the future is completed with an error.
    if (canHandle(e)) {
      return 499;  // The successor is completed with the value 499.
    } else {
      throw e;  // The successor is completed with the error e.
    }
  }
);

import 'dart:async';
import 'dart:io';

void main() {
  new File('file.txt').readAsString().then((String contents) {
    print(contents);
  });
}

Stream<int> timedCounter(Duration interval, [int maxCount]) async* {
  int i = 0;
  while (true) {
    await Future.delayed(interval);
    yield i++;
    if (i == maxCount) break;
  }
}

Stream<int> timedCounter(Duration interval, [int maxCount]) {
  StreamController<int> controller;
  Timer timer;
  int counter = 0;

  void tick(_) {
    counter++;
    controller.add(counter); // Ask stream to send counter values as event.
    if (counter == maxCount) {
      timer.cancel();
      controller.close(); // Ask stream to shut down and tell listeners.
    }
  }

  void startTimer() {
    timer = Timer.periodic(interval, tick);
  }

  void stopTimer() {
    if (timer != null) {
      timer.cancel();
      timer = null;
    }
  }

  controller = StreamController<int>(
      onListen: startTimer,
      onPause: stopTimer,
      onResume: startTimer,
      onCancel: stopTimer);

  return controller.stream;
}

Future<void> printOrderMessage() async {
  print('Awaiting user order...');
  var order = await fetchUserOrder();
  print('Your order is: $order');
}

Future<String> fetchUserOrder() {
  return Future.delayed(Duration(seconds: 2), () => 'Large Latte');
}

Future<void> main() async {
  countSeconds(4);
  await printOrderMessage();
}

void countSeconds(int s) {
  for (var i = 1; i <= s; i++) {
    Future.delayed(Duration(seconds: i), () => print(i));
  }
}

// output
Awaiting user order...
1
2
Your order is: Large Latte
3
4

abstract class StatelessWidget extends Widget {
  const StatelessWidget({ Key key }) : super(key: key);

  // @override to mark subclass override parent's method
  @override
  StatelessElement createElement() => StatelessElement(this);

  @protected
  Widget build(BuildContext context);
}

@Deprecated(
  'Use CalendarDatePicker instead. '
  'This feature was deprecated after v1.15.3.'
)
class YearPicker extends StatefulWidget {
  ...
}

class Foo extends StatelessWidget {
  const Foo({
    Key key,
    @required Widget child,
  }) : super(key: key, child: child);
}