ES6新增Object方法

编程入门行业动态更新时间:2024-10-26 16:32:22

1. Object.create(proto,[propertiesObject])

描述：创建一个新对象，使用现有对象来提供新建对象的__proto__

参数：
proto:新建对象的__proto__指向的原型对象
[propertiesObject]：一个对象，该对象的属性类型参照Object.defineProperties()的第二个参数

返回值：一个新对象，带着指定的原型对象和属性。

var o;// 创建一个原型为null的空对象
o = Object.create(null);o = {};
// 以字面量方式创建的空对象就相当于:
o = Object.create(Object.prototype);o = Object.create(Object.prototype, {// foo会成为所创建对象的数据属性foo: {writable:true,configurable:true,value: "hello"},// bar会成为所创建对象的访问器属性bar: {configurable: false,get: function() { return 10 },set: function(value) {console.log("Setting `o.bar` to", value);}}
});function Constructor(){}
o = new Constructor();
// 上面的一句就相当于:
o = Object.create(Constructor.prototype);
// 当然,如果在Constructor函数中有一些初始化代码,Object.create不能执行那些代码// 创建一个以另一个空对象为原型,且拥有一个属性p的对象
o = Object.create({}, { p: { value: 42 } })// 省略了的属性特性默认为false,所以属性p是不可写,不可枚举,不可配置的:
o.p = 24
o.p
//42o.q = 12
for (var prop in o) {console.log(prop)
}
//"q"delete o.p
//false//创建一个可写的,可枚举的,可配置的属性p
o2 = Object.create({}, {p: {value: 42,writable: true,enumerable: true,configurable: true}
});

2. Object.is(value1,value2)

描述：判断两个值是否相同
参数：两个要比较的值
返回值：一个布尔值

		都是undefined都是null都是true或false都是长度相同字符串且字符按相同顺序排列都是相同对象(相同的地址)都是数字且都是+0都是-0都是NaN(算数运算中只要分母为0就是NaN)都是Infinity都是非0且非NaN且为同一个值

与== 运算不同。 == 运算符在判断相等前对两边的变量(如果它们不是同一类型) 进行强制转换 (这种行为的结果会将 “” == false 判断为 true), 而 Object.is不会强制转换两边的值。

与=== 运算也不相同。 === 运算符 (也包括 == 运算符) 将数字 -0 和 +0 视为相等，而将Number.NaN 与NaN视为不相等.

3. Object.assign(target,…source)

描述：将所有可枚举的属性键值对从一个或者多个源对象中分配到目标对象
参数：
target: 目标对象
…source:其他对象
返回值：执行方法后的target
注：这个方法调用后会改变target本身，并且返回target

1.合并具有相同属性的对象会覆盖属性值
const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }2.继承属性不可复制
var obj = {'name':'lisi'};
var obj2 = {age:12};
Object.setPrototypeOf(obj,obj2);
console.log(obj.age);		//12
var obj3 = Object.assign({},obj);
console.log(obj3.age);		//undefined3.不可枚举的属性不可复制
const obj = Object.create({foo: 1}, { // foo 是个继承属性。bar: {value: 2  // bar 是个不可枚举属性。},baz: {value: 3,enumerable: true  // baz 是个自身可枚举属性。}
});const copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }4.原始类型会被包装为对象
const v1 = "abc";
const v2 = true;
const v3 = 10;
const v4 = Symbol("foo")const obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// 原始类型会被包装，null 和 undefined 会被忽略。
// 注意，只有字符串的包装对象才可能有自身可枚举属性。
console.log(obj); // { "0": "a", "1": "b", "2": "c" }5.assign是浅拷贝，当源对象中有引用类型的属性值时，复制的是引用地址
let obj1 = {a:0 , b:{c:0}}
let obj2 = Object.assign({},obj1);
console.log(obj2);  //{ a: 0, b: { c: 0 } }obj1.a = 1;
console.log(obj1);  //{ a: 1, b: { c: 0 } }
console.log(obj2);  //{ a: 0, b: { c: 0 } }obj2.a = 2;
console.log(obj1);  //{ a: 1, b: { c: 0 } }
console.log(obj2);  //{ a: 2, b: { c: 0 } }obj2.b.c = 3;
console.log(obj1);  //{ a: 1, b: { c: 3 } }
console.log(obj2);  //{ a: 2, b: { c: 3 } }// Deep Clone
obj1 = { a: 0 , b: { c: 0}};
let obj3 = JSON.parse(JSON.stringify(obj1));
obj1.a = 4;
obj1.b.c = 4;
console.log(JSON.stringify(obj3));	// { a: 0, b: { c: 0}}

4. Object.setPrototypeOf(obj,prototype)

描述：设置对象的__proto__指向的原型对象，让obj继承prototype

参数：
obj：要设置的目标对象
prototype：该对象的新原型(一个对象或 null).

返回值：这个对象obj本身

5. Object.getPrototypeOf(object)

描述：获取对象的原型对象

参数：
object：指定对象

返回值：给定对象的原型。如果没有继承属性，则返回 null 。

JavaScript中的 Object 是构造函数（创建对象的包装器）。
一般用法是：
var obj = new Object();所以：
Object.getPrototypeOf( Object );               // ƒ () { [native code] }
Object.getPrototypeOf( Function );             // ƒ () { [native code] }Object.getPrototypeOf( Object ) === Function.prototype;        // trueObject.getPrototypeOf( Object )是把Object这一构造函数看作对象，
返回的当然是函数对象的原型，也就是 Function.prototype。正确的方法是，Object.prototype是构造出来的对象的原型。
var obj = new Object();
Object.prototype === Object.getPrototypeOf( obj );              // trueObject.prototype === Object.getPrototypeOf( {} );               // true