JavaScript中常用对象方法总结

Object.create()创建对象

该方法用于创建一个新对象，新建对象具有指定原型和若干个指定属性；

Object.create(proto)
Object.create(proto, propertiesObject)

 该方法接收两个参数，第一个参数是新建对象的指定原型对象，第二个参数可选，表示新建对象的某些属性；第二个参数要传入一个对象，对象内容是键值对，配置有四个参数，分别表示如下：

• value：属性值
• enumerable: 是否可被枚举（可遍历）
• writable: 是否可被重写（改变）
• configrable：是否可被更改和删除，以及除value和writable特性外的其它特性是否可以被修改。

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
obj1.intro(); // my name is 小明
 
var obj2 = Object.create(obj1, {
  'EnglishName': {value: 'xiaoMing', writable: false, configurable: false, enumerable: true },
  'hobby': {value: 'playing', writable: true, configurable: false, enumerable: false }
})
obj2.intro() // my name is 小明
 
console.log(obj2.EnglishName); // xiaoMing
 
obj2.EnglishName = 'xiaoHong'
 
console.log(obj2.EnglishName); // xiaoMing,未被重写
 
for(var item in obj2) {
console.log(item); // EnglishName name age intro    hooby并未被遍历出来
}
 
console.log(delete obj2.age); // true
 
console.log(delete obj2.hobby); // false 删不掉hobby属性

补充：

1. 使用对象直接创建的属性，上述四种参数默认为true
2. 使用Object.create() / Object.defineProperty() / Object.defineProperties()创建出来的属性，上述四种参数默认为false

Object.defineproperty()修改对象旧属性或定义对象新属性

该方法可以对对象已有的属性进行修改，或增加新的属性

Object.defineProperty(obj, prop, descriptor)

该方法接收三个参数，分别是要定义属性的对象 / 要定义的属性名称 / 属性描述对象（该对象依然是传入上述四种配置）

        var obj1 = {
            name: '小明',
            age: 13,
            intro: function() {
                console.log(`my name is ${this.name}`);
            }
        }
        Object.defineProperty(obj1, 'name', {
            value: '小红',
            configurable: false
        })
        console.log(obj1); // {name: '小红', age: 13, intro: ƒ}
        console.log(delete obj1.name); // false

Object.defineproperties()修改对象多个旧属性或定义对象多个新属性

该方法与上面那个方法使用方式相似，只不过可以对多个属性进行修改或新增；

Object.defineProperties(obj, props)

该方法传入两个参数，其中第一个参数依然是要定义或修改属性的对象；第二个参数定义属性描述符对象（上述四个参数），分别以对象的形式传入，属性做键名~

        var obj1 = {
            name: '小明',
            age: 13,
            intro: function() {
                console.log(`my name is ${this.name}`);
            }
        }
        Object.defineProperties(obj1, {
            'name': {
                value: '小红',
                writable: false
            },
            'englishName': {
                value: 'Red',
                enumerable: false
            }
        })
        console.log(obj1); // {name: '小红', age: 13, englishName: 'Red', intro: ƒ}

Object.getOwnPropertyDescriptor()获取某自有属性的属性描述对象

该方法用于获取对象中某个自有属性（非继承得来）的属性描述对象；

Object.getOwnPropertyDescriptor(obj, prop)

该方法传入两个参数，第一个参数是要查找的目标对象，第二个参数是目标对象内自有属性名称；

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
var namepro = Object.getOwnPropertyDescriptor(obj1, 'name');
console.log(namepro); // { configurable: true enumerable: true value: "小明" writable: true }

Object.getOwnPropertyDescriptors()获取对象所有自身属性的属性描述对象

该方法用于获取某对象上所有自身属性（非继承）的属性描述对象，

Object.getOwnPropertyDescriptors(obj)

只有一个参数，表示要查找的目标对象，如果没有任何自身属性，则返回一个空对象；

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
var pro = Object.getOwnPropertyDescriptors(obj1);
console.log(pro); 

Object.getOwnPropertyNames()获取对象所有自有属性

该方法获取对象上所有的自由属性（不包含继承得来的属性和Symbol属性）；

Object.getOwnPropertyNames(obj)

 传入一个目标对象作为参数；返回一个字符串数组；

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
var obj2 = Object.create(obj1, {
  'EnglishName':  {
    value: 'xiaoMing',
    enumerable: false
  },
  'class': {
    value: '四年级',
    configurable: false
  }
});
console.log(Object.getOwnPropertyNames(obj2)); //  ['EnglishName', 'class'] 继承属性name，age，intro并未获取到

Object.getOwnPropertySymbols()获取对象的所有 Symbol 属性

该方法用于获取某对象中所有 Symbol 属性，返回一个数组；

Object.getOwnPropertySymbols(obj)

var obj = {};
var a = Symbol("a");
obj[a] = "localSymbol";
obj.name = '小明'
console.log(Object.getOwnPropertySymbols(obj)); // [Symbol(a)]

Object.setPrototypeOf()设置一个指定的原型对象

该方法用于为某对象设置一个指定的原型对象，即Prototype

Object.setPrototypeOf(obj, prototype)

传入两个参数，第一个参数是要设置的对象，第二个参数表示要指定的新原型（Prototype）

如果第一个参数不是一个对象，则该方法啥也不做；

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
var obj2 = {}
Object.setPrototypeOf(obj2, obj1)
console.log(obj2.name); //  小明
obj2.intro() // my name is 小明

Object.getPrototypeOf()获取某对象的原型对象prototype

该方法返回指定对象的对象原型prototype

Object.getPrototypeOf(obj)

只传入一个参数，即目标对象，若该目标对象没有继承属性，则返回null

function Obj() {
 
}
let obj = new Obj()
console.log(Object.getPrototypeOf(obj) === Obj.prototype) // true
const prototype1 = {};
const object1 = Object.create(prototype1);
 
console.log(Object.getPrototypeOf(object1) === prototype1); // true

Object.assign()合并对象

该方法用于将源对象(sources)的所有可枚举的自有属性（不是通过继承得来的属性）复制到目标对象(target)上；

返回合并后的对象target；

Object.assign(target, ...sources)

若源对象与目标对象具有相同的key，则目标对象中的属性将会被源对象中的属性覆盖；

该方法属于浅拷贝；

Object.is()

该方法用于比较两个值是否严格相等，与严格相等运算符===的行为基本一致，返回布尔值；但是在处理NaN和-0/+0o有差异

Object.is(value1, value2); // value1和value2是要比较的两个值

console.log(Object.is(1, 1)) // true
console.log(Object.is(NaN, NaN)) // true
console.log(Object.is(+0, -0)) // false
console.log(1 === 1) // true
console.log(NaN === NaN) // false
console.log(+0 === -0) // true
console.log(Object.is([], [])); // false
console.log([] === []); // false

Object.keys()返回自身可枚举键名

该方法返回自身（不含继承）的所有可枚举（enumerable）属性的键名

Object.keys(obj) // obj要遍历的对象

该方法返回一个由键名组成的数组 

var obj1 = {
  name: '小明',
  age: 13,
  sing: function() {
     console.log('he can sing ~');
  }
}
console.log(Object.keys(obj1)); // ['name', 'age', 'sing']

Object.values()返回自身可枚举键值

该方法返回自身（不含继承）的所有可枚举（enumerable）属性的键值；

Object.values(obj) // obj为要遍历的对象

该方法返回由键值组成的数组

var obj1 = {
  name: '小明',
  age: 13,
  sing: function() {
    console.log('he can sing ~');
  }
}
console.log(Object.values(obj1)); // ['小明', 13, ƒ]

Object.entries()返回自身可枚举键值对

该方法返回自身（不含继承）的所有可枚举（enumerable）属性的键值对；

Object.entries(obj) // obj

该方法返回由键值对组成的数组；

var obj1 = {
  name: '小明',
  age: 13,
  sing: function() {
    console.log('he can sing ~');
  }
}
console.log(Object.entries(obj1)); // [ ['name', '小明'], ['age', 13], ['sing', ƒ] ]

 obj.hasOwnProperty()判断对象上是否存在某自有属性

该方法用于判断对象obj自身属性中是否具有指定的属性，返回布尔值

obj.hasOwnProperty(prop)

所传参数为某属性

var obj1 = {
  name: '小明',
  age: 13,
  intro: function() {
    console.log(`my name is ${this.name}`);
  }
}
var obj2 = {}
Object.setPrototypeOf(obj2, obj1)
console.log(obj1.hasOwnProperty('name')); // true
console.log(obj2.hasOwnProperty('name')); // false

prototypeObj.isPrototypeOf（）判断某对象是否在另一个对象的原型链上

该方法用于测试一个对象是否存在于另一个对象的原型链上，返回布尔值

prototypeObj.isPrototypeOf(object)

其中object是要测试的目标对象，prototypeObj是另一个对象的原型链；

var o = {};
function Person(){
 
};
var p1 = new Person(); //继承自Person原来的原型Person.prototype
Person.prototype = o;
var p2 = new Person(); //继承自o
console.log(o.isPrototypeOf(p1)); // false o是不是p1的原型
console.log(o.isPrototypeof(p2)); // true  o是不是p2的原型
 
console.log(Object.prototype.isPrototypeOf(p1)); // true
console.log(Object.prototype.isPrototypeOf(p2)); // true
 
// p1的原型链结构是p1 => 原来的Person.prototype => Object.prototype => `null``
// p2的原型链结构是p2 => o => Object.prototype => null
// p1和p2都拥有Object.prototype, 他们都在Object.Prototype的原型链上