this关键字

概念：在不同的作用域中，代表的含义是不同的
具体含义：
        全局this指向的是window
                例：console.log(this)
        普通函数中的this指向的是window
                例：function fn() {
                        console.log(this)
                    }
                    fn()
        定时器函数中的this指向的是window
                例：setTimeout(function() {
                        console.log(this)
                    }, 1000)
        自调用函数中的this指向的是window
                例：(function() {
                        console.log(this)
                    })()
        对象方法中的this指向的是这个对象
                例：var obj = {
                        name: '张三',
                        age: 12,
                        eat: function() {
                            console.log(this)
                        }
                    }
                    obj.eat()
        事件函数中的this指向的是这个标签
                例：<button id="btn">按钮</button>
                    btn.onclick = function() {
                        console.log(this)
                    }
        箭头函数中的this指向的是上级作用域中的this
理解：
    函数定义不能确定this含义，却决于调用形式
改变this指向的三种方法：
        call  -- 函数.call(新的this含义,给函数传实参)
                例：function fn() {
                        console.log(this)
                    }
                    fn() // window
                    fn.call(document) // document
         可以精准的检测数据类型：
                             {}.toString.call(数据) -- [object构造函数名字]
         将伪数组转成数组：
                         [].slice.call(伪数组)
        apply -- 函数.apply(新的this含义,[给函数传实参])
                例：function fn(a, b) {
                        var c = a + b
                        console.log(c)
                        console.log(this)
                    }
                    fn(1, 2) // 3 window
                    fn.apply(document, [2, 3]) // document 5
        bind -- 函数.bind(新的this含义) - 返回新的函数 -赋值函数并且改this，新的函数中的this和原函数中的this不同
                    例：function fn() {
                            console.log(this)
                        }
                        var newFn = fn.bind(document)
                        fn() // window
                        newFn() // document
                    bind不加参数，新函数的this为window：
                    var obj = {
                        name: '张三',
                        eat: function() {
                            console.log(this);
                        }
                    }
                    var fn = obj.eat.bind()
                    fn() // window

ES6

定义变量的关键字：
        let：
            语法：
                let a=1
        const：
            语法：
                const a=1
            定义的值就必须赋值
            值不允许改变所以不是变量而是常量
        跟var的区别：
            不能预解析
            不能重复定义
            自带块级作用域：
                循环中执行异步代码或绑定事件，在异步代码中或事件中，可以使用循环的变量
                全局中用let和const定义的变量不在window中
模板字符串：
        使用反引号定义字符串：
            可以多行定义一个字符串
            在控制台多行显示
            在字符串中通过${变量名}直接解析变量，不用拼接
对象简写：
        当对象的键和值所使用的变量名同名，就可以简写
            例：var name = 'ly'
                    var age = 12
                    var obj = {
                    name,
                    age
                }
                等同于
                    var obj = {
                    name: name,
                    age: age
                }
        当对象的键对应的值是匿名函数，就可以简写：
            例：var obj = {
                    eat() {}
                }
                等同于
                    var obj = {
                    eat: function() {}
                }
箭头函数：
        对匿名函数的简写 语法：()=>{}
        当只有一个形参的时候，可以省略小括号不写，当大括号只有一行代码的时候，可以省略大括号，如果这行代码中有return，那么必须省略突然return
            例：原：let fn = function(){
                        console.log(111);
                    }
                箭头函数：
                    let fn = ()=>{console.log(111);}
形参默认值：
        在定义的函数的时候，给形参直接赋值，表示在函数这个参数就算没有实参给他赋值，他也有默认值
解构赋值：
        快速的批量的定义变量，并拥有对象或数组中的值
        var {键1,键2}=对象 --  定义了两个变量，变量名分别是键1，键2，值是对象中这两个键对应的值
        var {键1:新的变量名}=对象 -- 定义了一个变量，变量名是新的变量名，值是键1在对象中对应的值
        var {键1：{键2}}=对象 -- 定义了变量，变量名是键2，值是对象.键1中键2对应的值
        var [变量名]=数组 -- 定义变量，值是数组的第一个元素
        var [[变量名]]=数组 -- 定义变量，值是数组中第一个数组中的第一个值
        
        
        例：
            解构赋值：将对象或数组中的多个数据快速的简洁的批量的赋值给多个变量
            var obj={
                name:'刘阳',
                age:'21',
                gender:'男',
                obj2:{
                    a:'刘阳',
                    b:'21',
                    c:'男',
                }
            }
            var {name,age,gender}=obj
            
            console.log(name,age,gender)变量名必须和健保持同名
            
            var {name,age,gender,obj2:{a,b,c}}=obj 同时结构多个
            
            console.log(c)
            
            var {name:name1}=obj//取别的名字原本的名字就不能用了
            
            console.log(name1)
            
            var arr=[1,2,3,[4,5,6]];
            
            var [a]=arr //变量名的值按照数组中的顺序进行赋值
            
            console.log(a)
            
            var [_,_,_,[_,_,a]]=arr 
            
            console.log(a)
            
展开合并运算符：
        语法：
            ...数组名：
                当他作为实参的时候，是将一个数组，展开成多个值
                将一个对象展开成多个键值对
                当他当作形参的时候，是将多个实参收集成一个数组

this的指向+ES6

this关键字

ES6