面试题-关于深拷贝浅拷贝

1
2
3
4
5
6
7
8
9
const a = [{aa: 1}]

var b = a.map(item => { // 因为此时item是一个对象，所以是直接更改item.aa也会影响a
  item.aa = 2
  return item
})
console.log(b) // b: {aa: 2}
console.log(a) // a: {aa: 2}

1
2
3
var a = {aa: 1}
var b = {...a}

1
2
3
4
5
6
7
8
9
10
11
12
13
var obj = {a: 1}

function clone(origin) {
  return JSON.parse(JSON.stringify(origin))
}

var copy = clone(obj)

copy.a = 2

console.log(obj)
console.log(copy)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var obj = {
            a: 1,
            b: undefined,
            say: function() {
             console.log(this.a)
            }
          }

function clone(origin) {
  return JSON.parse(JSON.stringify(origin))
}

var copy = clone(obj)

copy.a = 2

console.log(obj)
console.log(copy)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var obj = {
	a: 1,
	b: undefined,
	c: { cc: 1 },
	say: function () {
		console.log(this.a);
	},
};

function clone(origin) {
	let newValue = new origin.constructor();
	for (let key in origin) {
		if (typeof origin[key] === 'object') {
			debugger;
			newValue[key] = clone(origin[key]);
		} else {
			newValue[key] = origin[key];
		}
	}
	return newValue;
}

var copy = clone(obj);

copy.c.cc = 2;

console.log(obj);
console.log(copy);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
var obj = {
	a: 1,
};

var obj2 = {
	obj: obj,
};

obj.obj2 = obj2;

function clone(origin) {
	let newValue = new origin.constructor();
	for (let key in origin) {
		if (typeof origin[key] === 'object') {
			newValue[key] = clone(origin[key]);
		} else {
			newValue[key] = origin[key];
		}
	}
	return newValue;
}

var copy = clone(obj);

console.log(obj);
console.log(copy);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
var obj = {
	a: 1,
};

var obj2 = {
	obj: obj,
};

obj.obj2 = obj2;

// stack为缓存，是一个weapMap实例
function clone(origin, stack = new WeakMap()) {
	let newValue = new origin.constructor();
	if (stack.has(origin)) { // 如果缓存已存在，直接返回
		return stack.get(origin);
	}
	stack.set(origin, newValue); // 缓存中不存在，则新增一条记录
	for (let key in origin) {
		if (typeof origin[key] === 'object') {
			newValue[key] = clone(origin[key], stack);
		} else {
			newValue[key] = origin[key];
		}
	}
	return newValue;
}

var copy = clone(obj);

console.log(obj);
console.log(copy);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
var obj = {
	a: 1,
};

var obj2 = {
	obj: obj,
};

obj.obj2 = obj2;

function clone(origin, stack = new WeakMap()) {
	if (!origin) {
		return origin;
	}
	if (obj instanceof Date) {
		// 增加Date类型的copy
		return new Date(origin);
	}
	if (obj instanceof RegExp) {
		// 增加正则类型的copy
		return new RegExp(origin);
	}
	let newValue = new origin.constructor();
	if (stack.has(origin)) {
		return stack.get(origin);
	}
	stack.set(origin, newValue);
	for (let key in origin) {
		if (typeof origin[key] === 'object') {
			newValue[key] = clone(origin[key], stack);
		} else {
			newValue[key] = origin[key];
		}
	}
	return newValue;
}

var copy = clone(obj);

console.log(obj);
console.log(copy);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/**
 * The base implementation of `clone` and `cloneDeep` which tracks
 * traversed objects.
 *
 * @private
 * @param {*} value The value to clone.
 * @param {number} bitmask The bitmask flags.
 *  1 - Deep clone
 *  2 - Flatten inherited properties
 *  4 - Clone symbols
 * @param {Function} [customizer] The function to customize cloning.
 * @param {string} [key] The key of `value`.
 * @param {Object} [object] The parent object of `value`.
 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
 * @returns {*} Returns the cloned value.
 */
function baseClone(value, bitmask, customizer, key, object, stack) {
	// Check for circular references and return its corresponding clone.
	// 这里同样用到缓存
	stack || (stack = new Stack());
	const stacked = stack.get(value);
	if (stacked) {
		return stacked;
	}
	stack.set(value, result);

	const props = isArr ? undefined : keysFunc(value);
	// 开始遍历递归
	arrayEach(props || value, (subValue, key) => {
		if (props) {
			key = subValue;
			subValue = value[key];
		}
		// Recursively populate clone (susceptible to call stack limits).
		assignValue(
			result,
			key,
			baseClone(subValue, bitmask, customizer, key, value, stack)
		);
	});

	return result;
}