04. Dart - Functions

个人学习用
不严谨
学习的话请看别的博客

可选参数

void main(){
  /**
   * 可选参数分为:
   *    可选命名参数
   *    可选位置参数
   *
   * 函数也是对象并且类型为Function,这意味着函数可以被赋值给变量或者其他函数的参数
   *
   */

  List list = [1,2,3];

  bool isNoNull(int i){
    return list[i] != null;
  }


  print(isNoNull(2));

  //简化表达式

  bool isNoNullSimple(int i) => list[i] !=null;


  print(isNoNullSimple(1));

}

可选命名参数

void main() {
  /**
   * 当调用函数的时候可以使用 参数名: 参数值 的形式来指定命名参数
   * 可以使用 @required 注解来标识一个命名参数是必须的参数

   */

  /**
   * 定义 - 可选命名参数
   * 大括号包裹
   */
  void showText({String s, bool b}) {
    if (b) {
      print(s);
    }
  }

  /**
   * 调用 - 可选命名参数
   * 键值对形式,键是定义时候的参数名称
   */

  showText(s: "123", b: true);
  showText(s: "123", b: false);
}

可选位置参数

void main() {
  /**
   * 可选位置参数: 使用[] 将一系列参数包裹起来,作为位置参数
   * 可选位置参数可以传入,也可以不传入值
   *
   */

  //定义时候 利用[] 来包裹可选位置参数
  String showText(String name, String from, [int age]) {
    String str = '我的名字是$name,我来自$from';
    if (age != null) {
      str = '我的名字是$name,我来自$from,我今年$age岁了';
    }
    return str;
  }

  //没调用可选位置参数的
  print(showText("张三", "山东"));
  //调用可选位置参数的
  print(showText("张三", "山东", 23));
}

默认参数值

void main() {
  /**
   * 可以用 = 为 可选参数(可选命名参数{} 可选位置参数[]) 设置默认值
   *
   */

  //可选命名参数{} 的默认值
  void showText({String name = "张三", int number = 13885678340}) {
    print('$name 我的号码是:$number');
  }

  //调用
  showText(); //因为有了默认参数,所以不传参数都可以//张三 我的号码是:13885678340
  showText(name: "李四"); //李四 我的号码是:13885678340
  showText(number: 24); //张三 我的号码是:24
  showText(name: "李四", number: 24); //李四 我的号码是:24
  print('===============================================');



  //可选位置参数[] 的默认值
  void shotLine(String name, [int age = 1999]) {
    print('$name$age');
  }

  shotLine("王五"); //王五1999
  shotLine("王五", 13); //王五13
  print('===============================================');



  //List和Map同样可以设置默认参数
  void listAndMap(
      {List<int> list = const [1, 2, 3, 4, 5],
      Map<String, int> map = const {'a': 1, 'b': 2}}) {
    print(list);
    print(map);
  }

  void listAndMap1(
      [List<int> list = const [1, 2, 3, 4, 5],
      Map<String, int> map = const {'a': 1, 'b': 2}]) {
    print(list);
    print(map);
  }

  listAndMap();  //使用默认初始化值,就不用传值了
  listAndMap1(); //使用默认初始化值,就不用传值了
}

函数作为一级对象

void main() {
  /**
   *函数作为参数传递
   */

  void printInt(int i) {
    print(i);
  }

  var list = [1, 2, 3, 4, 5];
  list.forEach(printInt);

  /**
   * 函数赋值给一个变量
   */

//  var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
//  assert(loudify('hello') == '!!! HELLO !!!');

  var v = (i) => print(i);
  v(123234234); //123234234
}

匿名函数

void main() {
  /**
   * 匿名函数: Lambada表达式活 Closure闭包
   * 可以将匿名方法 赋值给一个 变量,然后使用它
   */

  var list = [1, 2, 3, 4, 5];
  list.forEach((item) => print('${list.indexOf(item)}:$item'));
}

方法作用域

bool a = true;

void main() {
  /**
   * 方法作用域
   * 变量的作用域在写代码的时候就确定了,大括号内定义的变量只能在大括号内访问
   */

  bool b = true;

  void show() {
    bool c = true;

    void show1() {
      bool d = true;

      assert(a);
      assert(b);
      assert(c);
      assert(d);
    }
  }
}

词法闭包

void main() {
  /**
   * 词法闭包
   * 闭包即一个函数对象,及时函数对象的调动在他原始的作用域之外,依然能够访问他在他词法作用域内的变量
   */

  //返回值为一个函数
  Function makeAdder(num number) {
    var  v = (num n) => number + n;

    return v;
  }

  var makeAdder2 = makeAdder(2);
  var makeAdder3 = makeAdder(3);

  print(makeAdder2(2) == 4);
  print(makeAdder3(4) == 7);
}

测试函数是否相等

//顶层函数
void funTop() {}

class funStatic {
  static void funSta() {} //静态函数
  void baz() {} //实例方法
}

void main() {
  /**
   * 测试函数是否相等
   */
  var x;

  //比较顶层函数是否相等
  x = funTop;
  print(x == funTop); //true

  //比较静态函数是否相等
  x = funStatic.funSta;
  print(x == funStatic.funSta); //true

  //比较实例方法是否相等
  var a = funStatic();
  var b = funStatic();
  var c = b;

  x = b.baz;

  print(a.baz == b.baz); //false 因为这是创建了两个对象,里面的方法引用地址不一样
  print(c.baz == b.baz); //true  c和b 引用的是一个对象,所以里面的方法也是一个
}

返回值

void main() {
  /**
   * 返回值 return
   *
   */

  int add(int x, int y) {
    return x + y;
  }
}