Copia superficial copia profunda, prototipo, verificación de tipo, copia profunda recursiva
Copia superficial:
let top = {
name: "赵云",
};
let bom = "云中君";
function shallowCopy(src) {
var newobj = {
};
for (var prop in src) {
if (src.hasOwnProperty(prop)) {
newobj[prop] = src[prop];
}
}
return newobj;
}
En términos simples, una copia superficial es un puntero a un valor, y ambos valores cambiarán cuando cambie el valor actual.
Copia profunda:
// 示例
let ttp = [{
name: "123" }, {
name1: "1233" }];
let aa = ttp;
aa[0].name = "0";
console.log(ttp);
//我们可以借助这个实例来看，如果你直接赋值，当你的aa中发生改变，ttp中也会跟着改变
//我们可以使用JSON.parse(JSON.stringify(ttp));
let ttp = [{
name: "123" }, {
name1: "1233" }];
let aa = JSON.parse(JSON.stringify(ttp));
aa[0].name = "0";
console.log(ttp);
这样就 不会改变
La copia profunda consiste en extraer los tipos de referencia complejos poco a poco y asignarlos a un espacio recién abierto sin interferir con los datos originales.
prototipo:
Cada objeto en JavaScript tiene una propiedad –proto, que corresponde a su propio prototipo.
Cada función en JavaScript tiene una propiedad proto. Esta propiedad tiene una propiedad de prototipo. Esta propiedad es el prototipo.
Verificación de tipo
Tipo de datos básicos: Número de cadena booleano nulo simbólico indefinido Tipo de
datos de referencia: datos de función de matriz de objetos
.Tipo de juicio:
1.typeof: puede juzgar algunos tipos de datos básicos, y no funciona cuando se encuentran tipos de datos de referencia.
2.instanceof juzga los tipos de datos de referencia creados por new sin considerar los tipos de datos básicos creados por nulos e indefinidos
3.constructor can resolver tipos de datos básicos generales y tipo de referencia.
Solo si crea un constructor y lo apunta a la matriz, no funcionará 4.object.prototype.toString.call () para determinar a qué objeto pertenece, no puede determinar personalizado
Copia profunda recursiva
function cloneDeep(obj) {
3 // 3.根据obj为对象或者数组，产生一个空的对象或数组，存放数据
4 var newobj = obj instanceof Array ? [] : {
},
5 // 1.for...in进入循环
6 for (var k in obj) {
7 // 2.判断对象的第一个属性是否为数组或者对象，如果是，则进入递归
8 // if (obj[k] instanceof Array) {
9 // newobj[k] = cloneDeep(obj[k])
10 // } else if (obj[k] instanceof Object) {
11 // newobj[k] = cloneDeep(obj[k])
12 // }
13 // 4.上面两个执行逻辑一样，进行合并
14 if (typeof obj[k] === ‘object‘) {
15 newobj[k] = cloneDeep(obj[k])
16 } else {
17 // 5.如果数据为基本类型，则直接赋值
18 newobj[k] = obj[k]
19 }
20 }
21 // 6.把存放了数据的新对象返回出去
22 return newobj
23 }
Use funciones recursivas o recursivas para lograr una copia profunda:
use métodos recursivos para tomar valores en el anidamiento de objetos o de matriz, y coloque el valor recuperado en un nuevo espacio para completar la copia profunda.