闭包、赋值与引用、箭头函数、数组遍历API

一、闭包

定义： 函数中调用其它函数，有父级与子级之分。闭包即父级作用域包裹子级作用域，或子级作用域使用了父级作用域的变量或参数。
例：

        function fa(){   // 父
            let x = 10
            function son(){    // 子
                x++            //子用父的参数
            }
        }

 javascript变量回收机制
1.全局变量只要当前网页不关闭就不会回收
2.局部变量使用完后就会回收
闭包会使局部变量不会被回收，所以会占用内存。

代码1：

        fn()()
        var a = 0
        function fn(){
            alert(a)   // undefined
            var a = 3
            function b(){
                alert(a)  // 3
            }
            return b
        }

代码2：

        var a = 5
        function fn(){
            var a = 10
            alert(a)   //10
            function b(){
                a++
                alert(a)   //11
            }
            return b
        }
        var c = fn()
        c()  //10
        fn()()  //11
        c()    //12

二、赋值与引用

=的含义：
1.赋值：右边的数据赋值给左边的变量，赋完之后，左右无关系，左边的改变不会对右边有影响，右边数据时基础数据类型
2.引用：右边数据给左边，两边建立引用关系，右边数据是对象。左边的改变对右边有影响，任何一边的改变，会影响另一边。

        let a = 10
        let b = 10
        console.log(a===b) // true ,基础数据类型在做比较时，只比较值和类型

        let c = {name:"csdn"}
        let d = {name:"csdn"}
        console.log(c===d)  //false ，对象数据类型，比较地址

        let c = {name:"csdn"}
        let e = c
        console.log(c===e)  //true

三、箭头函数

箭头函数即普通函数的简写，且其内部不会产生新的this指向，以其父级this指向为准。

       let a = function(x){
            console.log(123)
        }
        // 简化后：
        let a = (x) => {
            console.log(x*2)
        }
        //精简后：
        let a = x => {
            console.log(x*2)
        }

        let x = function(a,b) {
            return a+b
        }
        //简化后：
        let x = (a,b) => {
            return a+b
        }
        //精简后：
        let x = (a,b) => a+b

四、数组的添加删除–push、pop、unshift、shift

        let arr = [11,22,33,44]
        console.log(arr.length)  //显示数组的长度，4
        arr[3] = 99    //重新定义数组的内容，将其改为[11,22,33,99]
        arr.length = 2   //将数组的长度削减为2，数组变为[11,22]
        arr.length = 10   //数组变为[11,22,33,44,empty*6]
        arr.push(55)   //从数组的后端添加，数组变为[11,22,33,44,55]
        arr.pop()  //从数组的后端删除，数组变为[11,22,33]
        arr.unshift(00)   //从数组的前端添加，数组变为[00,11,22,33,44]
        arr.shift()    //从数组的前端删除，数组变为[22,33,44]

        let arr = [11,22,33,44]
        let x = arr.push(55)
        console.log(x)  //push和unshift使用后，x返回的是数组的长度5

        let arr = [11,22,33,44]
        let x = arr.pop()
        console.log(x)  //pop和shift使用后，返回的是删除的元素，44

指定位置添加删除，方法 splice(从哪位开始，删除几个，用什么代替)

        let arr = [11,22,33,44]
        arr.splice(1,1,66)
        console.log(arr)  //[11,66,33,44]
        arr.splice(arr.length,0,"csdn")
        console.log(arr)   //[11,66,33,44,"csdn"]

五、数组的遍历forEach

        let arr = [4,5,6,7]
        arr.forEach( function(item, index, arr){
            console.log(item, index, arr)
        })
        //item为数组中的元素；index为元素对应的位置； arr为该数组
        // 打印 4  0  [4,5,6,7]
        //      5  1  [4,5,6,7]
        //      6  2  [4,5,6,7]
        //      7  3  [4,5,6,7]

只有querySelectorAll获得的节点列表、数组才能直接forEach

        //此处的ali为用querySelectorAll获得的列表
        ali.forEach((item) => {
            item.onclick = function(){
                alert(this.innerText)
            }
        })

六、数组的filter

过滤原数组，返回的是一个新数组

        let arr = [22,33,44,55]
        let newArr = arr.filter(item => {
            if(item%2){             //item%2,取余为0,0为false
                console.log("奇数")
            } else {
                console.log("偶数")
            }
        })

七、数组的遍历–map

forEach没有返回值，map返回的是一个根据指定函数对原数组进行处理产生的新数组

        let arr = [22,33,44,55]
        let newArr1 = arr.map( item =>  item*item)
        console.log(newArr)  //此处返回原数组各元素的二次方，产生的是个新数组
		let newArr2 = arr.map( item =>  item**3)   //此处返回原数组各元素的三次方

API	返回值
forEach	无返回需求
filter	布尔值
map	数组