javascript基础:第五章：函数(方法)

第五章：函数(方法)

1.什么是函数（方法）?

函数，方法：
完成某个独立个功能代码来解决某个问题，任务。编写好了后，可以反复的调用。
-----------------------
方法是对象提供的行为，方法。建立起面向过程的编程思想。 函数式编程。
如何来定义方法？
function 函数名(参数列表){
   函数体
   return 返回值
}

2.自定义函数

两个身份：
1.函数的作者
2.函数的调用者
分成4个步骤来
定义函数，站在作者的角度
1.问自己要做什么事情? 就是找一个名字，能够很好的描述这个事情，函数名，一般情况是动名词,
    doSomething 命名首字小写，多个英文单词首字大写，驼峰命名方式
2.完成这个事情需要已知条件么？几个条件？每个条件的代表什么含义？
    已知条件就是参数
3.任务完成后，需要将结果告诉给调用者么，返回的结果，就是返回值
4. 实现函数代码
===================

<script type="text/javascript">
    /**
			 * 根据三角形的三边求面积
			 *返回面积，-1的话表示参数错或不构成三角形
			 */
    function getTriangleArea(a,b,c){
        let area=-1;
        if(a<=0||b<=0||c<=0){
            return -1;
        }
        if(a+b>c&&a+c>b&&b+c>a){
            //构成三角形
            let d=(a+b+c)/2;
            area=Math.sqrt( d*(d-a)*(d-b)*(d-c));//求面积sqrt，开根号
        }
        return area;
    }

    //测试下
    var a=3,b=4,x=5;
    var area=getTriangleArea(a,b,x);//调用函数，获取返回值
    console.log("面积是：",area);			
</script>

3.参数传递过程

4.传值和传引用

传值：传递的是值类型，如number,boolean
传引用：传递的是地址

	<script type="text/javascript">
        //交换两个数
        function swap(a,b){
            let temp=a;
            a=b;
            b=temp;
            console.log("函数内部: a=",a,'b=',b);	
        }			
        function swap2(arr){
            let temp=arr[0];
            arr[0]=arr[1]
            arr[1]=temp;
            console.log('swap2内部:',arr[0],arr[1]);
        }
        /
        //测试下
        let a=10,b=20;
        swap(a,b);
        console.log("a=",a,'b=',b);
        let arr=[100,200];
        swap2(arr);
        console.log(arr[0],arr[1]);						
</script>

5.默认值参数(ES6)

函数的参数可以设置默认值，当调用时不指定参数的，那么就使用默认值，注意，默认值参数要连续，放在列表的右边。
<script type="text/javascript">		
    function add(a,b,c,d){
        console.log("d-->",d);
        return a+b+c+d;
    }			
    let ret=add(1,2,3,4);
    console.log(ret);
    //使用默认值参数
    function add2(a,b=10,c=20,d=30){
        return a+b+c+d;
    }
    console.log(add2(5),add2(5,6),add2(5,6,7),add2(5,6,7,8))			
</script>

6.rest参数[ES6]

rest参数形式（...参数名) ,表示任意多个参数。参数就变成了一个数组
<script type="text/javascript">
		
        function add(a,b,...values){
        let sum=a+b;
        //任意多个参数，形式就是数组
        for (let v of values) {
        sum+=v
        }
        return sum;
        }
        //简单的调用
        let sum=add(10,20,40,50);
        console.log(sum);
  </script>

7. 变量的作用域

1. 脚本级变量
    就是在脚本里定义的变量，也称为全局变量，在定义后就可以使用
2. 局部变量
    就是函数内部定义的变量，以及参数的参数。只能在该函数内部使用

<script type="text/javascript">
    //这是一段脚本
    var name="小红";//脚本级，从定义后就可以用
    function fun(){
        console.log(name);
        var x=1000;
        y=2000;//如果没有var,let，这里就相当于是给顶级对象window设置一个属性y了。
    }
    fun();
    console.log("y=",y);//这里就相当于访问window对象的y属性
</script>

7.高阶函数

高阶函数：满足下面两个条件中任意一个
  a.函数的参数是函数  b.函数的返回值是函数
1.函数的参数是函数
   函数可以向变量一样来使用了，传递函数，就可以非常灵活

7.1 函数的参数是函数

<script type="text/javascript">		
    function add(a,b){
        return a+b;
    }
    function minus(a,b){
        return a-b;
    }
    //函数的参数是函数
    function execute(a,b,fn){
        let result=fn(a,b);//调用函数
        console.log("函数执行结果:",result);
    }
    
    execute(10,20,minus);//传递函数名，函数名就是一个引用，指向了入口

    //理解匿名函数，没有函数名的函数
    execute(5,6,function(x,y){
        return x*y;
    });
    execute(5,6,function(x,y){
        return x/y;
    });
</script>

7.2 函数的返回值是函数

<script type="text/javascript">
    //函数的返回值是函数
    //可以将函数内部的局部变量，让外界访问，这就叫闭包
    //如果是闭包，函数结束后，该栈区不收回，这样，局部变量不销毁
    function fun(a,b){
        let x=20;
        //函数的内部定义了函数
        function inner(){
            return x-a-b;
        }
        return inner;//将函数返回
    }
    //调用演示:
    f=fun(5,6);
    console.log("f=",f);
    ret=f();//调用函数
    console.log("ret=",ret);			
</script>