Dart中的函数 函数的定义 可选参数 默认参数 命名参数 箭头参数 匿名参数 闭包等

01 方法的定义 变量 方法的作用域

内置方法/函数

print();

自定义方法

自定义方法的基本格式：

返回类型 方法名称 （参数1，参数2......）{

方法体

return 返回值;

}

/内置方法/函数
print("调用系统内置的方法");


//1.自定义int 返回类型的方法(也可以将方法写在main函数外面)
int getNum(){
var myNum=123;
return myNum;
}
//调用自定义方法
var num=getNum();
print(num);//123


//2.自定义String 返回类型的方法(也可以将方法写在main函数外面)
String printUserInfo(){
return "str";
}
print(printUserInfo());//str


//3.自定义list 返回类型的方法(也可以将方法写在main函数外面)
List getList(){
return ["111","222","333"];
}
print(getList());//[111, 222, 333]


//方法的作用域
//演示方法作用域
void aaa(){        //方法1
  
void bbb(){        //方法2
print("aaa");
}
bbb();
}
aaa();//aaa 可以调用得到
// bbb(); 调用不到方法体里面的方法 错误写法

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

//调用方法传参

//1. 定义一个方法 求1到这个数的所有数的和
int sumNum(int n){
var num=0;
for(int i=0;i<=n;i++){
num+=i;
}
return num;
}
//调用方法
var n=sumNum(5);
print(n);//15
var n2=sumNum(100);
print(n2);//5050


//2.定义一个方法然后打印用户信息
String printUserInfo(String username,int age){//行参
return "姓名：$username------年龄：$age"; 
}
//调用方法
print(printUserInfo("张三", 20));//实参  姓名：张三------年龄：20


//3.定义一个带可选参数的方法
String printUserInfo2(String username,[int? age]){//行参
if(age!=null)
{
return "姓名：$username------年龄：$age"; 
}else{
return "姓名：$username------年龄：保密"; 
  
}
}
//调用方法
print(printUserInfo2("张三", 20));//实参  姓名：张三------年龄：20
print(printUserInfo2("张三"));//实参  姓名：张三------年龄：保密


//4.定义一个带默认参数的方法
String printUserInfo3(String username,[String sex="男",int? age]){//行参
if(age!=null)
{
return "姓名：$username------性别：$sex----年龄：$age"; 
}else{
return "姓名：$username------性别：$sex----年龄：保密"; 
  
}
}
//调用方法
print(printUserInfo3("张三","女",30));//实参  姓名：张三------性别：女----年龄：30
print(printUserInfo3("张三"));//实参  姓名：张三------性别：男----年龄：保密


//5.定义一个命名参数的方法
String printUserInfo4(String username,{int? age,String sex="男"}){//行参
if(age!=null)
{
return "姓名：$username------性别：$sex----年龄：$age"; 
}else{
return "姓名：$username------性别：$sex----年龄：保密"; 
  
}
}
//调用方法
print(printUserInfo4("张三",age: 20,sex: "男"));//实参  姓名：张三------性别：男----年龄：20


//6.实现一个把方法当做参数的方法
//方法1
fn1(){
print("fn1");
}
//方法2
fn2(fn){
fn();
}
//调用fn2 这个方法 把fn1这个方法当做参数传入
fn2(fn1);

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

//箭头函数(箭头函数代码只能写一行)
//需求：使用forEach打印下面List里面的数据
List list=["苹果","芒果","西瓜"];

list.forEach((value)=>print(value));//箭头函数

list.forEach((value)=>{

print(value)

});


//需求：修改下面List里面的数据，让数组中大于2的值乘以2
List list1=[1,2,3,4];

//(箭头函数代码只能写一行)
var newList=list1.map((value)=>value>2?value*2:value);

print(newList.toList());//[1, 2, 6, 8]



//需求：1.定义一个方法isEvenNumber来判断一个数是否是偶数
//      2.定义一个方法打印1-n以内的所有偶数
    bool isEvenNumber(int number){

    if(number%2==0){

     return true;

    }else{

    return false;

    }


   }    

  printNum(int n){

    for(var i=1;i<=n;i++){

     if(isEvenNumber(i)){

     print(i);

     }

    }


  }

  printNum(10);

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

//匿名方法
var printNum=(){

print(123);

};

printNum();//123

var printNum2=(int n){

print(n+2);

};

printNum2(12);//14


//自执行方法

((){

print("我是自执行方法");//我是自执行方法

})();

//方法的递归(自己调用自己)
//通过方法的递归 求1-100的和

var sum=0;

fn(int n){

sum+=n;

if(n==0){

return;

}

  fn(n-1);

}

fn(100);
print(sum);//5050

05 闭包

闭包：

  1.全局变量的特点：全局变量常驻内存，全局变量污染全局

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

想实现的功能：

 1.常驻内存

 2.不污染环境

  产生了闭包，闭包可以解决这个问题......

闭包：函数嵌套函数，内部函数会调用外部函数的变量或参数，变量或参数不会被系统回收

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

//全局变量
var a=123;

fn(){

  a++;

  print(a);

}

fn();//124
fn();//125
fn();//126



//局部变量(会被垃圾回收掉)

printInfo(){

var myNum=123;

myNum++;

print(myNum);

}

printInfo();//124
printInfo();//124
printInfo();//124



//闭包
//函数嵌套函数形成闭包，不会被系统回收掉

fn2(){

var a=123;//不会污染全局 常驻内存

return(){

a++;

print(a);

};


}
var b=fn2();

b();//124
b();//125
b();//126