原生方法

let obj = { name: 'Alice', age: 25, city: 'New York' };

keys

返回一个由对象的所有可枚举属性的名称（键）组成的数组。

let keys = Object.keys(obj); // ["name", "age", "city"]

values

返回一个由对象的所有可枚举属性的值组成的数组。

let values = Object.values(obj); // ["Alice", 25, "New York"]

entries

返回一个给定对象自身可枚举属性的键值对数组。

let entries = Object.entries(obj); // [["name", "Alice"], ["age", 25], ["city", "New York"]]

assign

将所有可枚举的自身属性从一个或多个源对象复制到目标对象。它将返回目标对象。

let target = { a: 1 };
let source = { b: 2, c: 3 };
Object.assign(target, source); // { a: 1, b: 2, c: 3 }

freeze

冻结一个对象。一个被冻结的对象再也不能被修改。

Object.freeze(obj);
obj.age = 30; // 不能修改冻结的对象，obj.age 仍然是 25

seal

封闭一个对象，防止添加或删除属性。现有属性仍然可以更改。

Object.seal(obj);
obj.age = 30; // 可以修改现有属性
delete obj.city; // 不能删除属性，obj.city 仍然存在

getOwnPropertyDescriptor

返回指定对象上一个自有属性对应的属性描述符。

let descriptor = Object.getOwnPropertyDescriptor(obj, 'name');
// { value: "Alice", writable: true, enumerable: true, configurable: true }

getOwnPropertyDescriptors

返回指定对象所有自身属性（非继承属性）的描述对象。

let descriptors = Object.getOwnPropertyDescriptors(obj);
// {
//   name: { value: "Alice", writable: true, enumerable: true, configurable: true },
//   age: { value: 25, writable: true, enumerable: true, configurable: true },
//   city: { value: "New York", writable: true, enumerable: true, configurable: true }
// }

create

使用指定的原型对象及其属性创建一个新对象。

let newObj = Object.create(obj);
console.log(newObj.name); // "Alice"，从 obj 继承的属性

hasOwnProperty

判断对象是否包含特定的自身（非继承）属性。

let hasName = obj.hasOwnProperty('name'); // true
let hasToString = obj.hasOwnProperty('toString'); // false

propertyIsEnumerable

判断对象指定的属性是否可枚举。

let isEnumerable = obj.propertyIsEnumerable('name'); // true

get

获取嵌套对象的属性值，并且在路径不存在时返回默认值

var object = { a: [{ b: { c: 3 } }] };

_.get(object, 'a[0].b.c');
// => 3

_.get(object, ['a', '0', 'b', 'c']);
// => 3

_.get(object, 'a.b.c', 'default');
// => 'default'

原生实现

//可选链
let obj = { a: { b: { c: 3 } } };
let value = obj.a?.b?.c;

function hasValue(obj, path) {
	let keys = path.split('.');
	for (let key of keys) {
		if (obj && obj[key] !== undefined && obj[key] !== null) {
			obj = obj[key];
		} else {
			return false;
		}
	}
	return true;
}

let obj = { a: { b: { c: 3 } } };

has

检查对象是否具有指定路径上的属性

let obj = { a: { b: { c: 3 } } };

console.log(_.has(obj, 'a.b.c')); // true
console.log(_.has(obj, 'a.b.d')); // false

原生实现

//in运算符
let obj = { a: { b: { c: 3 } } };

console.log('c' in obj.a.b); // true
console.log('d' in obj.a.b); // false

//可选链操作符
let obj = { a: { b: { c: 3 } } };

console.log(obj.a?.b?.c !== undefined); // true
console.log(obj.a?.b?.d !== undefined); // false

function has(obj, path) {
	let keys = path.split('.');
	for (let key of keys) {
		if (!obj || !obj.hasOwnProperty(key)) {
			return false;
		}
		obj = obj[key];
	}
	return true;
}

omit

从对象中排除指定的属性

let obj = { a: 1, b: 2, c: 3 };
let omitted = _.omit(obj, ['a', 'c']);

原生实现

function omit(obj, keys) {
	let result = {};

	for (let key in obj) {
		if (obj.hasOwnProperty(key) && !keys.includes(key)) {
			result[key] = obj[key];
		}
	}

	return result;
}

sum

计算数组中所有元素的和

console.log(_.mean([4, 2, 8, 6])); // 5

原生实现

function sum(array) {
	return (sum = array.reduce((acc, val) => acc + val, 0));
}

sum

计算数组中所有元素的和

console.log(_.mean([4, 2, 8, 6])); // 5

原生实现

function sum(array) {
	return (sum = array.reduce((acc, val) => acc + val, 0));
}

sum

计算数组中所有元素的和

console.log(_.mean([4, 2, 8, 6])); // 5

原生实现

function sum(array) {
	return (sum = array.reduce((acc, val) => acc + val, 0));
}

sum

计算数组中所有元素的和

console.log(_.mean([4, 2, 8, 6])); // 5

原生实现

function sum(array) {
	return (sum = array.reduce((acc, val) => acc + val, 0));
}

sum

计算数组中所有元素的和

console.log(_.mean([4, 2, 8, 6])); // 5

原生实现

function sum(array) {
	return (sum = array.reduce((acc, val) => acc + val, 0));
}