Dart-函数

方法的定义以及变量、方法的作用域

内置方法/函数：

print();

自定义方法：

自定义方法的基本格式：

返回类型  方法名称（参数1，参数2,...）{
    方法体
    return 返回值;
}

void printInfo(){
  print('我是一个自定义方法');
}

int getNum(){
  var myNum=123;
  return myNum;
}

String printUserInfo(){
  return 'this is str';
}

List getList(){
  return ['111','2222','333'];
}

void main(){
    print('调用系统内置的方法');
    printInfo();
    var n = getNum();
    print(n);
    
    print(printUserInfo());
    print(getList());

// 演示方法的作用域
void xxx(){
    aaa(){
        print(getList());
        print('aaa');
    }
    aaa();
}

aaa();  // 错误写法 
xxx();  // 调用方法
}

方法传参、默认参数、可选参数、命名参数、方法作为参数

调用方法传参

1、定义一个求和的方法

int sumNum(int n){
    var sum = 0;
    for(var i=1;i<=n;i++){
        sum += i;
    }
    return sum;
} 

var n1 = sumNum(5);
print(n1);
var n2 = sumNum(100);
print(n2);

2、定义一个方法然后打印用户信息

String printUserInfo(String username,int age){  // 形参
    return "姓名:$username---年龄:$age";
}

print(printUserInfo('张三',20)); // 实参

3、定义一个带可选参数的方法

String printUserInfo(String username,[int age]){  // 形参
    if(age != null){
        return "姓名:$username---年龄:$age";
    }
    return "姓名:$username---年龄保密";
}

print(printUserInfo('张三',21)); // 实参
print(printUserInfo('张三'));

4、定义一个带默认参数的方法

String printUserInfo(String username,[String sex='男',int age]){  // 形参
    if(age != null){
        return "姓名:$username---性别:$sex--年龄:$age";
    }
    return "姓名:$username---性别:$sex--年龄保密";
}
print(printUserInfo('张三')); // 姓名:张三---性别:男--年龄保密
print(printUserInfo('小李','女')); // 姓名:小李---性别:女--年龄保密
print(printUserInfo('小李','女',30)); // 姓名:小李---性别:女--年龄30

5、定义一个命名参数的方法

String printUserInfo(String username,{int age,String sex='男'}){  // 形参
    if(age != null){
        return "姓名:$username---性别:$sex--年龄:$age";
    }
    return "姓名:$username---性别:$sex--年龄保密";
}
print(printUserInfo('张三',age:20,sex:'未知'));

6、实现一个把方法当做参数的方法

var fn = (){
    print('我是一个匿名方法');
};      
fn();

// 方法fn1
fn1(){
    print('fn1');
}

// 方法fn2
fn2(fnName){
    fnName();
}

// 匿名方法fn3
var fn3 = () {
    print("fn3");
};

// 调用fn2这个方法，把fn1这个方法当做参数传入
fn2(fn1);
fn2(fn3);

箭头函数、函数的相互调用

使用forEach打印List里面的数据

List list = ['苹果','香蕉','西瓜'];
list.forEach((value){
    print(value);
});

// 箭头函数（箭头函数后面只能执行单行代码，不能执行多行代码）
list.forEach((value)=>print(value));

list.forEach((value)=>{
    print(value) // 注意不能加分号
});

修改下面List里面的数据，让数组中大于2的值乘以2

List list = [4,1,2,3,4];
var newList = list.map((value){
    if(value > 2){
        return value * 2;
    }
    return value;
});
print(newList.toList());

var newList = list.map((value)=>value > 2 ? value*2 : value);
print(newList.toList());

定义一个方法isEvenNumber来判断一个数是否是偶数

bool isEvenNumber(int n){
    if(n%2 == 0){
        return true;
    }
    return false;
}

定义一个方法打印1-n以内的所有偶数

printNum(int n){
    for(var i=1;i<=n;i++){
        if(isEvenNumber(i)){
            print(i);
        }
    }
}
printNum(10);

匿名方法、自执行方法、方法的递归

匿名方法

var printNum = (){
    print(123);
};
printNum();

var printNum = (int n){
    print(n+2);
};
printNum(12);

自执行方法

((int n){
  print(n);
  print('我是自执行方法');
})(12);

方法的递归

var sum = 1;			
fn(n){
    sum*=n;
    if(n==1){
        return;
    }         
    fn(n-1);
}
fn(5);      
print(sum);

通过递归 求1-100的和

var sum=0;
fn(int n){
    sum+=n;
    if(n==0) return;
    fn(n-1);
}
fn(100);
print(sum);

闭包

1.全局变量特点： 全局变量常驻内存、全局变量污染全局
2.局部变量的特点： 不常驻内存会被垃圾机制回收、不会污染全局

想实现的功能：

1.常驻内存
2.不污染全局
由此产生了闭包，闭包可以解决这个问题.....
闭包: 函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)
闭包的写法： 函数嵌套函数，并return 里面的函数，这样就形成了闭包。

// 全局变量
var a = 123;

void main(){

    print(a);
    
    fn(){
        a++;
        print(a);
    }
    fn(); // 124
    fn(); // 125
    fn(); // 126

// 局部变量
    printInfo(){
        var myNum = 123;
        myNum++;
        print(myNum);
    }
    printInfo(); // 124
    printInfo(); // 124
    printInfo(); // 124

// 闭包
    fn(){
        var a = 123;  /*不会污染全局 常驻内存*/
        return(){			
            a++;			
            print(a);
        };        
    }     
    var b=fn(); // 变量a常驻内存，fn中return的方法赋值给了b，调用b()的时候相当于执行fn中return后面的函数体
    b(); // 124
    b(); // 125
    b(); // 126
}