函数是一等公民

函数类型变量

//箭头函数 = lamda
bool getIsEmpty2(String j) => j == null;

函数参数

• 1、可选参数 []

• 2、命名参数 {参数1,参数2} 内部定义名字 = 具名

parse(String source, {int? radix})

• 3、必须参数 required

• 4、函数参数

• 5、可以省略

扩展函数

通过 Xxx on String 的方式; 而 ktolin 通过 String. 的方式

void main(List<String> args) {

    var a = 'a'.parseInt();
    print(a);
}

extension NumberParsing on String {
  int parseInt() {
    return int.parse(this,radix: 16);
  }
}

lamda 表达式 函数作用域和闭包

闭包： 内层函数使用外层函数的变量

函数作用域：函数 {} 作用域内是其作用域

void main(List<String> args) {
  //匿名函数、lamda 表达式 或者 闭包
  //写法1
  var lamda = () {
    print(20);
    return 1;
  };
  print(lamda());

  //写法2 只能表示1行，写多行使用方法1
  var lamda2 = () => 2;
  print(lamda2());
  print(lamda2);

  var lamda3 = (d) => 2 + d;
  print(lamda3(5));
  print(lamda3);

  var lamda4 = (int d) => 2 + d;
  print(lamda4(5));
  print(lamda4);

  var list = [1, 2, 3, null];

  // = 第一种写法
  list.forEach((item) {
    print(item);
  });

  //词法作用域 闭包
  //例子1
  void main() {
    var insideMain = true;
    void myFunction() {
      var insideFunction = true;
      void nestedFunction() {
        var insideNestedFunctipn = true;
        assert(insideMain);
      }
    }
  }

  //例子2
  Function calc(int a) {
    return (int b) => a + b;
  }

  print(calc(10)(10));

  //没有返回值就是 null
  foo() {}
  print(foo());
}

异步函数

//泛型
//dart 的泛型类型是固化的， 这意味着即便在运行时也会保持
//java 是泛型擦除，在运行时泛型会具体化；

//协程 Future

Future<String> lookUpVersion() async {
  return Future.value("112");
}

Future<void> checkVersion() async {
  // Future.delayed(Duration.secondsPerDay);
  var version = await lookUpVersion();
  print(version);
}

例子

void printString(String v) {
  print("v = $v");
}

void main(List<String> args) {
  //一等公民 函数
  var vF = printString;

  vF("aa");
  var a = "aaa";
  var b = getIsEmpty2(a);
  var c = getIsEmpty(a);
  print("b=$b $c");

  //参数
  //1、可选参数+命名参数 {参数1,参数2} 内部定义命名 = 具名
  // parse(String source, {int? radix})
  var f = int.parse("FF", radix: 16);
  print("f = $f");
  //2、必要参数 required
  foo(a: 10, b: 29);
  //可选且有名字，
  foo(a: 10);
  foo2();
  //不可选，没有名字
  foo3(10, 20);
  // a 是必须的， b 是可选
}

//函数
bool getIsEmpty(String j) {
  return j == null;
}

//箭头函数 = lamda
bool getIsEmpty2(String j) => j == null;

void foo({required int a, int? b}) {
  print("foo a $a; b=$b");
}

void foo2({int? a, int? b}) {
  print("foo2 a $a; b=$b");
}

void foo3(int a, int b) {
  print("foo3 a $a; b=$b");
}

void foo4(int a, [int b]) {
  print("foo4 a $a; b=$b");
}