web前端基础篇

柔情只为你懂 2022-05-27 01:17 263阅读 0赞

# JS #

--------------------

*  数据类型：
    
     *  Number
        
        JavaScript不区分整数和浮点数，统一用Number表示。
     *  字符串
        
        字符串是以单引号”或双引号”“括起来的任意文本。
     *  布尔值
        
        布尔值和布尔代数的表示完全一致，一个布尔值只有true、false两种值。
     *  比较运算符
        
        JavaScript在设计时，有两种比较运算符：  
        第一种是==比较，它会自动转换数据类型再比较，很多时候，会得到非常诡异的结果；  
        第二种是===比较，它不会自动转换数据类型，如果数据类型不一致，返回false，如果一致，再比较。  
        由于JavaScript这个设计缺陷，不要使用==比较，始终坚持使用===比较。  
        另一个例外是NaN这个特殊的Number与所有其他值都不相等，包括它自己：
        
            NaN === NaN; // false
        
        唯一能判断NaN的方法是通过isNaN()函数：
        
            isNaN(NaN); // true
     *  null和undefined
        
        null表示一个“空”的值，它和0以及空字符串”不同，0是一个数值，”表示长度为0的字符串，而null表示“空”。  
        undefined，它表示“未定义”。
     *  数组
        
        数组是一组按顺序排列的集合，集合的每个值称为元素。JavaScript的数组可以包括任意数据类型。
     *  对象
        
        JavaScript的对象是一组由键-值组成的无序集合，例如：
        
            var person = {
                name: 'Bob',
                age: 20,
                tags: ['js', 'web', 'mobile'],
                city: 'Beijing',
                hasCar: true,
                zipcode: null
            };
            person.name; // 'Bob'
 *  字符串
    
     *  如果字符串内部既包含’又包含”怎么办？可以用转义字符\\来标识，比如：
        
            'I\'m \"OK\"!';
     *  操作字符串
     *  str.length
     *  toUpperCase
        
        toUpperCase()把一个字符串全部变为大写：
        
            var s = 'Hello';
            s.toUpperCase(); // 返回'HELLO'
     *  toLowerCase
        
        toLowerCase()把一个字符串全部变为小写：
        
            var s = 'Hello';
            var lower = s.toLowerCase(); // 返回'hello'并赋值给变量lower
            lower; // 'hello'
     *  indexOf
        
        indexOf()会搜索指定字符串出现的位置：
        
            var s = 'hello, world';
            s.indexOf('world'); // 返回7
            s.indexOf('World'); // 没有找到指定的子串，返回-1
     *  substring
        
        substring()返回指定索引区间的子串：
        
            var s = 'hello, world'
            s.substring(0, 5); // 从索引0开始到5（不包括5），返回'hello'
            s.substring(7); // 从索引7开始到结束，返回'world'
 *  数组
    
     *  indexOf
    
    与String类似，Array也可以通过indexOf()来搜索一个指定的元素的位置：
    
        var arr = [10, 20, '30', 'xyz'];
        arr.indexOf(10); // 元素10的索引为0
        arr.indexOf(20); // 元素20的索引为1
        arr.indexOf(30); // 元素30没有找到，返回-1
        arr.indexOf('30'); // 元素'30'的索引为2
    
    **注意了，数字30和字符串’30’是不同的元素。**
    
     *  slice
    
    slice()就是对应String的substring()版本，它截取Array的部分元素，然后返回一个新的Array：
    
        var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
        arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']
        arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']
    
    **注意到slice()的起止参数包括开始索引，不包括结束索引。**
    
    如果不给slice()传递任何参数，它就会从头到尾截取所有元素。利用这一点，我们可以很容易地复制一个Array：
    
        var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
        var aCopy = arr.slice();
        aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
        aCopy === arr; // false
    
     *  push和pop
    
    push()向Array的末尾添加若干元素，pop()则把Array的最后一个元素删除掉：
    
        var arr = [1, 2];
        arr.push('A', 'B'); // 返回Array新的长度: 4
        arr; // [1, 2, 'A', 'B']
        arr.pop(); // pop()返回'B'
        arr; // [1, 2, 'A']
        arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
        arr; // []
        arr.pop(); // 空数组继续pop不会报错，而是返回undefined
        arr; // []
    
     *  unshift和shift
    
    如果要往Array的头部添加若干元素，使用unshift()方法，shift()方法则把Array的第一个元素删掉：
    
        var arr = [1, 2];
        arr.unshift('A', 'B'); // 返回Array新的长度: 4
        arr; // ['A', 'B', 1, 2]
        arr.shift(); // 'A'
        arr; // ['B', 1, 2]
        arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
        arr; // []
        arr.shift(); // 空数组继续shift不会报错，而是返回undefined
        arr; // []
    
     *  sort
    
    sort()可以对当前Array进行排序，它会直接修改当前Array的元素位置，直接调用时，按照默认顺序排序：
    
        var arr = ['B', 'C', 'A'];
        arr.sort();
        arr; // ['A', 'B', 'C']
    
    **能否按照我们自己指定的顺序排序呢？完全可以，我们将在后面的函数中讲到。**
    
     *  reverse
    
    reverse()把整个Array的元素给掉个个，也就是反转：
    
        var arr = ['one', 'two', 'three'];
        arr.reverse();
        arr; // ['three', 'two', 'one']
    
     *  splice
    
    splice()方法是修改Array的“万能方法”，它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素：
    
        var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
        // 从索引2开始删除3个元素,然后再添加两个元素:
        arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']
        arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
        // 只删除,不添加:
        arr.splice(2, 2); // ['Google', 'Facebook']
        arr; // ['Microsoft', 'Apple', 'Oracle']
        // 只添加,不删除:
        arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素
        arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
    
     *  concat
    
    concat()方法把当前的Array和另一个Array连接起来，并返回一个新的Array：
    
        var arr = ['A', 'B', 'C'];
        var added = arr.concat([1, 2, 3]);
        added; // ['A', 'B', 'C', 1, 2, 3]
        arr; // ['A', 'B', 'C']
    
    **请注意，concat()方法并没有修改当前Array，而是返回了一个新的Array。**
    
    实际上，concat()方法可以接收任意个元素和Array，并且自动把Array拆开，然后全部添加到新的Array里：
    
        var arr = ['A', 'B', 'C'];
        arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
    
     *  join
    
    join()方法是一个非常实用的方法，它把当前Array的每个元素都用指定的字符串连接起来，然后返回连接后的字符串：
    
        var arr = ['A', 'B', 'C', 1, 2, 3];
        arr.join('-'); // 'A-B-C-1-2-3'
    
    **如果Array的元素不是字符串，将自动转换为字符串后再连接。**
    
     *  多维数组
    
    如果数组的某个元素又是一个Array，则可以形成多维数组，例如：
    
        var arr = [[1, 2, 3], [400, 500, 600], '-'];
    
     *  数组快速去重  
        
        
            console.log([...new Set(arr)])
 *  对象
    
     *  JavaScript的对象是一种无序的集合数据类型，它由若干键值对组成。
        
            var xiaohong = {
              name: '小红',
              'middle-school': 'No.1 Middle School'
            };
     *  xiaohong的属性名middle-school不是一个有效的变量，就需要用”括起来。访问这个属性也无法使用.操作符，必须用\[‘xxx’\]来访问：
        
            xiaohong['middle-school']; // 'No.1 Middle School'
            xiaohong['name']; // '小红'
            xiaohong.name; // '小红'
     *  由于JavaScript的对象是动态类型，你可以自由地给一个对象添加或删除属性：
        
            var xiaoming = {
                name: '小明'
            };
            xiaoming.age; // undefined
            xiaoming.age = 18; // 新增一个age属性
            xiaoming.age; // 18
            delete xiaoming.age; // 删除age属性
            xiaoming.age; // undefined
            delete xiaoming['name']; // 删除name属性
            xiaoming.name; // undefined
            delete xiaoming.school; // 删除一个不存在的school属性也不会报错
     *  如果我们要检测xiaoming是否拥有某一属性，可以用in操作符：
        
            var xiaoming = {
                name: '小明',
                birth: 1990,
                school: 'No.1 Middle School',
                height: 1.70,
                weight: 65,
                score: null
            };
            'name' in xiaoming; // true
            'grade' in xiaoming; // false
    
    不过要小心，如果in判断一个属性存在，这个属性不一定是xiaoming的，它可能是xiaoming继承得到的：
    
        'toString' in xiaoming; // true
    
    因为toString定义在object对象中，而所有对象最终都会在原型链上指向object，所以xiaoming也拥有toString属性。
    
     *  要判断一个属性是否是xiaoming自身拥有的，而不是继承得到的，可以用hasOwnProperty()方法：  
        
        
            var xiaoming = {
                name: '小明'
            };
            xiaoming.hasOwnProperty('name'); // true
            xiaoming.hasOwnProperty('toString'); // false
 *  循环
    
     *  for循环的一个变体是for … in循环，它可以把一个对象的所有属性依次循环出来：  
        
        
            var o = {
              name: 'Jack',
              age: 20,
              city: 'Beijing'
            };
            for (var key in o) {
                if (o.hasOwnProperty(key)) {
                    console.log(key); // 'name', 'age', 'city'
                }
            }
    
    **由于Array也是对象，而它的每个元素的索引被视为对象的属性，因此，for … in循环可以直接循环出Array的索引。**
 *  Map和Set
    
    > JavaScript的默认对象表示方式\{\}可以视为其他语言中的Map或Dictionary的数据结构，即一组键值对。  
    > 但是JavaScript的对象有个小问题，就是键必须是字符串。但实际上Number或者其他数据类型作为键也是非常合理的。  
    > 为了解决这个问题，最新的ES6规范引入了新的数据类型Map。要测试你的浏览器是否支持ES6规范，请执行以下代码，如果浏览器报ReferenceError错误，那么你需要换一个支持ES6的浏览器.
    
     *  Map
    
    Map是一组键值对的结构，具有极快的查找速度。
    
     *  如果用Map实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用JavaScript写一个Map如下：  
        `var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]); m.get('Michael'); // 95`
     *  初始化Map需要一个二维数组，或者直接初始化一个空Map。Map具有以下方法：
        
            var m = new Map(); // 空Map
            m.set('Adam', 67); // 添加新的key-value
            m.set('Bob', 59);
            m.has('Adam'); // 是否存在key 'Adam': true
            m.get('Adam'); // 67
            m.delete('Adam'); // 删除key 'Adam'
            m.get('Adam'); // undefined
        
        **由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉。**
     *  Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。
        
        要创建一个Set，需要提供一个Array作为输入，或者直接创建一个空Set：
        
            var s1 = new Set(); // 空Set
            var s2 = new Set([1, 2, 3]); // 含1, 2, 3
        
        重复元素在Set中自动被过滤：
        
            var s = new Set([1, 2, 3, 3, '3']);
            s; // Set {
                    1, 2, 3, "3"}
        
        **注意数字3和字符串’3’是不同的元素。**
        
        通过add(key)方法可以添加元素到Set中，可以重复添加，但不会有效果：
        
            s.add(4);
            s; // Set {1, 2, 3, 4}
            s.add(4);
            s; // 仍然是 Set {1, 2, 3, 4}
        
        通过delete(key)方法可以删除元素：
        
            var s = new Set([1, 2, 3]);
            s; // Set {
                    1, 2, 3}
            s.delete(3);
            s; // Set {
                    1, 2}
 *  iterable
    
    > 遍历Array可以采用下标循环，遍历Map和Set就无法使用下标。为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。  
    > 具有iterable类型的集合可以通过新的for … of循环来遍历。  
    > for … of循环是ES6引入的新的语法，请测试你的浏览器是否支持。
    
     *  用for … of循环遍历集合，用法如下：
        
            var a = ['A', 'B', 'C'];
            var s = new Set(['A', 'B', 'C']);
            var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
            for (var x of a) { // 遍历Array
                console.log(x);
            }
            for (var x of s) { // 遍历Set
                console.log(x);
            }
            for (var x of m) { // 遍历Map
                console.log(x[0] + '=' + x[1]);
            }
     *  for … of循环和for … in循环有何区别？
    
    for … in循环由于历史遗留问题，它遍历的实际上是对象的属性名称。一个Array数组实际上也是一个对象，它的每个元素的索引被视为一个属性。
    
    当我们手动给Array对象添加了额外的属性后，for … in循环将带来意想不到的意外效果：
    
        var a = ['A', 'B', 'C'];
        a.name = 'Hello';
        for (var x in a) {
            console.log(x); // '0', '1', '2', 'name'
        }
    
    for … in循环将把name包括在内，但Array的length属性却不包括在内。
    
    for … of循环则完全修复了这些问题，它只循环集合本身的元素：
    
        var a = ['A', 'B', 'C'];
        a.name = 'Hello';
        for (var x of a) {
            console.log(x); // 'A', 'B', 'C'
        }
    
     *  iterable内置的forEach方法
    
    然而，更好的方式是直接使用iterable内置的forEach方法，它接收一个函数，每次迭代就自动回调该函数。以Array为例：
    
        var a = ['A', 'B', 'C'];
              a.forEach(function (element, index, array) {
              
                  // element: 指向当前元素的值
                  // index: 指向当前索引
                  // array: 指向Array对象本身
                  console.log(element + ', index = ' + index);
              });
    
    **注意，forEach()方法是ES5.1标准引入的，你需要测试浏览器是否支持。**
    
     *  Set与Array类似，但Set没有索引，因此回调函数的前两个参数都是元素本身：
        
            var s = new Set(['A', 'B', 'C']);
            s.forEach(function (element, sameElement, set) {
                console.log(element);
            });
     *  Map的回调函数参数依次为value、key和map本身：
        
            var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
            m.forEach(function (value, key, map) {
                console.log(value);
            });
    
    **如果对某些参数不感兴趣，由于JavaScript的函数调用不要求参数必须一致，因此可以忽略它们。例如，只需要获得Array的element：**
    
        var a = ['A', 'B', 'C'];
        a.forEach(function (element) {
              
            console.log(element);
        })
 *  函数
    
     *  rest参数
    
    由于JavaScript函数允许接收任意个参数，于是我们就不得不用arguments来获取所有参数：
    
        function foo(a, b) {
              
            var i, rest = [];
            if (arguments.length > 2) {
                for (i = 2; i<arguments.length; i++) {
                    rest.push(arguments[i]);
                }
            }
            console.log('a = ' + a);
            console.log('b = ' + b);
            console.log(rest);
        }
    
    为了获取除了已定义参数a、b之外的参数，我们不得不用arguments，并且循环要从索引2开始以便排除前两个参数，这种写法很别扭，只是为了获得额外的rest参数，有没有更好的方法？
    
     *  ES6标准引入了rest参数，上面的函数可以改写为：  
        
        
            function foo(a, b, ...rest) {
                    
                console.log('a = ' + a);
                console.log('b = ' + b);
                console.log(rest);
            }
            
            foo(1, 2, 3, 4, 5);
            // 结果:
            // a = 1
            // b = 2
            // Array [ 3, 4, 5 ]
            
            foo(1);
            // 结果:
            // a = 1
            // b = undefined
            // Array []
    
    rest参数只能写在最后，前面用…标识，从运行结果可知，传入的参数先绑定a、b，多余的参数以数组形式交给变量rest，所以，不再需要arguments我们就获取了全部参数。
    
    **如果传入的参数连正常定义的参数都没填满，也不要紧，rest参数会接收一个空数组（注意不是undefined）。**
    
    **因为rest参数是ES6新标准，所以你需要测试一下浏览器是否支持。**
    
     *  return的多行写法是：  
        
        
            function foo() {
                    
                return {        // 这里不会自动加分号，因为{表示语句尚未结束
                    name: 'foo'
                };
            }
 *  作用域
    
     *  变量提升
    
    JavaScript的函数定义有个特点，它会先扫描整个函数体的语句，把所有申明的变量“提升”到函数顶部：
    
        'use strict';
        function foo() {
              
            var x = 'Hello, ' + y;
            console.log(x);
            var y = 'Bob';
        }
        
        foo();    //Hello, undefined
    
    虽然是strict模式，但语句var x = ‘Hello, ’ + y;并不报错，原因是变量y在稍后申明了。但是console.log显示Hello, undefined，说明变量y的值为undefined。这正是因为JavaScript引擎自动提升了变量y的声明，但不会提升变量y的赋值。
    
    对于上述foo()函数，JavaScript引擎看到的代码相当于：
    
        function foo() {
              
            var y; // 提升变量y的申明，此时y为undefined
            var x = 'Hello, ' + y;
            console.log(x);
            y = 'Bob';
        }
    
     *  名字空间
    
    全局变量会绑定到window上，不同的JavaScript文件如果使用了相同的全局变量，或者定义了相同名字的顶层函数，都会造成命名冲突，并且很难被发现。
    
    减少冲突的一个方法是把自己的所有变量和函数全部绑定到一个全局变量中。例如：
    
        // 唯一的全局变量MYAPP:
        var MYAPP = {};
        
        // 其他变量:
        MYAPP.name = 'myapp';
        MYAPP.version = 1.0;
        
        // 其他函数:
        MYAPP.foo = function () {
              
            return 'foo';
        };
    
    把自己的代码全部放入唯一的名字空间MYAPP中，会大大减少全局变量冲突的可能。
    
     *  解构赋值
    
    从ES6开始，JavaScript引入了解构赋值，可以同时对一组变量进行赋值。
    
    什么是解构赋值？我们先看看传统的做法，如何把一个数组的元素分别赋值给几个变量：
    
        var array = ['hello', 'JavaScript', 'ES6'];
        var x = array[0];
        var y = array[1];
        var z = array[2];
    
    现在，在ES6中，可以使用解构赋值，直接对多个变量同时赋值：
    
        'use strict';
        // 如果浏览器支持解构赋值就不会报错:
        var [x, y, z] = ['hello', 'JavaScript', 'ES6'];
        // x, y, z分别被赋值为数组对应元素:
        console.log('x = ' + x + ', y = ' + y + ', z = ' + z);    
        //x = hello, y = JavaScript, z = ES6
    
    **注意，对数组元素进行解构赋值时，多个变量要用\[…\]括起来。**
    
    如果数组本身还有嵌套，也可以通过下面的形式进行解构赋值，注意嵌套层次和位置要保持一致：
    
        let [x, [y, z]] = ['hello', ['JavaScript', 'ES6']];
        x; // 'hello'
        y; // 'JavaScript'
        z; // 'ES6'
    
    解构赋值还可以忽略某些元素：
    
        let [, , z] = ['hello', 'JavaScript', 'ES6']; // 忽略前两个元素，只对z赋值第三个元素
        z; // 'ES6'
    
    如果需要从一个对象中取出若干属性，也可以使用解构赋值，便于快速获取对象的指定属性：
    
        'use strict';
        
        var person = {
            name: '小明',
            age: 20,
            gender: 'male',
            passport: 'G-12345678',
            school: 'No.4 middle school'
        };
        var {name, age, passport} = person;
        
        // name, age, passport分别被赋值为对应属性:
        console.log('name = ' + name + ', age = ' + age + ', passport = ' + passport);
    
    对一个对象进行解构赋值时，同样可以直接对嵌套的对象属性进行赋值，只要保证对应的层次是一致的：
    
        var person = {
            name: '小明',
            age: 20,
            gender: 'male',
            passport: 'G-12345678',
            school: 'No.4 middle school',
            address: {
                city: 'Beijing',
                street: 'No.1 Road',
                zipcode: '100001'
            }
        };
        var {name, address: {city, zip}} = person;
        name; // '小明'
        city; // 'Beijing'
        zip; // undefined, 因为属性名是zipcode而不是zip
        // 注意: address不是变量，而是为了让city和zip获得嵌套的address对象的属性:
        address; // Uncaught ReferenceError: address is not defined
    
    使用解构赋值对对象属性进行赋值时，如果对应的属性不存在，变量将被赋值为undefined，这和引用一个不存在的属性获得undefined是一致的。如果要使用的变量名和属性名不一致，可以用下面的语法获取：
    
        var person = {
            name: '小明',
            age: 20,
            gender: 'male',
            passport: 'G-12345678',
            school: 'No.4 middle school'
        };
        
        // 把passport属性赋值给变量id:
        let {name, passport:id} = person;
        name; // '小明'
        id; // 'G-12345678'
        // 注意: passport不是变量，而是为了让变量id获得passport属性:
        passport; // Uncaught ReferenceError: passport is not defined
    
    解构赋值还可以使用默认值，这样就避免了不存在的属性返回undefined的问题：
    
        var person = {
            name: '小明',
            age: 20,
            gender: 'male',
            passport: 'G-12345678'
        };
        
        // 如果person对象没有single属性，默认赋值为true:
        var {name, single=true} = person;
        name; // '小明'
        single; // true
    
    有些时候，如果变量已经被声明了，再次赋值的时候，正确的写法也会报语法错误：
    
        // 声明变量:
        var x, y;
        // 解构赋值:
        {x, y} = { name: '小明', x: 100, y: 200};
        // 语法错误: Uncaught SyntaxError: Unexpected token =
    
    这是因为JavaScript引擎把\{开头的语句当作了块处理，于是=不再合法。解决方法是用小括号括起来：
    
        ({x, y} = { name: '小明', x: 100, y: 200});
    
     *  使用场景
        
        解构赋值在很多时候可以大大简化代码。例如，交换两个变量x和y的值，可以这么写，不再需要临时变量：
        
            var x=1, y=2;
            [x, y] = [y, x]
        
        快速获取当前页面的域名和路径：
        
            var {hostname:domain, pathname:path} = location;
        
        如果一个函数接收一个对象作为参数，那么，可以使用解构直接把对象的属性绑定到变量中。例如，下面的函数可以快速创建一个Date对象：
        
            function buildDate({year, month, day, hour=0, minute=0, second=0}) {
                    
              return new Date(year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second);
            }
        
        它的方便之处在于传入的对象只需要year、month和day这三个属性：
        
            buildDate({ year: 2017, month: 1, day: 1 });
            // Sun Jan 01 2017 00:00:00 GMT+0800 (CST)
        
        也可以传入hour、minute和second属性：
        
            buildDate({ year: 2017, month: 1, day: 1, hour: 20, minute: 15 });
            // Sun Jan 01 2017 20:15:00 GMT+0800 (CST)
        
        **使用解构赋值可以减少代码量，但是，需要在支持ES6解构赋值特性的现代浏览器中才能正常运行。目前支持解构赋值的浏览器包括Chrome，Firefox，Edge等。**
 *  方法
    
    > 在一个对象中绑定函数，称为这个对象的方法。
    
     *  如果我们给xiaoming绑定一个函数，就可以做更多的事情。比如，写个age()方法，返回xiaoming的年龄：  
        
        
            var xiaoming = {
                name: '小明',
                birth: 1990,
                age: function () {
                    
                    var y = new Date().getFullYear();
                    return y - this.birth;
                }
            };
            
            xiaoming.age; // function xiaoming.age()
            xiaoming.age(); // 今年调用是25,明年调用就变成26了
    
    绑定到对象上的函数称为方法，和普通函数也没啥区别。
    
     *  apply
    
    虽然在一个独立的函数调用中，根据是否是strict模式，this指向undefined或window，不过，我们还是可以控制this的指向的！
    
    要指定函数的this指向哪个对象，可以用函数本身的apply方法，它接收两个参数，第一个参数就是需要绑定的this变量，第二个参数是Array，表示函数本身的参数。
    
    用apply修复getAge()调用：
    
        function getAge() {
              
            var y = new Date().getFullYear();
            return y - this.birth;
        }
        
        var xiaoming = {
            name: '小明',
            birth: 1990,
            age: getAge
        };
        
        xiaoming.age(); // 25
        getAge.apply(xiaoming, []); // 25, this指向xiaoming, 参数为空
    
    另一个与apply()类似的方法是call()，唯一区别是：
    
    > apply()把参数打包成Array再传入；  
    > call()把参数按顺序传入。
    
    比如调用Math.max(3, 5, 4)，分别用apply()和call()实现如下：
    
        Math.max.apply(null, [3, 5, 4]); // 5
        Math.max.call(null, 3, 5, 4); // 5
    
    对普通函数调用，我们通常把this绑定为null。
    
     *  装饰器 （这是啥玩意儿，不太懂）
     *  利用apply()，我们还可以动态改变函数的行为。
        
        JavaScript的所有对象都是动态的，即使内置的函数，我们也可以重新指向新的函数。
        
        现在假定我们想统计一下代码一共调用了多少次parseInt()，可以把所有的调用都找出来，然后手动加上count += 1，不过这样做太傻了。最佳方案是用我们自己的函数替换掉默认的parseInt()：
        
            'use strict';
            
            var count = 0;
            var oldParseInt = parseInt; // 保存原函数
            
            window.parseInt = function () {
                    
              count += 1;
              return oldParseInt.apply(null, arguments); // 调用原函数
            };
            
            // 测试:
            parseInt('10');
            parseInt('20');
            parseInt('30');
            console.log('count = ' + count); // 3