Dart入门03 -- 函数，闭包，运算符，枚举

函数

函数的定义

main(List<String> args) {
  print(sum(10, 30));
}

//1.返回值类型可以省略，开发中不推荐这么写
int sum(int num1, int num2) {
  return num1 + num2;
}

• 函数返回值类型可以省略，开发中不推荐这么写；

函数的参数

• Dart中不支持函数的重载；
• 函数的参数可分为两类：
  • 必选参数：必须传，不存在默认值；
  • 可选参数：位置可选参数 ，命令可选参数，存在默认值；

必传参数

• 案例代码如下：

main(List<String> args) {
  sayHello1("liyanyan");
}

//1.必选参数：必须传
void sayHello1(String name) {
  print(name);
}

位置可选参数

• 位置可选参数 用 []，参和行参在进行匹配时，是根据位置匹配的，可以设置默认值，这种语法在Shell脚本语言中也存在；

void main(List<String> args) {
  sayHello1("yanzi", 33, 45.6);
  sayHello1("yanzi", 22);
  sayHello1("yanzi");
}

void sayHello1(String name, [int age = 100, double height = 123.5]) {
  print(name);
  print(age);
  print(height);
}

命名可选参数

• 命令可选参数 用 {}，可以设置默认值，在进行函数调用时，命令可选参数必须写参数名，且支持不用传所有的命令可选参数；

void main(List<String> args) {
  sayHello3("yanzi");
  sayHello3("liyanyan", age: 31, height: 175);
  sayHello3("wangwu", height: 172);
  sayHello3("zhuliu", age: 33);
  sayHello3("nima", height: 144, age: 55); 
}

//命名可选参数 {int age,double height }
void sayHello3(String name, {int age = 32, double height = 56.9}) {
  print(name);
  print(age);
  print(height);
}

箭头函数

• 箭头函数：函数体只有一行代码，可省略函数体的大括号；

void main(List<String> args) {
  test1();
  test2();
}

void test1() {
  print("test1");
}

//可写成箭头函数的形式 加箭头，去除大括号
void test2() => print("test2");

匿名函数

• 没有函数名称的函数，称之为匿名函数；
• Function类型的变量 指向匿名函数；
• 匿名函数作为函数参数；
• 匿名函数的格式：(参数列表) { 函数实现体 }

import 'dart:ffi';

void main(List<String> args) {
  printInfo("yanzi", 22);

  test1(() {
    print("无参 无返回值");
  });

  test2(10.2, 23.6, (double a, double b) {
    print(a);
    print(b);
  });

  test3(100, 200, (a, b) {
    return a + b;
  });

  test4("yanzi", "sf", (String str1, String str2) {
    return str1 + str2;
  });

  test5(1000, 2000, (m, n) {
    return m + n;
  });

  test5(500, 600, (m, n) => m + n);

  test4("aaa", "bbb", (str1, str2) => str1 + str2);
}

//匿名函数 用一个变量来指向此匿名函数
//通过变量来调用匿名函数
Function printInfo = (String name, int age) {
  print(name);
  print(age);
};

//匿名函数作为参数
//无参 无返回值的 匿名函数
void test1(Function func) {
  func();
}

//有参 无返回值的 匿名函数
void test2(double num1, double num2, Function(double a, double b) func) {
  func(num1, num2);
  print("test2调用了");
}

//有参 有返回值的 匿名函数
void test3(int a, int b, Function(int a, int b) func) {
  var result = func(a, b);
  print(result);
}

//有参 有返回值的 匿名函数
void test4(String str1, String str2, Function(String str1, String str2) func) {
  var result = func(str1, str2);
  print(result);
}

void test5(int a, int b, int func(int m, int n)) {
  var result = func(a, b);
  print(result);
}

立即执行函数

• 立即执行函数：匿名函数直接调用执行；

void main(List<String> args) {
  //立即执行函数 匿名函数直接调用执行
  () {
    print("立即执行函数");
  }();
}

闭包表达式

• 闭包的本质就是函数实现体；

Function printInfo = (String name, int age) {
  print(name);
  print(age);
};

• ( 参数 ){ 实现体 }就是一个闭包表达式，也就是闭包，也就是函数实现体；
• 变量printInfo，其值就是一个闭包表达式，函数实现体；

自定义函数类型

• 使用typedef关键字，可以自定义函数类型；

void main(List<String> args) {

  test3((num1, num2) => num1 + num2);

  test4((num1, num2) => num1 * num2);
}

//定义函数类型
typedef CalFunc = int Function(int num1, int num2);

void test3(int foo(int num1, int num2)) {
  var result = foo(20, 30);
  print(result);
}

void test4(CalFunc cal) {
  print(cal(100, 200));
}

函数作为返回值

void main(List<String> args) {
  var func = test();
  var sum = func(100, 200);
  print(sum);
}

typedef Sum = int Function(int a, int b);

//返回值是一个函数
Sum test() {
  return (int m, int n) {
    return m + n;
  };
}

运算符

赋值运算符

• ??=
  • 当变量有值时，那么??=不执行，不执行赋值操作，变量依然保持原来的旧值；
  • 当变量值为null时，那么将新值 赋值给这个变量；
• ??
  • ??前面的变量有值时，那么就使用??前面变量的数据；
  • ??前面的变量值为null时，那么就使用??后面的数据；
• 案例代码如下：

main(List<String> args) {
  //??=
  //当原来的变量有值时，那么??=不执行
  //当原来的变量为null，那么将值赋值给这个变量
  var name1 = "liyanyan";
  name1 ??= "shit";
  print(name1); //liyanyan

  var age = null;
  age ??= 100;
  print(age); //100

  //??
  //??前面的数据有值，那么就使用??前面的数据
  //??前面的数据为null，那么就使用??后面的数据
  var name2 = "SF";
  var temp2 = name2 ?? "SFFF";
  print(temp2); //SF

  var name3 = null;
  var temp3 = name2 ?? "SFFF";
  print(temp3); //SFFF
}

级联运算符

• .. 两个点；
• 在自定义类中的使用级联运算符；
  • 调用方法时，省略实例对象去调用，且方法实现链式调用；

main(List<String> args) {
  var p = Person();
  p.name = "SF";
  p.run();
  p.eat();

  //..级联运算符
  var p1 = Person()
    ..name = "SF"
    ..eat()
    ..run();
}

class Person {
  String name;

  void run() {
    print("run");
  }

  void eat() {
    print("eat");
  }
}

• 在List数组中使用级联运算符；

void main(List<String> args) {
  List<int> nums = new List()
    ..add(100)
    ..add(200)
    ..add(300)
    ..removeLast();
  print(nums); //[100, 200]
}

• 在Map字典中使用级联运算符；

void main(List<String> args) {
  Map<String, dynamic> datas = new Map()
    ..putIfAbsent("name", () => "yanzi")
    ..putIfAbsent("age", () => 20)
    ..addAll({"weight": 120, "height": 175})
    ..remove("weight");

  print(datas); //{name: yanzi, age: 20, height: 175}
}

拼接运算符

• ... 三个点 用来拼接集合，例如List，Map等等；

void main(List<String> args) {
  List<String> list1 = ["a", "b", "c"];
  List<String> list2 = ["d", "e", "f", ...list1];
  List<String> list3 = [...list1, "d", "e", "f"];

  print(list2); //[d, e, f, a, b, c]
  print(list3); //[a, b, c, d, e, f]

  var map1 = {'a': 'a', 'b': 'b'};
  var map2 = {...map1, 'c': 'c', 'd': 'd'};
  var map3 = { 'c': 'c', 'd': 'd',...map1};
  print(map2); //{a: a, b: b, c: c, d: d}
  print(map3); //{c: c, d: d, a: a, b: b}
}

枚举

• 使用enum关键字 定义枚举；
• 案例代码：

enum Colors { red, green, blue }

main(List<String> args) {
  final color = Colors.red;

  switch (color) {
    case Colors.red:
      print("红色");
      break;
    case Colors.green:
      print("灰色");
      break;
    case Colors.blue:
      print("蓝色");
      break;
    default:
  }
  //获取枚举的所有值
  print(Colors.values);
  //获取枚举值的index
  print(Colors.red.index);
}