四、函数

一、默认赋值

• 默认赋值：预先给函数的参数一个值

  <script>
       function go(type="get"){
           console.log(type)
       }
       go()
       go("post")
   </script>

  二、回调函数

 <script>
        /* 回调函数:就是将函数作为参数传递给另外一个函数
        作用:可以获取函数内部的值 */
        function http(callback){
            var data = {"name":"cheng",age:18};
            callback(data);
        }    
        function hanleData(res){
            console.log(res)
        }
        http(hanleData);
    </script>

三、箭头函数

• 参数只有一个可以不用小括号，输出语句只有一行可以不用大括号

  <script>
        var a = function(x){
            console.log(x)
        }    
        var a = x=>{
            console.log(x)
        }
        var a = (x,y)=>{
            console.log(x)
        }
    </script>

 <script>
        function show(x){
            return x;
        }
        /*  */
        var go=x=>x;
        var test = z=>console.log(z);
        var getInfo=(x,y)=>{
            console.log(x);
            console.log(x+y)
        }
        console.log(go(10))
        test(20)
    </script>

箭头函数的好处

解决函数内部this关键字的指向问题
当函数直接调用时，this指向window

 <div id="test">hello world</div>
    <script>
        /* */   
        var test = document.getElementById("test");
        test.onclick = function(){
            setTimeout = (function(){
                console.log(this)
            },300) 
        }
        // test.onclick = function(){
        //     console.log(this)
        //     go()
        // }
        // function go(){
        //     console.log(this)
        // }
        // test.onclick = go;
    </script>

四、构造函数

<script>
        /* 不要使用 */
        var go = new Function('a','b','alert(a*b)')
        go(4,5)   
</script>

五、返回值 retrun

• 返回值就是函数的执行结果，js中函数可以没有返回值

• 使用return 语句后，返回值后面的语句不会执行

  <script>
  /*  */
  function show(){
     return "hello world"
     console.log(3)
  }   
  console.log(show()) 
  function og(x){
     console.log(x)
  }
  </script>

  六、函数的参数

• 函数传不定参

   函数内部有个arguments对象，接收函数传递过来的参数<br />       是一个类数组对象

  <script>
        /* 函数传不定参 
        函数内部有个arguments对象，接收函数传递过来的参数
        是一个类数组对象*/
        function go(a,b,c){
            console.log(a)
            console.log(a+b)
            console.log(a+b+c)
        }
        go(10,10,30,50)
    </script>
  

  七、重载

• 重载：根据传入参数不一样，动态决定调用哪一种方法

• 原因：js不支持重载，重复声明，覆盖掉了

   可以使用arguments对象模拟重载
  

  <script>
        /* 
         */    
        function go(a,b){
            console.log(a+b)
        }
        function go(a){
            console.log(a)
        }
        function show(){
            if(arguments.length == 2){
                console.log(arguments[0]+arguments[1])
            }else if(arguments.length == 1){
                console.log(arguments[0])
            }
        }
        show(20)
        show(20,30)
    </script>
  

  八、改变this

• Javascript的函数也是对象,它有三种方法可以改变函数内部this关键字的指向。

1.bind
2.call
3.apply()

8-1、bind

bind()改变了函数执行的上文环境，不会马上被执行

<script>
        /* 改变函数内部的this关键字的指向 */
        var name = "cheng";
        var obj = {
            name :"li"
        }
        /* bind()改变了函数执行的上文环境 */  
        var test = function(){
            console.log(this.name)
        }.bind(obj);
        test() 
    </script>

8-2、call

• 马上执行，一个一个的传参

  call(thisObj,params)
  //第一个参数指向函数内部的this,之后的参数是需要被传入函数的参数
  

• 功能

1.改变函数内部this关键字的指向
2.可以让对象拥有一个它没有的方法

 <script>
        var li = "li";
        var obj = {
            name:"cheng"
        }  
        var test = function(){
            console.log(this.name)
        } 
        test.call(obj) 
    </script>

8-3、apply()

• 马上执行，传进去是数组

  //apply(thisObj,[params])
   var person = {
           name : 'cheng',
           sayName(label){
               console.log(label+":"+this.name);
           }
       }
       var jiang = {
           name:"jiang"
       }
       person.sayName.call(jiang,["jiang"])