【JS面向对象编程常用方法】

Object.defineProperty()： 

在对象上直接定义个新的属性，或者修改现有的属性，并返回此对象；

/**
* Object.defineProperty()
* @param 第一个参数为对象 obj
* @param 第二个参数为属性 name
* @param 第三个参数为数据属性
* @return 目标对象
*/
let obj = {}
Object.defineProperty(obj,'d',{
      value: 4
})

Object.assign(): 

将所有可枚举属性从一个或多个源对象分配到目标对象，并返回目标对象。可用于对象浅拷贝；

/**
* Object.assign()
* @param target:目标对象
* @param source:源对象
* @return 目标对象
*/
const obj = {username:'张三',age:30}
const obj2= {city:'河北保定'}
const user = Object.assign(obj,obj2)

Object.create(): 

创建一个新对象，使用现有的对象来提供新创建对象的原型。

/**
* Object.create()
* @param proto:新创建对象的原型对象
* @param [propertiesObject]:可选，对象的属性的描述
* @return 一个新对象，带着指定的原型对象和属性
*/
let obj = {
    name:'张三',
    print:function(){
        console.log(`我是${this.name}`)
    }
}
let user = Object.create(obj);
console.log(user);
console.log(user.__proto__);
console.log(user.name);

Object.is()

判断两个值是否为同一个值，它与==或===两个运算符都不一样，Object.is()不会强制转换两边的值，并且===运算符将数字-0和+0视为相等，而Object.is()则不是，它更加严格。

/**
* Object.is()
* @param val:被比较的第一个值
* @param val2:被比较的第二个值
* @return 一个布尔类型标识两个参数是否是同一个值
*/
console.log(Object.is(undefined,undefined)) ==>true
console.log(Object.is(+0,-0)) ==>false
console.log(Object.is(NaN,NaN))==>true

Object.getPrototypeOf() 

获取实例的隐式原型(proto)的指向 

/**
* Object.getPrototypeOf()
* @param obj:要实例对象
*/
function Person(username){
    this.username = username;
}
var p = new Person('张三');
console.log(Object.getPrototypeOf(p))

Object.setPrototypeOf() 

设置一个指定的对象的原型(即内部[[Prototype]]属性到另一个对象或null。

/**
* Object.setPrototypeOf()
* @param obj:要设置其原型的对象
* @param prototype:该对象的新原型(一个对象或null)
*/
var obj1={name:'name1'}
var obj2={name2:'name2'}
​
Object.setPrototypeOf(obj1,obj2)
console.log(obj1)
console.log(obj1.name2)

Object.keys(): 

返回一个由一个给定对象的自身可枚举属性组成的数组，这些属性的顺序与手动遍历该对象属性时一致；

/**
* Object.keys()
* @param obj:要返回其枚举自身属性的对象
* @return 一个表示给定对象的所有可枚举属性的字符串数组
*/
let obj = {
    name:'张三',
    print:function(){
        console.log(`我是${this.name}`)
    }
}
console.log(Object.keys(obj));

Object.values(): 

返回一个给定对象自身的所有可枚举属性值的数组；

/**
* Object.values()
* @param obj:被返回可枚举属性值的对象
* @return 一个包含对象自身的所有可枚举属性值的数组
*/
let obj = {
    name:'张三',
    print:function(){
        console.log(`我是${this.name}`)
    }
}
console.log(Object.values(obj));

Object.entries(): 

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

/**
* Object.entries()
* @param obj:可以返回其可枚举属性的键值对的对象
* @return 给定对象自身可枚举属性的键值对数组
*/
let obj = {
    name:'张三',
    print:function(){
        console.log(`我是${this.name}`)
    }
}
console.log(Object.entries(obj));

Object.prototype.toString()

返回一个表示该对象的字符串；

/**
* Object.prototype.toString()
* @return 一个表示该对象的字符串
*/

call 

改变对象的this指向，使之指向两一个对象。

/***
* call:改变对象的this指向，使之指向两一个对象
* @param obj : 要传入的对象
* @param 参数以逗号分隔开输入
*/
function Anmial(){
    console.log(this)
}
function Cat(){
​
}
var obj = {}
Anmial.call();
Anmial.call(null);
Anmial.call(undefined);
Anmial.call(1);
Anmial.call('');
Anmial.call(true);
Anmial.call(Cat);
Anmial.call(obj);

apply 

改变对象的this指向，使之指向两一个对象。

/***
* apply:改变对象的this指向，使之指向两一个对象
* @param obj : 当前对象
* @param 参数以数组方式输入
*/
function Anmial(){
    console.log(this)
}
function Cat(){
​
}
var obj = {}
Anmial.apply();
Anmial.apply(null);
Anmial.apply(undefined);
Anmial.apply(1);
Anmial.apply('');
Anmial.apply(true);
Anmial.apply(Cat);
Anmial.apply(obj);

call和apply区别：

接受参数方式不同，apply接受两个参数，第一个参数为this,第二个参数为参数列表；

function Anmial(name){
    this.name = name;
    this.getName = function(){
        return this.name;
    }
}
function Cat(name){
    Anmial.call(this,name);
    //Anmial.apply(this,[name])
}
var cat = new Cat('小猫');
console.log(cat.getName())

for/in 

使用for/in遍历对象属性

const obj = {
  name: "张三",
  age: 10
};
for (let key in obj) {
  console.log(key, obj[key]);
}

for/of

for/of用于遍历迭代对象，不能直接操作对象。可以通过Object对象的keys()返回的是迭代对象。

const obj = {
  name: "张三",
  age: 10
};
for (const key of Object.keys(obj)) {
  console.log(key);
}

获取所有对象属性

const obj = {
  name: "张三",
  age: 10
};
for (const key of Object.values(obj)) {
  console.log(key);
}