1. javascript对象方法总结
| 顺序 | 方法名 | 功能 | 返回值 | 是否改变原对象 |
|---|---|---|---|---|
| 1 | assign() | 多个对象的合并（ 浅拷贝 ） | 合并后的对象 | 是 |
| 2 | create() | 使用原型对象及其属性去创建一个新的对象 | 新对象 | 否 |
| 3 | defineProperties() | 在对象上定义新的属性或修改现有属性 | 新对象 | 是 |
| 4 | defineProperty() | 在对象上定义一个新属性，或者修改一个对象的现有属性 | 新对象 | 是 |
| 5 | keys() | 获取对象中可枚举属性的key | key数组 | 否 |
| 6 | values() | 获取对象中可枚举属性的value | value数组 | 否 |
| 7 | entries() | 获取对象中可枚举属性的键值对数组 | 键值对数组 | 否 |
| 8 | hasOwnProperty() | 判断对象自身属性中是否具有指定的属性 | 布尔值 | 否 |
| 9 | getOwnPropertyDescriptor() | 获取对象上一个自有属性对应的属性描述符 | 属性描述符对象 | 否 |
| 10 | getOwnPropertyDescriptors() | 获取对象所有自身属性的描述符 | 对象 | 否 |
| 11 | getOwnPropertyNames() | 获取对象所有自身属性的属性名 | key数组 | 否 |
| 12 | getOwnPropertySymbols() | 获取对象自身的所有 Symbol属性 | symbol属性数组 | 否 |
| 13 | getPrototypeOf() | 获取对象的原型 | 对象的原型 | 否 |
| 14 | isPrototypeOf() | 判断对象是否存在于另一个对象的原型链上 | 布尔值 | 否 |
| 15 | setPrototypeOf() | 设置对象的原型对象 | 对象 | 是 |
| 16 | is() | 判断两个值是否相同 | 布尔值 | 否 |
| 17 | freeze() | 冻结一个对象 | 对象 | 是 |
| 18 | isFrozen() | 判断一个对象是否被冻结 | 布尔值 | 否 |
| 19 | preventExtensions() | 设置对象不能再添加新的属性 | 对象 | 是 |
| 20 | isExtensible() | 判断对象是否可扩展 | 布尔值 | 否 |
| 21 | seal() | 对象密封（不能添加新属性，不能编辑已有属性，不可删除） | 对象 | 是 |
| 22 | isSealed() | 判断一个对象是否被密封 | 布尔值 | 否 |
2. 方法详解
1. Object.assign()
功能：该方法主要用于对象的合并，将源对象的所有可枚举属性合并到目标对象上,此方法只拷贝源对象的自身属性，不拷贝继承的属性。
var target = {
x: 0,
y: 1
}
var source = {
x: 1,
y: 2,
obj: {
z: 3
}
}
Object.assign(target, source); // {x: 1, y: 2, obj: { z: 3 }}
target.obj.z = 4; // source => {x: 1,y: 2, obj: { z: 4 }}
function Student(){
this.name = 'xxx'
}
Student.prototype.sex = '男';
let studentOne = new Student();
studentOne.age = 29;
const young = {instert: 'sport'};
// 只能拷贝自身属性不能拷贝prototype
Object.assign(young, studentOne); // {instert: "sport", name: "xxx", age: 29}
// 把数组当作对象来处理
Object.assign([1,2,3], [4,5]) // [4, 5, 3]
2. Object.create()
功能：使用指定的原型对象及其属性去创建一个新的对象
var children = {
x:0,
y: 1
}
var child = Object.create(children, {
z: {
writable: true,
enumerable: true,
configurable: true,
value: 2
}
})
console.log(child); // { z: 2, __proto__: { x: 0, y: 1 } }
3. Object.defineProperties
功能：直接在一个对象上定义新的属性或修改现有属性，并返回该对象。
var obj = {};
Object.defineProperties(obj, {
'property1': {
value: true,
writable: true
},
'property2': {
value: 'Hello',
writable: false
}
});
console.log(obj) // {property1: true, property2: "Hello"}
4. Object.defineProperty()
功能：在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。
var obj = {book: 1}
Object.defineProperty(obj, '_book', {
get: function() {
return `${this.book}`;
},
set: function(value) {
this._book= value;
}
});
console.log(obj) // { book: 1, _book: "1" }
5. Object.keys()
功能：返回一个给定对象的自身可枚举属性的属性名组成的数组。其属性的enumerable设置为true才可被枚举
/* Array数组 */
let arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // ['0', '1', '2']
/* Object 对象 */
let obj = { foo: "bar", baz: 42 },
console.log(Object.keys(obj)); // ["foo","baz"]
6. Object.values()
功能：返回一个给定对象的所有可枚举属性的属性值的数组。其属性的enumerable设置为true才可被枚举
var parent = {
x : 1,
y : 1
}
var child = Object.create(parent,{
z: {
writable:true,
configurable:true,
enumerable: true,
value: "newAdd"
}
});
console.log(Object.values(child)) // ["newAdd"]
7. Object.entries()
功能：返回对象自身可枚举属性的键值对数组。
const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
const simuArray = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(simuArray)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
8. Object.hasOwnProperty()
功能：判断对象中是否存在某个key
let obj = { a: 1 };
console.log(obj.hasOwnProperty("a")) // true
9. Object.getOwnPropertyDescriptor()
功能：返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。
var obj = {
name: '123'
}
var arr = ['name','age'] ;
arr.forEach(val => console.log(Object.getOwnPropertyDescriptor(obj,val)))
// { configurable: true,enumerable: true,value: "123",writable: true } undefined
10. Object.getOwnPropertyDescriptors()
功能：获取一个对象的所有自身属性的描述符。
var obj = {
name : 'js',
age : 20
}
console.log(Object.getOwnPropertyDescriptors(obj))
/*
{
name: {configurable: true,enumerable: true,value: js,writable: true},
age: {configurable: true,enumerable: true,value: 20,writable: true}
}
*/
11. Object.getOwnPropertyNames()
功能：返回指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。
var obj = {
x : 1,
y : 2
}
Object.defineProperty(obj,'z',{
enumerable : false
})
console.log(Object.getOwnPropertyNames(obj)) // ["x", "y", "z"] 包含不可枚举属性 。
console.log(Object.keys(obj)) // ["x", "y"] 只包含可枚举属性 。
12. Object.getOwnPropertySymbols()
功能：返回给定对象自身的所有 Symbol 属性的数组。
13. Object.getPrototypeOf()
功能：获取对象的原型。
var parent = {
x :1,
y : 1
}
var child = Object.create(parent,{
z : {
writable:true,
configurable:true,
value: "newAdd"
}
});
console.log(Object.getPrototypeOf(child)) // { x: 1, y: 2 }
14. isPrototypeOf()
功能：判断一个对象是否在另一个对象的原型上。
var parent = {
x : 1,
y : 1
}
var child = Object.create(parent,{
z : {
writable:true,
configurable:true,
value: "newAdd"
}
});
// 对象判断的是指针指向的地址
console.log({x: 1, y: 1}.isPrototypeOf(child)) // false
console.log(parent.isPrototypeOf(child)) // true
15. Object.setPrototypeOf()
功能：设置对象的原型对象
var parent = {
x : 1,
y : 1
}
var child = Object.create(parent,{
z : {
writable:true,
configurable:true,
value: "newAdd"
}
});
console.log(Object.setPrototypeOf(child, {a:1,b:2})) // { z: "newAdd", __proto__: { a: 1, b: 2 } }
16. Object.is()
功能：判断两个值是否相同。
如果下列任何一项成立，则两个值相同：
- 两个值都是 undefined
- 两个值都是 null
- 两个值都是 true 或者都是 false
- 两个值是由相同个数的字符按照相同的顺序组成的字符串
- 两个值指向同一个对象
- 两个值都是数字并且
- 都是正零 +0
- 都是负零 -0
- 都是 NaN
- 都是除零和 NaN 外的其它同一个数字
Object.is('foo', 'foo'); // true
Object.is(window, window); // true
Object.is('foo', 'bar'); // false
Object.is([], []); // false
var test = { a: 1 };
Object.is(test, test); // true
Object.is(null, null); // true
// 特例
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true
17. Object.freeze()
功能：冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。
var obj = {
prop: function() {},
foo: 'bar'
};
// 新的属性会被添加, 已存在的属性可能
// 会被修改或移除
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;
// 作为参数传递的对象与返回的对象都被冻结
// 所以不必保存返回的对象（因为两个对象全等）
var o = Object.freeze(obj);
o === obj; // true
Object.isFrozen(obj); // === true
// 现在任何改变都会失效
obj.foo = 'quux'; // 静默地不做任何事
// 静默地不添加此属性
obj.quaxxor = 'the friendly duck';
console.log(obj)
18. Object.isFrozen()
功能：判断对象是否已经被冻结
19. Object.preventExtensions()
功能：对象不能再添加新的属性。可修改，删除现有属性，不能添加新属性。
var obj = {
name :'lilei',
age : 30 ,
sex : 'male'
}
obj = Object.preventExtensions(obj);
console.log(obj); // {name: "lilei", age: 30, sex: "male"}
obj.name = 'haha';
console.log(obj) // {name: "haha", age: 30, sex: "male"}
delete obj.sex ;
console.log(obj); // {name: "haha", age: 30}
obj.address = 'china';
console.log(obj) // {name: "haha", age: 30}
20. Object.isExtensible()
功能：判断对象是否是可扩展的，Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）
21. Object.seal()
功能：Object.seal() 方法可以让一个对象密封，并返回被密封后的对象。密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会失败或抛出TypeError 异常. 不会影响从原型链上继承的属性。但 __proto__ ( ) 属性的值也会不能修改。
var obj = {
prop: function () {},
foo: "bar"
};
// 可以添加新的属性,已有属性的值可以修改,可以删除
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;
var o = Object.seal(obj);
assert(o === obj); // true
assert(Object.isSealed(obj) === true); // true
// 仍然可以修改密封对象上的属性的值.
obj.foo = "quux";
// 但你不能把一个数据属性重定义成访问器属性.
Object.defineProperty(obj, "foo", { get: function() { return "g"; } }); // 抛出TypeError异常
// 现在,任何属性值以外的修改操作都会失败.
obj.quaxxor = "the friendly duck"; // 静默失败,新属性没有成功添加
delete obj.foo; // 静默失败,属性没有删除成功
// ...在严格模式中,会抛出TypeError异常
function fail() {
"use strict";
delete obj.foo; // 抛出TypeError异常
obj.sparky = "arf"; // 抛出TypeError异常
}
fail();
// 使用Object.defineProperty方法同样会抛出异常
Object.defineProperty(obj, "ohai", { value: 17 }); // 抛出TypeError异常
Object.defineProperty(obj, "foo", { value: "eit" }); // 成功将原有值改变
22. Object.isSealed()
判断一个对象是否被密封
216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
