JavaScript学习笔记——函数进阶

1.函数定义方式

函数声明：函数声明会进行提升，所以函数调用可以在页面的任何位置。
函数表达式：表达式的声明会进行提升，但是函数不会进行提升，所以函数调用需要在函数表达式的后面。
注意：在现代浏览器中，不会对if表达式内部的函数声明进行提升，但是老版本的IE浏览器会对if表达式的函数声明提升，所以使用表达式可以避免这个问题。
new function()：函数也是对象，所以可以使用构造函数定义，构造函数的参数就是函数需要传递的参数和执行的语句。
使用new function()定义函数执行速度较慢，不推荐使用。

2.函数的调用方式和对应的this指向

1.直接调用           this：window
2.构造函数调用       this：实例对象
3.对象的方法调用     this该方法所对应的对象
4.事件绑定方法       this指向触发该事件的对象
5.定时器内部方法     this指向window 每多个毫秒就调用一次函数
总结：谁调用方法，this就指向谁

3.apply()，call()，bind()

改变this指向的函数：call()/apply()/bind()
call(thisArg,参数列表)：调用一个函数指定this值并且提供相应的参数，call()方法应用：扩展内置对象，该表对象方法的this指向。
apply(thisArg,参数数组[])：常应用于将数组的内容展开。
apply()使用和call()相似，只是call()方法接受的是若干个参数的列表，apply()方法接受的是一个包含多个参数的数组。
bind()：bind()和call()/apply()的区别在于不会调用函数，返回的是一个新的函数，因此bind()方法常常用于setInterval()和事件的函数。
注意：如果不用改变函数的this指向，那么可以将thisArg设置为null。

// call()的应用 扩展内置对象
var obj = {
     1:30,
     2:60,
     3:89,
     length:3
}
//call(this的指向,参数的列表)
Array.prototype.push.call(obj,60);
console.log(obj);
// apply的应用
var arr = [15,2,56,59];
// Math.max不能直接求数组的大小
//使用apply方法可以改变this的指向，同时可以将数组的内容展开
console.log(Math.max.apply(null,arr));
console.log.apply(console,arr);
// bind的应用
var obj = {
   name:'zs',
   fn:function() {
       setInterval(function(){
       // 过一秒打印name
     console.log(this.name); //注意此时的this不是指向obj而是指向window
}.bind(this),1000) //此时bind中的this指向的是obj，默认是window
     }
}
  obj.fn();

4.函数的其他成员

arguments：伪数组，函数实参的集合
caller：函数的调用者
length：形参的个数
name：函数的名称

5.高阶函数

两种情况：
函数作为参数

Array.prototype.mySort = function(fn) {
    for(var i = 0; i < this.length-1; i++) {
          var isSort = true;
       for(var j = 0; j < this.length-i-1; j++) {
              if(fn(this[j],this[j+1]) > 0) {
                    var temp = this[j];
                    this[j] = this[j+1];
                    this[j+1] = temp;
                   isSort = false;
             }
   }
   if(isSort) {
     break; //如果isSort是true 说明没有执行比较 也就说明数组排序完成
   }
  }
}
var arr = [15,48,89,6,45,23];
arr.mySort(function(a,b) { //函数作为方法的参数
      return a - b;
 });

函数作为返回值

function getRandom() {
// 产生一个随机数 每次打印的都是第一次产生的随机数
        var random = parseInt(Math.random()*10 + 1);
         return function() {
                return random;
            }
}
 var fn = getRandom();
// fn()是调用返回值的函数 执行到return函数就停止了，所以再次打印还是第一次产生的随机数
console.log(fn());
console.log(fn());
console.log(fn());

6.递归

递归：函数自己调用自己，需要有一个结束条件，否则会出现内存溢出的情况。

// 使用递归，求1 + 2 + 3 + …… + n
        function getSum(n) {
            if(n === 1) { //递归结束条件
                return 1;
            }
            return n + getSum(n - 1);
        }
        var sum = getSum(3);
        console.log(sum);
        // 使用递归 解决阶乘问题（本质上和求和问题是一样的）
        function getResult(n) {
            if(n === 1) {
                return 1;
            }
            return n * getResult(n - 1);
        }
        var result = getResult(4);
        console.log(result);
// 斐波那契数列 1 1 2 3 5 8 13 21 34…… 从第三个数开始 值等于前两个数的和
        function fn(n) {
            // 在斐波那契数列中 第n个数的结果
            if(n === 1 || n === 2) {
                return 1;
            }
            return fn(n - 1) + fn(n - 2);
        }
        var result = fn(5);
        console.log(result)

7.拷贝

浅拷贝：一个对象拷贝另一个对象，只能拷贝属性和方法的值，如果对象中含有对象，拷贝的地址，而不是新的对象。
注意：浅拷贝如果更改原来对象的属性和方法，拷贝后对象的属性和方法不会发生改变，但是如果改变对象内部中的对象属性，那么属性也会随之更改。

var obj1 = {
            name: 'zs',
            age: 15,
            sex: '男',
            dog: {
                dogName: '大黄',
                dogAge: 8,
                color: 'yellow'   
            },
            friends:['zs','ls','ww']
};
var obj2 = {};
// 把o1对象复制给o2
        function copy(o1,o2) {
            for(var key in o1) {
                o2[key] = o1[key];
            }
        }
        copy(obj1,obj2);
        // 修改obj1的成员
        obj1.name = 'ls';
        obj1.dog.dogAge = 5; //此时obj2的dogAge值也会被改变
        console.dir(obj1);
        console.dir(obj2);

深拷贝：拷贝的同时，判断此时的内容是否为对象，如果是对象，那么使用递归，遍历对象中的内容。

var obj3 = {
            name: 'zs',
            age: 15,
            sex: '男',
            dog: {
                dogName: '大黄',
                dogAge: 8,
                color: 'yellow'   
            },
            friends:['zs','ls','ww']
        };
        var obj4 = {};
        function deepCopy(o3,o4) {
            for(var key in o3) {
                if(o3[key] instanceof Object) {
// 如果此时o1中的内容是对象或者数组，那么新建一个o2索引的空对象
//将o1对象中内容遍历到o2中，使用递归，再次遍历对象中的内容
                    o4[key] = {};
                    deepCopy(o3[key], o4[key]);
                } else if(o3[key] instanceof Array) {
                    o4[key] = [];
                    deepCopy(o3[key], o4[key])
                } else {
                    o4[key] = o3[key]
                }
            }
        }
        deepCopy(obj3,obj4);
        console.log('深拷贝');