函数

1、Dart 是完全面向对象的语言，即使是函数也是对象，所以函数也可以被声明成变量，或者作为另一个函数的参数。也可以像调用函数一样调用类的实例变量。
函数例子：

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

2、建议函数都指明返回值类型，虽然不写类型也能执行。
3、函数只有一行表达式的，可以使用尖头语法简写成：

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

4、函数有两种参数类型：规定参数和可选参数。先列出规定参数，可选参数跟随其后。命名成可选的参数也可以被标记为规定参数。

可选参数

可选参数可以按位置设置，或者按命名设置，但是不能同时使用。

可选命名参数

调用一个函数时可以用参数名字指明参数使用paramName: value.例如：

enableFlags(bold: true, hidden: false);

定义函数的时候使用{param1, param2, …}来明确参数：

void enableFlags({bool bold, bool hidden}) {...}

Flutter创建实例的表达式可以非常复杂，所以widget的构造方法必须使用带名称的参数。这样创建实例的表达式易于阅读。你也可以在任何Dart代码中用@required标记一个已经命名的参数，来指明这是一个必选参数。例如：

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

当一个Scrollbar被创建的时候，如果缺少参数，解析器会报错。

可选位置参数

在函数参数中用[]符号包裹可选的位置参数：

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

不带可选参数调用方法举例：

assert(say('Bob', 'Howdy') == 'Bob says Howdy');

包含可选参数举例：

assert(say('Bob', 'Howdy', 'smoke signal') == 'Bob says Howdy with a smoke signal');

默认参数值

可以使用=来指明参数的默认值。默认值必须是编译时常量。如果没有默认值，默认值就是null。
有名参数的例子：

void enableFlags({bool bold = false, bool hidden = false}) {...}
enableFlags(bold:true);

位置参数的例子：

String say(String from, String msg, [String device = 'carrier pigeon', String mood]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  if (mood != null) {
    result = '$result (in a $mood mood)';
  }
  return result;
}
assert(say('Bob', 'Howdy') ==  'Bob says Howdy with a carrier pigeon');

也可以传数组或者字典作为默认值，例如：

void doStuff( {List<int> list = const [1, 2, 3], Map<String, String> gifts = const {
        'first': 'paper',
        'second': 'cotton',
        'third': 'leather'
       }
    }
  ) {
  print('list:  $list');
  print('gifts: $gifts');
}

main()函数

每个app必须有一个顶级的main()函数，提供程序的入口。main()函数返回void类型并且有一个list<String>类型的可选参数。例子：

void main() {
  querySelector('#sample_text_id')
    ..text = 'Click me!'
    ..onClick.listen(reverseText);
}

..语法叫级连。使用级连可以对一个对象的成员执行多个操作。
示例代码：

void main(List<String> arguments) {
  print(arguments);

  assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}

函数作为一等对象

你可以传递一个函数作为另一个函数的参数。例如：

void printElement(int element) {
print(element);
}
var list = [1.2.3];
list.forEach(printElement);

也可以声明一个函数给一个变量，例如：

var loudify = (msg)

匿名函数

Dart也可以创建匿名函数，或者叫作拉姆达表达式或闭包。可以给一个变量赋值一个匿名函数，例如在一个集合中进行添加、删除。
匿名函数看起来像一个有名称的函数零个或多个参数在圆括号中用逗号或中括号分隔，代码块在函数体后边。
下面的例子定义了一个匿名函数，包含一个无类型的参数item。这个函数调用列表中的每一项，打印一个特定索引和其对应值的字符串。

var list = ['apple', 'banana', 'orange'];
list.forEach((item) {
print('${list.indexOf(item)}:$item');
});

简写成

list.forEach((item) => print('${list.indexOf(item)}:$item'));

静态作用域

Dart是一个静态作用域的语言，意味着变量的作用域是在写代码的时候就提前定义好的。可以看一个函数是否在花括号里边来看他的作用域。
下面是一个例子展示函数的嵌套和变量的作用域级别：

bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideNestedFunction = true;

    assert(topLevel);
    assert(insideMain);
    assert(insideFunction);
    assert(insideNestedFunction);
  }
}

词法闭包

一个闭包是一个函数对象，它有接口来获取闭包中的变量，即使在它原来的作用域之外使用。
函数能够关闭作用域内的变量。下面的例子中makeAdder函数捕获了addBy变量。不管返回的参数在哪儿执行，它都能记住addBy。

Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

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

检测函数相等

下面的例子是测试顶级函数，静态方法，和实例方法的相等：

void foo() {} // A top-level function

class A {
  static void bar() {} // A static method
  void baz() {} // An instance method
}

void main() {
  var x;

  // Comparing top-level functions.
  x = foo;
  assert(foo == x);

  // Comparing static methods.
  x = A.bar;
  assert(A.bar == x);

  // Comparing instance methods.
  var v = A(); // Instance #1 of A
  var w = A(); // Instance #2 of A
  var y = w;
  x = w.baz;

  // These closures refer to the same instance (#2),
  // so they're equal.
  assert(y.baz == x);

  // These closures refer to different instances,
  // so they're unequal.
  assert(v.baz != w.baz);
}

返回值

所有的函数都有返回值，如果没有指明返回值，函数返回null；会默认的拼接到函数体。

foo() {}

assert(foo() == null);