原创声明
本文系作者辛苦码字所得，欢迎分享和转载，但请在明显位置注明作者的如下信息：
笔名：来碗鸡蛋面
主页：https://www.jianshu.com/u/4876275b5a73
邮箱：[email protected]
CSDN ID：tom_wong666
需求：
js对象(Object)方法汇总
索引：
一，对象操作方法：
1，Object.keys(obj)--键；
2，Object.values(obj)--值；
3，Object.entries(obj)--键+值；
4，Object.assign(target,...resource)--合并对象可遍历属性;
5，Object.is(value1,value2)--判断是否相等;
二，面向对象：
1，封装；
2，继承--Object.defineProperties给原型对象增加方法；
3，继承--Object.setPrototypeOf设置某个子实例的原型为某个对象；
4，继承--构造函数.prototype=ob修改构造函数的原型对象；
5，继承--构造函数.call;
6，多态--重写Obj.方法名=function；
7，多态--重载；
8，对象的数据属性；
9，Object.getOwnPropertyDescriptor获取对象的数据属性；
10，Object.defineProperty修改数据属性的四大特性；
11，对象的防篡改--数据属性的保护；
12，继承特例---Object.create--通过原型对象直接创造实例；
正文：
一，对象操作方法
1，Object.keys(obj)
(1)作用：获取对象的可遍历属性(键)；
(2)语法：Object.keys(obj);
(3)语法解释：obj指代某个对象实例；
(4)返回值：返回对象的可遍历属性(键)组成的数组；
(5)示例代码:
const obj={name:'tom',age:30};
const res=Object.keys(obj);
console.log(res);// ["name", "age"]
2，Object.values(obj)
(1)作用：获取对象的可遍历属性值(值)；
(2)语法：Object.values(obj);
(3)语法解释：obj指代某个对象实例；当obj为字符串时，会返回各个字符组成的一个数组；
(4)返回值：返回对象的可遍历属性值(值)组成的数组；
(5)示例代码：
const obj={name:'tom',age:30};
const res=Object.values(obj);
console.log(res);// ["tom", 30]
// 当参数为字符串的情况
const str='Hello';
const strRes=Object.values(str);
console.log(strRes);// ["H", "e", "l", "l", "o"]
3，Object.entries(obj)
(1)作用：获取对象的可遍历键值对；
(2)语法：Object.entries(obj);
(3)语法解释：obj指代某个对象实例；
(4)返回值：返回对象的可遍历键值对组成的数组；
(5)示例代码：
const obj={name:'tom',age:30};
const res=Object.entries(obj);
console.log(res)；// [['name','tom'],['age',30]]
4，Object.assign
(1)作用：用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。
(2)语法：Object.assign(targetObject,object1,object2...);
(3)语法解释：targetObject目标对象，后面跟多个对象是值被复制的源对象；
(4)返回值：返回增加值以后的目标对象；
(5)实例代码：
// 单组示例
const obj1={a:1,b:2};
const obj2={c:3,d:4};
const obj=Object.assign(obj1,obj2);
console.log(obj);// {a: 1, b: 2, c: 3, d: 4}
console.log(obj===obj1);// true
// 多组示例
const obj3={e:5,f:6};
const obj4={g:7,h:8};
const objMore=Object.assign(obj,obj1,obj2,obj3,obj4);
console.log(objMore);// {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8}
console.log(objMore===obj); // true
5，Object.is()
(1)作用：判断两个值是否是相同的值；
(2)语法：Object.is(val1,val2);
(3)语法解释:val1，val2需要比较的值；判断规则如下图：
(4)返回值：比较结果布尔值；
(5)示例代码：
const obj1={a:1};
const obj2={a:1};
Object.is(obj1,obj2);// false
Object.is('a','a');// true
二，面向对象
1，封装=>对象直接量，new Object()和构造函数
(1)作用：封装对象；
(2)语法：{},new,function;
(3)语法解释:见注释；
(4)返回值：无；
(5)实例代码：
// 将某个事物封装为对象---对象直接量
var obj={
属性名: 属性值,
... : ...,
方法名: function(){
... this.属性名 ...
},
...
}
// 将某个事物封装为对象---new
var obj=new Object();
obj.属性名=值;
obj.方法名=function(){};
// 将某一类对象定义为构造函数，供批量制造用
function 类型名(属性参数列表){
this.属性名=属性参数;
... = ... ;
this.方法名=function(){
... this.属性名 ...
}
}
2，继承=>Object.defineProperties(obj, props)=>给原型对象增加方法待子级实例调用
(1)作用：(通过对象实例指向)给对象的原型对象添加属性/方法；
(2)语法：Object.defineProperties(obj, props);
(3)语法解释：obj指代某个对象实例，props指代要添加到原型对象中的属性/方法；
(4)返回值：无；
(5)示例代码：
// 通俗说明:Object.defineProperties(obj, props)===
// Obj(构造函数).prototype.方法名/属性名=props;
// 普通示例
var obj = {};
Object.defineProperties(obj, {
'property1': {
value: true,
writable: true
},
'property2': {
value: 'Hello',
writable: false
}
});
// vue示例
Object.defineProperties(Vue.prototype, {
$http: {
value: axios,
writable: false
},
$api $api: {
value: API,
writable: false
}
})
3,继承=>Object.setPrototypeOf=>让某个子级对象实例直接继承某个对象作为其原型对象
(1)作用：(通过对象实例指向)改变某个对象实例的原型对象；
(2)语法：Object.setPrototypeOf(obj, prototype)；
(3)语法解释：obj指代某个对象实例，prototype指代该对象实例的新原型(一个对象或者null)；
(4)返回值：无；
(5)实例代码：
// 通俗说明：Object.setPrototypeOf(obj, prototype)===
// obj._proto_=prototype;
// 构造函数
function Student(sname,sage){
this.sname=sname;
this.sage=sage;
}
// 新实例
const hmm=new Student('hmm',19);
hmm.bal;// undefined
// 新对象(后续作为原型对象用的)
const superFather={ bal:10000000000, car:"infiniti" };
// hmm的原型对象设置为superFather
Object.setPrototypeOf(hmm,superFather);
hmm.bal;// 10000000000
4,继承=>构造函数.prototype=obj=>重新定义构造函数的原型对象为某个对象，待所有实例继承；
(1)作用:重新定义原型对象；
(2)语法：构造函数.prototype=obj；
(3)语法解释：见注释；
(4)返回值：无；
(5)实例代码：
// 富有对象
var father={ bal:10000000000, car:"infiniti" };
function Student(sname,sage){
this.sname=sname;
this.sage=sage;
}
// 设置student构造函数的原型对象为富有对象
Student.prototype=father;
// 为原型对象增加方法
// 方法一
Student.prototype.intr=function(){
console.log("I'm "+this.sname+", I'm "+this.sage);
}
// 方法二
Object.defineProperties(Student.prototype, {
intr:{
value:function(){
console.log("I'm "+this.sname+", I'm "+this.sage);
},
writable:false,
}
})
var lilei=new Student("Li Lei",18);
var hmm=new Student("Han Meimei",19);
5，继承=>构造函数.call(this,参数1，参数2.......)=>子级构造函数调用母级构造函数
function Enemy(fname,speed){
this.fname=fname;
this.speed=speed;
}
Enemy.prototype.fly=function(){
console.log(this.fname+"以时速"+this.speed+"飞行");
}
function Plane(fname,speed,score){
//this->f16
Enemy.call(this,fname,speed);//this->Plane的this
this.score=score;
}
Plane.prototype.getScore=function(){
console.log("击落"+this.fname+"得"+this.score+"分");
}
Object.setPrototypeOf(Plane.prototype,Enemy.prototype)
var f16=new Plane("F16",1000,5);
f16.fly();
f16.getScore();
6，多态=>Obj.方法名=function=>重写子级实例修个某个特定方法实现多态
(1)在对象实例本级定义父级同名方法，覆盖父级方法；
(2)语法：Obj.方法名=function(){}；
(3)语法解释：Obj指代某个对象实例
(4)返回值：无；
(5)实例代码：
// 定义lilei对象
var lilei={
sname:"Li Lei",
sage:11,
intr:function(){
console.log("I'm "+this.sname+", I'm "+this.sage);
},
}
// 调用对象的toString方法
lilei.toString();// "[object Object]"
// 重写toString方法
lilei.toString=function(){
return "{ sname:"+this.sname+", sage:"+this.sage+" }";
}
// 测试重写后的结果
lilei.toString();// "{ sname:Li Lei, sage:11 }"
构造函数调用构造函数的方法
函数.call(替换this的对象, 参数, ...)
//执行结果：
F16以时速1000飞行
击落F16得5分
Bee_1以时速1200飞行
击落Bee_1得奖励一条命
7，多态=>重载：通过参数让同一个函数具有不同的作用。
8，对象的数据属性，实际存储属性值的属性：
value: 保存属性值,
writable: 控制是否可修改,
enumerable: 控制是否可被for in遍历,
configurable:
1，控制是否可删除该属性；2，控制是否可修改前两个特性；
3，特点，这个属性不可逆；
9，Object.getOwnPropertyDescriptor获取一个属性的四大特性:
var obj=Object.getOwnPropertyDescriptor(obj, "属性名")
10，Object.defineProperty修改数据属性的四大特性：
Object.defineProperty(obj, "属性名", {
特性: bool,
... : ... ,
})
11,对象的防篡改：
// 防扩展: 禁止添加新属性
Object.preventExtensions(obj)
// 对象是否是可扩展的
Object.isExtensible()
// 密封: 在禁止扩展同时禁止删除现有属性
Object.seal(obj)
// 对象是否是被密封的
Object.isSealed(obj)
// 冻结: 在密封基础上，禁止修改属性的值
Object.freeze(obj)
// 对象是否是被冻结的
Object.isFrozen(obj)
12，Object.create，仅基于一个现有父对象，创建子对象，并继承父对象
var child=Object.create(father,{
//同defineProperties中的格式
属性名：{
value:"LV",
writable:true,
enumerable:true,
configurable:false
}
})