this指向

在对象中this指向的是谁调用指向谁！

let obj ={
            name:'你好啊',
            age:'18',
            fn(){
                console.log(this);
            }
        }  
        obj.fn()//指向的整个对象

 // 在构造函数中
        function fn (name,age){
            this.name = name
            this.age = age
        } 
        console.log(fn);//fn 指向它的实例 整个函数

在函数中也是谁调用他指向谁

    <button class="aaa">1</button>
    <button class="aaa">2</button>
    <button class="aaa">3</button>
    <button class="aaa">4</button>
    <button class="aaa">5</button>
    <button class="aaa">6</button>

    var aaa = document.querySelectorAll('.aaa')
        for(var i=0;i<aaa.length;i++){
            aaa[i].addEventListener('click',function(){
            console.log(this);
        })
    }

递归

递归的压栈和出栈

栈是什么？可以理解为在内存中的一块区域，这个区域可以比喻成一个箱子，当我往箱子放东西就是压栈，最先放下的东西在最底下，最后放下的东西在最上面，我们把这个东西从箱子中拿出来就是出栈

阶乘是什么？ 就是 1 * 2 * 3 * 4 * 5 * 6

所以得出一个结论，我们都有个习惯，拿东西从上往下拿，最先放
下的东西在最底下最后才能拿到。
在js中调用函数会触发压栈行为就是放东西
遇到return 关键字句子或者执行结束之后会发生出栈就是取东西

// 简单的递归----
        function fn(num){
            if(num === 6) return 6
            return num + fn(num+1)
            // 1+2+3+4+5+6
        }
        console.log(fn(1));
        // 执行顺序，fn(1)传递了一个1 压栈 执行到reutnr 此时还不能出栈，继续调用fn
        // 1+1 = 2 fn(2)
        // 2+1 = 3 fn(3)
        // 3+1 = 4 fn(4)
        // 4+1 = 5 fn(5)
        // 5+1 = 6 fn(6)
        // 1+2+3+4+5+6 = 21

深浅拷贝

浅拷贝

let a = {a:1}
let a1 = {b:{b:2}}
let a2 = {c:3}
// 使用assign 实现浅拷贝
Object.assign(a1,a,a2)

深拷贝

        let obj1 = {
            a:0,
            b:{
                c:0
            }
        }
        console.log('深拷贝---↓');
        // 深拷贝
        let obj2 = JSON.parse(JSON.stringify(obj1))
        console.log(obj2);