es6 &&防抖节流

<script>
    let arr = [1, 2, 3, 6, 5, 4]
    for (var k in arr) {
        // console.log(arr[k])
    }
    // console.log(typeof arr) object


    // ------ 深拷贝  JSON.parse(JSON.stringify(data))会丢失里面的函数------ 缺点：据说如果数据深度 > 1000+ 会爆栈 方法一
    // 深浅拷贝的区别就是前者将原数据重新复制了一份然后新开了一个地址，后者则是将原数据的引用地址拷贝了一份而已
    // let obj = {
    //     name: 'zj',
    //     age: 18,
    //     grendr: {
    //         num: 12,
    //         list: [0, 12, 3, 0],
    //         listObj: {
    //             ore: 'res',
    //             message: '成功',
    //             list: [
    //                 1, 2, 3, {
    //                     a: 1,
    //                     b: 2
    //                 }
    //             ]
    //         }
    //     },
    //     test: function() {},
    //    a:[3,2,1]
    // }
    // function clone(obj, tar) {
    //     var tar = tar || {};
    //     var type = Object.prototype.toString;
    //     for (var k in obj) {
    //         if (obj.hasOwnProperty(k)) {
    //             if (typeof obj[k] === 'object' && obj[k] != null) {
    //                 tar[k] = type.call(obj[k]) === '[object Array]' ? [] : {};
    //                 clone(obj[k], tar[k]);
    //             } else {
    //                 tar[k] = obj[k];
    //             }
    //         }
    //     }
    //     return tar
    // }
    // console.log(clone(obj, {}))

    // 使用lodash函数库来进行深拷贝 方法二
    //  src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"
    // let data = {
    // name: '严家辉',
    // age: 18,
    // other: {
    //     gender: "男"
    // }
    //     }
    //     const aa = () => {
    //         // 核心代码
    //         let data1 = _.cloneDeep(data)
    //         data1.name = '隔壁小花'
    //         data1.other.gender = '女'
    //         console.log('a函数',data1)
    //     }
    //     const b = () => console.log('b函数',data) // 老严
    //     aa()
    //     b()


    // jq来进行深拷贝 方法三
    // src="http://code.jquery.com/jquery-2.1.1.min.js"let data = {
    //     name: '严家辉',
    //     age: 18,
    //     other: {
    //         gender: "男"
    //     }
    // }
    // const a = () => {
    //     // 核心代码
    //     let data1 = $.extend(true,{},data);
    //     data1.name = '隔壁老王'
    //     data1.other.gender = '女'
    //     console.log('a函数',data1)
    // }
    // const b = () => console.log('b函数',data) // 老严
    // a()
    // b()

    // ------浅拷贝 -----------
    // 浅拷贝方法一
    // const deepCopy = obj => {
    //     let result = typeof obj.splice === "function" ? [] : {};
    //     if (obj && typeof obj === 'object') {
    //         for (let key in obj) {
    //             // 我们直接去掉递归，让第二层的数据直接赋值（引用地址）
    //              result[key] = obj[key];
    //         }
    //         return result;
    //     }
    //     return obj;
    // }
    // let data = {
    //     name: '严家辉',
    //     age: 18,
    //     other: {
    //         gender: "男"
    //     }
    // }
    // const a = () => {
    //     let data1 = deepCopy(data);
    //     data1.name = '隔壁老王'
    //     data1.other.gender = '女'
    //     console.log('a函数',data1)
    // }
    // const b = () => console.log('b函数',data) // 老严
    // a()
    // b()

    // 浅拷贝方法二
    // let data = {
    //     name: '严家辉',
    //     age: 18,
    //     other: {
    //         gender: "男"
    //     }
    // }
    // const a = () => {
    //     // 核心代码
    //     let data1 = Object.assign({},data);
    //     data1.name = '城中村村花'
    //     data1.other.gender = '女'
    //     console.log('a函数',data1)
    // }
    // const b = () => console.log('b函数',data) // 老严
    // a()
    // b()


  //------ 如何判断两个对象（不定顺序的key）是否相等呢？------
    // const objArrobj = { a: 1, b: 2, c: 3 };
    // let a = Object.keys(objArrobj)//把key变为一个数组
    // console.log(a.includes('a')) //includes查找数组中是否有这个元素

    // let msgobj1 = {
    //     name: '严家辉',
    //     age: 18
    // }
    // let msgobj2 = {
    //     age: 18,
    //     name: '严家辉'
    // }
    // var obj1keys = Object.keys(msgobj1);  
    // var obj2keys = Object.keys(msgobj2);
    // var isSame = (obj1keys, obj2keys) => {
    //     if (obj2keys.length !== obj1keys.length) return false;
    //     for (let i = 0; i <= obj1keys.length - 1; i++) {
    //         let key = obj1keys[i];
    //         if (!obj2keys.includes(key)) return false
    //         if (msgobj2[key] !==msgobj2[key]) return false
    //     }
    //     return true
    // }
    // console.log(isSame(obj1keys, obj2keys))

  



    // es6 generator 
    // function* geners() {
    //     var y = yield 0 + 0;
    //     console.log(y)

    //     var c =  yield 1
    //     console.log(c)

    //     var z = yield z+2
    //     console.log(z)
    // }
    // var nex = geners()
    // nex.next()
    // nex.next(2333) //遇到yield 语句会停止 传的参数会赋值
    // nex.next(23)

    // es6 new set()去重
    // let array = [1,2,2,2,2,2,2,2,2,3,6,6,8,4,5,6,54,2]
    // let setarr = new Set(array)
    // let newArr = Array.from(setarr);
    // console.log(newArr)

    // es6 Object.assign()合并
    // let obj12 = {a:1}
    // let obj2 = {c:2}
    // let obj3 = Object.assign(obj12,obj2)
    // console.log(obj3)


    // 闭包


    //防抖节流 
    function debounce(fn, delay) {
        let timer = null //借助闭包
        return function () {
            if (timer) {
                clearTimeout(timer);
            }
            timer = setTimeout(fn, delay); // 简化写法
        }
    }
    // 然后是旧代码
    function showTop() {
        var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
        console.log('滚动条位置：' + scrollTop);
    }
    window.onscroll = debounce(showTop, 1000);


	
	instanceof使用场景
	判断在一个继承关系中实例是否属于它的父类。
	
	// 继承
	let oFather = function () {};
	let nFather = function () {};
	nFather.prototype = new oFather();
	nFather.construction = nFather;
	
	let nSon = new nFather();
	console.log(nSon instanceof nFather); // true
	console.log(nSon instanceof oFather); // true
	</script>
	```