castArray

用于将给定的值转换为数组。如果值已经是数组，则返回原始数组；如果不是数组，则返回包含该值作为单个元素的新数组

const array1 = _.castArray(1);
console.log(array1); // Output: [1]

const array2 = _.castArray({ a: 1, b: 2 });
console.log(array2); // Output: [{ a: 1, b: 2 }]

const array3 = _.castArray([1, 2, 3]);
console.log(array3); // Output: [1, 2, 3]

原生实现

function castArray(value) {
	return Array.isArray(value) ? value : [value];
}

cloneDeep

浅拷贝 object.assign() 扩展运算符 ...

深拷贝 深浅拷贝的区别在于对值的引用关系 浅拷贝只拷贝对象的第一层深层属性为地址引用

const obj = { a: 1, b: { c: 2 } };
const clonedObj = _.cloneDeep(obj);

console.log(clonedObj); // 输出: { a: 1, b: { c: 2 } }
console.log(obj === clonedObj); // 输出: false (它们是不同的对象)
console.log(obj.b === clonedObj.b); // 输出: false (嵌套对象也被复制了)

原生实现

//1.递归拷贝
function deepClone(value) {
	if (typeof value !== 'object' || value === null) {
		return value; // 如果不是对象，则直接返回原始值
	}

	let clone;
	if (Array.isArray(value)) {
		clone = []; // 如果是数组，则创建一个新数组
		for (let i = 0; i < value.length; i++) {
			clone[i] = deepClone(value[i]); // 递归复制数组元素
		}
	} else {
		clone = {}; // 如果是对象，则创建一个新对象
		for (let key in value) {
			if (value.hasOwnProperty(key)) {
				clone[key] = deepClone(value[key]); // 递归复制对象属性
			}
		}
	}

	return clone;
}
//2.JSON.parse(JSON.stringify(object))
//不能处理循环引用（对象属性指向自身或相互引用的情况）；
//不能复制特定的对象属性，比如函数或 undefined；
//会忽略 symbol 类型的属性
const obj = { a: 1, b: { c: 2 } };
const clonedObj = JSON.parse(JSON.stringify(obj));

eq | isEqual

• _.eq 用于检查两个值的引用是否相同，类似于 === 运算符。
• _.isEqual 用于进行深度比较，以确定两个值是否相等，包括嵌套的对象和数组。

const obj1 = { a: 1, b: { c: [2, 3] } };
const obj2 = { a: 1, b: { c: [2, 3] } };

console.log(_.eq(obj1, obj2)); // false，因为 obj1 和 obj2 的引用不同

console.log(_.isEqual(obj1, obj2)); // true，因为 obj1 和 obj2 的内容相同

原生实现

1. 首先检查两个值是否完全相同（value === other）。
2. 检查值是否为 null 或类型是否非 object，若是，则直接返回 false。
3. 获取两个对象的键数组，若长度不同，则返回 false。
4. 遍历一个对象的所有键，检查是否都存在于另一个对象中，并递归比较对应的属性值。

function isEqual(value, other) {
	if (value === other) {
		return true;
	}

	if (
		value == null ||
		other == null ||
		typeof value !== 'object' ||
		typeof other !== 'object'
	) {
		return false;
	}

	const keysA = Object.keys(value);
	const keysB = Object.keys(other);

	if (keysA.length !== keysB.length) {
		return false;
	}

	for (let key of keysA) {
		if (
			!Object.prototype.hasOwnProperty.call(other, key) ||
			!isEqual(value[key], other[key])
		) {
			return false;
		}
	}

	return true;
}

// 测试
const obj1 = { a: 1, b: { c: [2, 3] } };
const obj2 = { a: 1, b: { c: [2, 3] } };

console.log(isEqual(obj1, obj2)); // true，因为 obj1 和 obj2 的内容相同