Dart学习笔记（3）:函数

函数

Dart 是一种真正面向对象的语言，所以即便函数也是对象并且类型为 Function，这意味着函数可以被赋值给变量或者作为其它函数的参数。
定义一个函数比如：

 String getName(String name){
	return "my name is${name} ";
 }

返回值类型可以省略：

  getName(String name){
	return  "my name is${name} ";
  }

如果函数体内只包含一个表达式，你可以使用简写语法：

getName(String name)=>"my name is${name} ";

语法 => 表达式 是 { return 表达式; } 的简写， => 有时也称之为 箭头 函数。
在 => 与 ; 之间的只能是 表达式 而非 语句。比如你不能将一个 if语句 放在其中，但是可以放置 条件表达式。比如

getAge(int age) => age > 18 ? 0 : 1;

void main() {
  print(getAge(20));
 }
//输出：0

参数：

函数可以有两种形式的参数：必要参数 和 可选参数。必要参数定义在参数列表前面，可选参数则定义在必要参数后面。可选参数可以是 命名的 或 位置的。
命名参数：命名参数默认为可选参数，除非他们被特别标记为 required。
当你调用函数时，可以使用 参数名: 参数值 的形式来指定命名参数。
例如：
//声明一个命名参数的函数

 void getPerson(String name ,int age ,{String country}){
     if(country!=null){
         print("my name is ${name},and I am ${age} years old ,and come from ${country}");
     }else{
         print("my name is ${name},and I am ${age} years old");
     }
 }
 //调用函数
 void main(){
   getPerson("jack",18,country:"CHN");//打印输出：my name is   jack,and I am 18 years old ,and come from CHN
   getPerson("jack",18);//打印输出：my name is jack,and I am 18  years old
 }

如果 country 用required 修饰 则country参数一定要传值
例如：

void getPerson(String name ,int age ,{required String country}){
   print("my name is ${name},and I am ${age} years old ,and come from ${country}");
}
 void main(){
   getPerson("jack",18,country:"US");
}

可选位置参数：使用 [] 将一系列参数包裹起来作为位置参数：
//声明一个可选位置参数

void getPerson(String name ,int age ,[String country]){
     if(country!=null){
         print("my name is ${name},and I am ${age} years old ,and come from ${country}");
     }else{
         print("my name is ${name},and I am ${age} years old");
     }
   }
 void main(){
     getPerson("jack",18);
     getPerson("jack",18,"US");
   }

可以看出来 命名参数和位置参数赋值时 命名参数要指定名字赋值。例如：country:“US”，位置参数只要传入对应的类型值就行了
默认参数值
可以用 = 为函数的命名参数和位置参数定义默认值，默认值必须为编译时常量，没有指定默认值的情况下默认值为 null。

void getPerson(String name ,int age ,{String country="CHN" }){
	print("my name is ${name},and I am ${age} years old ,and come from ${country});
  }
void main(){
	getPerson("jack",18);
  }
输出：my name is jack,and I am 18 years old ,and come from CHN

函数：作为参数传递给另一个函数

int add(int a, int b) {
  return a + b;
 }

int test(int a, int b, Function operation) {
  return operation(a, b);
 }

void main() {
   print(test(5, 2, add));
 }

匿名函数：

大多数方法都是有名字的，比如 main() 或 printElement()。你可以创建一个没有名字的方法，称之为 匿名函数、 Lambda 表达式 或 Closure 闭包。你可以将匿名方法赋值给一个变量然后使用它，比如将该变量添加到集合或从中删除。
匿名方法看起来与命名方法类似，在括号之间可以定义参数，参数之间用逗号分割。

后面大括号中的内容则为函数体：

([[类型] 参数[, …]]) {
  函数体;
};

声明2个数相加的匿名函数

  var result=(x,y)=>{print(x+y)};
  result(1,2);//打印结果为3

或者如果函数体内只有一行返回语句，你可以使用胖箭头缩写法。

var result=(int x,int y)=>print(x+y);//参数最好加上参数类型

立即执行方法，就是写完就执行的方法，不必调用，运行就执行，
格式:(匿名方法)()

 ((x,y)=>{print(x+y)})(1,2);//打印结果为3

参数最好加上参数类型，比如

((int x,int y)=>{print(x+y)})(1,2);//打印结果为3

闭包

闭包是一个方法（对象） 闭包定义在其他方法内部
闭包能够访问外部方法内的局部变量，并持有其状态（这是闭包最大的作用，可以通过闭包的方式，将其暴露出去，提供给外部访问） 闭包:
函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)

闭包的写法： 函数嵌套函数，并return 里面的函数，这样就形成了闭包。

如下例子：

getAdd(int num) {
  int count = 100;
  // 内部声明一个函数 : 闭包
  printCount() {
    // 内部可以访问外部方法内的局部变量 count
    print(count + num);
  };
  // 返回闭包
  return printCount;
}

匿名函数的写法

getAdd(int num) {
  int count = 100;
  // 返回闭包
  return () {  // 内部声明一个匿名函数 : 闭包
    // 内部可以访问外部方法内的局部变量 count
    print(count + num);
  };
}

匿名函数只有一个表达式，可以用箭头函数，如下

getAdd(int num) {
  int count = 100;
  return () => print(count + num);
}
void main() {
  var func = getAdd(150);
  func();//打印250
}

词法作用域

Dart 是词法有作用域语言，变量的作用域在写代码的时候就确定了，大括号内定义的变量只能在大括号内访问

int boss = 100;
void a() {
  int a = 1;
  print(boss);
  print(b); //报错：Local variable 'b' can't be referenced before it is declared.
  void b() {
    int b = 2;
    print(boss);
    void c() {
      int c = 3;
      print(boss);
      void d() {//d()函数可以访问包括顶层变量在内的所有的变量。
        print(a + b + c + boss);
      }
    }
  }
}

返回值

所有的函数都有返回值。没有显示返回语句的函数最后一行默认为执行 return null;。

getBird() {
  }
void main() {
  print(getBird());//输出null
}