深拷贝和浅拷贝
首先明白概念，深浅拷贝都只是针对复杂数据类型的，对于简单数据类型来说是没有深浅拷贝这个概念的
浅拷贝，拷贝复杂数据类型的时候，会直接拷贝复杂数据类型的地址，这样不管我们修改哪一个数组或者对象的时候，另外一个也会跟着改变。但是修改简单数据类型的时候，另外一个不会改变。（只对复杂数据类型有效果）
深拷贝，拷贝复杂数据类型的时候，不会直接拷贝复杂数据类型的地址，而是拷贝复杂数据类型里边的数据。所以我们在修改复杂数据类型里边的数值的时候，不会影响到另外一个数据
直接赋值，不是深浅拷贝，是公用一个地址，这样修改简单数据类型的时候，两个都会跟着改变
深拷贝有哪些方法：方法一，递归。第二个方法，lodash。第三个方法，JSON.parse(JSON.stringify(拷贝的数据))
JSON深拷贝的原理：字符串的不可更改性，首先我们创建一个字符串以后，js会给该字符串开辟一个新的空间。当，我们在重新修改字符串的时候，js会开辟一个新的空间，然后改变指针指向新的字符串，原来的字符串是还在的。
所以我们应该避免字符串，过多拼接，如果拼接字符串超过一万的时候，浏览器会报错，太长了，导致js引擎解析不出来
浅拷贝的方法
// 浅拷贝
let Obj = {
uname : `张三`,
age : 18
}
let ls = Obj
console.log(ls)
ls.uname = `李四`
console.log(Obj) // 这个时候张三和李四都会改变为李四
console.log(ls)
// Object.assign(给谁，拷贝谁)
let Obj1 = {}
Object.assign(Obj1,Obj)
console.log(Obj1)
const o = {...Obj}
// 浅拷贝
console.log(o)
深拷贝的递归方法
<script>
let obj = {
name : `11`,
arr : [1,3,5,7,9],
sing : {
uname : `22`,
age : `33`
}
}
let obj1 = {}
function deef(obj,obj1) {
for (const k in obj) {
if (obj[k] instanceof Array){
obj1[k] = []
// obj1[k] = obj[k]
deef(obj1[k],obj[k])
}
else if (obj[k] instanceof Object){
obj1[k] = {}
// obj1[k] = obj[k]
deef(obj1[k],obj[k])
}
else obj1[k] = obj[k]
// console.log([k])
// console.log(obj[k])
}
console.log(obj1)
}
deef(obj,obj1)
console.log(obj)
console.log(obj1)
obj1.arr = [2,4,6,8]
obj.arr = [11,13,14,16]
console.log(obj1)
console.log(obj)
</script>
深拷贝lodash方法
<script src="../js/lodash.min.js"></script>
<script>
let obj = {
name : `11`,
arr : [1,3,5,7,9],
sing : {
uname : `22`,
age : `33`
}
}
const o = _.cloneDeep(obj)
console.log(o)
o.sing.uname = `66`
console.log(o)
console.log(obj)
</script>
JSON方法（js拷贝的时候会完全过滤掉空的字符串和方法）
<script>
let obj = {
name : `11`,
arr : [1,3,5,7,9],
sing : {
uname : `22`,
age : `33`
}
}
// JSON.stringify(obj) //把代码转换为json字符串
// JSON.parse(JSON.stringify(obj))
// 字符串的不可变性
// let str = `pink` //这里的pink不会改变，更改的时候会开辟一个新的空间
// str = `123` //改为123 //开辟一个新的空间，存放123，并且指针指向123
// str = `red` //改为red，更新变量的值//开辟一个新的空间，存放red，指针指向red
//不要大量拼接字符串，超过万级以上，会造成内存泄漏
let a = JSON.parse(JSON.stringify(obj))
console.log(a)
</script>
递归定时器和深拷贝
<script>
// setTimeout()实现setInterval()效果
function getTime() {
console.log(new Date().toLocaleString()) // 提供快速拼接年月日 时分秒
document.querySelector(`div`).innerHTML = new Date().toLocaleString()
// setTimeout(function () { // 回调函数，过一秒调用一次自己的函数
// getTime()
// },1000)
// setTimeout(getTime,1000) //定时器调用函数本身，函数递归，函数自己调用自己
}
getTime()
// 递归实现深拷贝
obj1 = {
name : `王路飞`,
age : 18,
arr: [1,3,5,7,9],
sing : {
m : `王路飞1`,
f : `王路飞2`
}
}
// 未来给到一个新的对象
const obj = {}
obj1.name = `老师`
obj1[`age`] = 30
// console.log(obj1)
for (let k in obj) {
console.log([k])
console.log(obj[k])
// obj1[k] = obj[k] //拷贝obj，浅拷贝
}
// console.log(obj1)
// 自己手写深拷贝
function deep(obj,obj1) {
// 简单数据类型可以直接赋值
// 复杂数据类型，判断是数组还是对象，数组用数组方式遍历，对象用对象方式遍历
for (const k in obj1) {
// console.log([k]) //所有的属性名
// console.log(obj1[k]) //所有的属性值
// if (如果值数数组) {数组的处理方法} else if (如果值是对象){对象处理方法}
if (obj1[k] instanceof Array){
// 开辟一个新数组
obj[k] = []
deep(obj[k],obj1[k]) //再次调用一次函数，先去赋值一个空数组，然后给他赋值
}
else if (obj1[k] instanceof Object){
obj[k] = {}
deep(obj[k],obj1[k])
}
else obj[k] = obj1[k]
console.log(obj)
}
}
deep(obj,obj1) //新的数组，有数据的数组
obj.arr = [2,4,6,8] //测试数组，改变以后地址是否也进行了改变
console.log(obj)
console.log(obj1)
</script>
捕获异常
// 异常捕获
// try{
// console.log(uname)//可能会错误的代码
// }catch (err){
// 捕获异常错误
// }finally {
// 不管成功失败都会运行
// console.log(1+1) //不管有没有错误都会走
// }
try {
age = 10 //可能出错的代码
} catch (err){
// 捕获错误
}finally {
console.log(`代码错误在这里显示`)
}
// 不会影响后边代码
console.log(1+1)
标签：obj1,obj,log,捕获,数据类型,深浅,console,拷贝 From： https://www.cnblogs.com/hgng/p/16938129.html