关于钩子函数、深浅拷贝、多库共存以及jQuery的闭包函数的定义封装调用执行、数组去重详解

钩子函数

严格意义上来说,就是一个 观察者设计模式
本质特点是:
与 某个函数或者程序 相互挂钩、当程序执行到某个状态或步骤是触发不同的函数程序

只对 jQuery封装的 $.get $.post $.ajax起作用

深浅拷贝
1,只对 应用数据类型 讨论深浅拷贝

2,将 引用数据类型的 内存地址 赋值给一个变量存储 称为浅拷贝
特点 : 两个变量a , b 同时操作一个存储空间
a操作 引用数据类型
b查看 也会看到操作的结果影响
两个变量 a,b 同时操作一个内存地址,一个数据对象
任意一个操作,另一个也会受到影响,也会改变调用数据的结果

3,将 引用数据类型的 存储数据数值 逐一赋值给另一个变量存储,称为 深拷贝
特点 : 两个变量a,b 操作两个不同的存储空间
只是其中存储的数据内容相同

4,语法
将 obj1 之后所有变量存储的数据,浅拷贝给obj1
$.extend(obj1,obj2,obj3…)
将 obj1之后所有变量存储的数据,深拷贝给obj1
$.extend(true,obj1,obj2,obj3…);

多库共存
交出 $ 和 jQuery 两个关键词 控制 JQ 的控制权
同时更换 控制 JQ 的关键词
$.noConflict() 交出 $ 的控制权
$.noConflict(true) 交出 $ 和 jQuery 的控制权
var aaa = $.noConflit(true) 将控制权交给aaa
aaa.() 调用jQuery方法

添加方法
添加给 jQuery本身,通过$.名称() 调用添加的函数
jQuery.extend({
名称:匿名函数
})
添加给 标签对象, 通过 $(标签对象).名称() 调用添加的函数
jQuery.fn.extend({
名称:匿名函数{return}
})

闭包
闭包:是 js 中对于函数的一种高级应用
本质目的是为了调用使用 局部作用域变量 存储的数据

函数的定义封装
1,开辟一个存储空间,定义内存地址,准备存储函数程序
2,将函数程序以类似于字符串的形式,存储在内存空间中
此时 函数 只是以字符串的形式存储,并没有被执行
3,将 内存地址赋值给 函数名称 或者变量存储

函数的调用执行
1,通过函数名称或者变量中存储的内存地址,找到存储空间
2,读取其中存储的函数程序,并给形参赋值实参
3,预解析/预解释函数中的 var 或者 funtion 关键词
4,执行函数

函数的执行过程
1,会在函数存储空间中 再次创建一个独立的存储空间
2,专门存储函数中定义的参数、变量等 局部作用域变量
3,执行函数程序,调用使用的是全局作用域边梁或者局部作用域变量
4,函数执行结束,执行空间被销毁,其中的 局部作用域变量,会同之星空间一起被销毁
当函数执行结束之后,局部作用域变量将不存在
无法调用函数中的变量,原因就是因为,函数执行结束函数的局部作用域变量会同执行空间一起被销毁
如果想要使用 局部作用域变量 需要执行空间一直存在
如何来创建一个不被销毁的执行空间
1, 定义一个函数
2, 函数的返回值 是一个 引用数据类型
3, 在函数外部,有一个变量,来存储/使用这个引用数据类型
为了解决全局变量污染
闭包的 优点/缺点
1,会创建一个不被销毁的存储空间
优点: 数据会一直存在不被销毁
缺点: 占用存储空间
2,在函数为不可以访问函数内部的数据
优点: 操作方便
缺点: 容易数据泄露
3,变量私有化
优点: 全局变量变成局部变量,数据更安全了
缺点: 调用方法更复杂了

**SET 数据类型是 ES6 新增的语法形式 **
是一个类似于数组的数据类型
特点:不会存储重复数据
通过 构造函数 来定义 set类型
每一个set类型都有一个size属性 类似于数组的length属性
set类型不能像数组 使用[]语法去通过索引下标获取具体的数据

数组去重方法
1,set类型去重

<script>
const arr = [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6];
const newArr = [...new Set(arr)];
</script>

2, obj对象类型,键名不能重复

<script>
const arr = [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6];
                    const obj = {};
                    const newArr = [];
                    arr.forEach((v)=>{
                        obj[v] = '随便写';
                    })
                    for(let k in obj){
                        newArr.push(k);
                    } 
</script>

3,数组排序
从第一个单元开始,与之后的单元比较,两两相邻比较
如果数据相同就删除后一个单元
i-- 防止数组坍塌

<script>
                    const arr = [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6];
                    arr.sort((a,b)=>{return a-b});
                    for(let i = 0 ; i <= arr.length-1 ; i++){
                        if(arr[i] === arr[i+1]){
                            arr.splice(i,1);
                            i--;
                        }
              }
</script>

4,双层for循环
从第一个单元开始,给之后的所有单元比较
如果后面的数值相同,就删除之后的单元
内层循环变量-- 防止数组坍塌的影响

<script>
 const arr = [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6];
                    for(let i = 0 ; i <= arr.length-1 ; i++){
                        for(let j = 0 ; j <= arr.length-1-1 ; j++){
                            if(arr[i] === arr[j]){
                                arr,splice(j , 1);
                                j--;
                            }
                        }
                    }
 </script>  

5, indexOf 新数组中没有的数值在新增

  <script>
 const arr = [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6];
                   const newArr = [];
                   arr.forEach((v)=>{
                       if(newArr.indexOf === -1){
                           newArr.push(v);
                       }
                   })
</script>