JavaScript基础 函数

JavaScript基础

• 1 函数的定义式

function demo (){
   console.log('demo');
 }

• 2 函数表达式

var feng = function(){
   console.log('feng');
  }

• 3 简单类型赋值的是值（互相不影响）

 var a = 20;
 //变量a为变量 b赋值
 var b = a;
 //修改b
 //简单类型赋值的是值，
  b = 30;
 console.log(a,b);  //20  30

• 4 引用类型赋值的是地址

 var a = function(){
    console.log('只是一个函数');
  }
  var b = a;
  //引用数据类型数可以添加属性，通过点语法添加
   //a和b指向同一个数据，通过b修改数据，a也会受到影响
   b.color = 'red'
   console.log('a',a.color); //a  red 
   console.log(a,b); // f()  f()  函数

• 5 函数的声明提升

 function feng (num){
   console.log(111,num);
    //定义变量(只声明提升  不赋值)
     var num = 20;
     console.log(333,num);
    //声明函数(执行覆盖操作 最后是函数)
    function num(){
    console.log(111);
  }
 console.log(222,num);
}
feng(10)

• 步骤
  1.传入一个 10
  2.寻找 num 变量 （只声明提升，不赋值）
  3.找到函数 赋值提升 整体到前面
  4.然后 第一个 输出为函数
  5.num = 20 (函数那个 提升了就没有了 )
  6. 333 222 输出为 20

• 6 递归函数

        function demo (num){
            if(num <=1){
                return 1
            }
            return num + demo(num-1)
        }
        var result = demo(5)
        console.log(result);

输出为 5 + 4 + 3 +2 + 1 = 15

• 7 //波非那切数列(num 表示项数)

        function bo(num){
            //临界条件
            if(num === 1 || num === 2){
                // 前2项都是1
                return 1;
            }
            //当前项等于 前 2项之和
            return bo(num-1) + bo(num-2)
        }
        测试
        console.log(bo(1));
        console.log(bo(2));
        console.log(bo(3));
        console.log(bo(4));
        console.log(bo(5));
        console.log(bo(6));
        console.log(bo(7));

输出： 1    1    2    3    5    8   13

• 8 作用域

        //函数可以锁住变量
        //按照作用域链一层一层向上查找
        var num = 1;
        function fn1(){
            function fn2(){
                //函数在 执行的一瞬间会产生ActiveObject（活动对象）
                //把形参 放在 AO  里 赋值为 undefined
                //如果 fn3()中传入 num 
                //输出 undefined
                function fn3(){
                    console.log(num);
                }   
                fn3();
            }
            fn2();
        }
        fn1();

• 9 闭包
• 将内部的函数暴露在外部，就可以访问内部的数据

            function demo(){
                var num = 10;
                function inner(){
                    console.log(num);
                }
                return inner
            }
            var outer = demo();
            console.log(outer);  //输出函数
            // 通过 outer访问内部的数据
            outer() //输出 10

闭包的缺点：无法回收

• 10 冲突

            function init(x,y){
                // 返回一个 闭包
                return function(y){
                    //x 使用的是 外部的 y 使用的是内部的
                    console.log(x + y);
                }
            }
            //注意：闭包函数本身也是一个作用域
            //与外界产生冲突是 会优先使用内部的数据
            // 里面的 y 代替了 传递的 4 
            //所以  2 + 上add 传入的 5  6  7  =  7  8  9 
            var add = init(2,4)
            add(5)
            add(6)
            add(7)

• 11 立即执行函数
  1.在函数定义式中，直接在函数后面添加() 有语法错误，
  2.要将函数转成表达式 在function 前 添加一个 + - ~ !
  3.或者用 （） 把整个函数包起来

        +function demo(){
            console.log('demo');
        }();
        console.log(demo); //它是表达式了 不能访问demo了
         
        函数定义式
        var demo3 = function demo3(){
            console.log('demo3');
            return 100;
        }()
        console.log(demo3);//  得到的是函数的结果


        -function demo(){
            console.log('demo');
        }();
        ~function demo(){
            console.log('demo');
        }();

        !function demo(){
            console.log('demo');
        }();

        (function demo(){
            console.log('demo');
        })()

• IIFE(立即执行函数)的返回值 可以参与运算

        var demo = function(){
            return 1000
        }()+200
        console.log(demo); // 输出  1200