函数

函数定义：函数也是一个对象；函数就是可以重复执行的代码块；函数就是完成特定功能的一段代码。

《1》 用函数求1~100之间的和：

 function getSum(count) {
        var sum=0;
        for (var i=1; i<count;i++){
            sum+=i;
        }
        console.log(sum);

    }
    getSum(100);

《2.1》函数声明方式：

  // 3.1 函数声明式
    function sum(a,b) {
        console.log(a + b);
    }
    sum(20,3);

所输出的就是两个参数值相加。

2.2 函数表达式声明方式：

// 3.2 函数表达式声明方式
    //
    // var sum=function (a,b) {
    //     console.log(a + b);
    // }
    // sum(20,30);

所输出来的值还是相加的。

2.3 arguments对象

 

 function sum(arr) {
    //    1 变量
        var value=0;
    //    2 遍历
        for (var i=0; i<arr.length; i++){
            value+=arr[i];
        }
        console.log(value);
        console.log(arguments);

    }
    sum([10, 20, 30]);

用arguments对象，遍历出它的长度，所要输出的值。

 

《3》函数返回值（return）：

当一个函数被调用，通常会从函数的开始执行到结束。

一般return用于返回结果。

例子1：

 *  4.1请写出一个判断一个数是不是偶数的函数？
     * @param (number)num
     */
    function isEven(num) {
     //    1 验证
       if (typeof num!=='number'){
           alert('参数不正确')
    //     //    返回语句
            return ;
       }
    // //    2判断
      if (num % 2===0){
         return '偶数';
       }else{
          return '奇数';
     }

    }
    var f1=isEven(100);
     console.log(f1);

所输出的结果是偶数。

例子2：

//    请模拟写出一个Math.min（x，y）的函数？
    console.log(Math.min(10,-20,30));
    function getMin() {
        //1 定义变量
        var minValue=arguments[0];//    最小值
        //2 遍历数组
        for (var i=0; i<arguments.length; i++) {
            if (arguments[i] > minValue) {
                minValue = arguments[i];

            }
        }
        // 3返回结果
            return minValue;

    }
     var minValue=getMin(10,20 -30);
    console.log(minValue);

所输出的就是max与min了

《4》 函数直接声明和函数表达式声明的区别：

1 函数声明必须有函数名，而函数表达式的函数名可以省略。

2 js解析器首先会把当前作用域的函数声明提前到整个作用域的最前面。

                                                                                                                              

《5》匿名函数：

没有命名的函数 。

作用：1用在绑定事件的时候；

2 定时器；

 setInterval(function () {
        console.log('每秒爱你1遍！');
    },1000)

 

 

《6》回调函数

1 就是一个通过函数调用的函数；

2 如果你把函数指针（地址）作为参数传递给另个函数，当这个指针被用来调用其他所指向的函数时，我们就说这是回调函数。

3 一般用于递归。

4 案例

//    实现加减乘除函数
    function add(num1,num2) {return num1+num2;}
    function sub(num1,num2) {return num1-num2;}
    function mul(num1,num2) {return num1*num2;}
    function divide(num1,num2) {return num1/num2;}

    //    计算器函数
    function cal(num1,num2,func) {
        return func(num1,num2);
    }

//    使用
//      var result=cal(10,20,add);
//      var result=cal(10,20,sub);
//      var result=cal(10,20,mul);
     var result=cal(10,20,divide);

    console.log(result);

可以很方便的计算出加减乘除的值。

 

《7》变量的作用域：

1 作用域可以到作用范围。

2 全局变量：在任何地方都可以访问到的变量就是全局变量；对应全局作用域。

3 局部变量

注意：不使用var声明的变量是局部变量，不推荐使用。

变量退出作用域之后会销毁，全局变量关闭网页或浏览器才会销毁。

《8》作用域链

1 只有函数可以制造作用域结构，那么只要是代码，就至少有一个作用域。

2 凡是代码中有函数，那么这个函数就可以构成另一个作业域。

3 如果函数中有函数，那么在这个作用域中就可以诞生一个作用域。

案例:

 var color="yellow";
    function getColor() {
        var anotherColor="red";
        function swapColor() {
            var tmpColor=color; //yellow
            color=anotherColor; //red
            anotherColor=tmpColor; //yellow

        }
            swapColor();

    }
    getColor();
    console.log(color);//    red

《9》预解析

1 js解析器执行js代码的时候，分为两个过程：预解析过程和代码执行过程。

2 预解析过程：《1》把变量的声明提升到当前作用域的最前面，只会提升声明，不会提升赋值。

《2》把函数的声明提升到当前作用域的最前面，只会提升声明，不会提升调用。

《3》先提升var，再提升function：

console.log(fn2);
    function fn2() {
        console.log("我是函数")
    }
    var fn2='我是变量';
    console.log(fn2);

4 面试相关：

 var str1='撩课学院';
    fn1();
    function fn1() {
        console.log(str1);//undefined
        var str1='itlike';
    }

    var num1=10;
    fn2();
    function fn2() {
        var num2=20;
        console.log(num1);//undefined
        console.log(num2);//20
        var num1='12345'

    }

    fn3();
    // console.log(num1);//报错
    console.log(num2);// 100
    console.log(num3);//100
    function fn3() {
    var num1=num2=num3=100;
    console.log(num1);//100
    console.log(num2);//100
    console.log(num3);// 100

    }

<1变量提升：定义变量的时候，变量的声明会被提升到作用域的最前面，变量的赋值不会提升。

<2函数提升：js解析器首先会把当前作用域的函数声明提前 到整个作用域的最前面。