[问题探讨]js对象(Object)方法汇总

需求：

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的对象, 参数, …)

  <script>
  /*window*/
  class Enemy{
   constructor(fname,speed){
    this.fname=fname;
    this.speed=speed;
   }
   fly(){
    console.log(this.fname+"以时速"+this.speed+"飞行");
   }
  }
  class Plane extends Enemy{
   constructor(fname,speed,score){
    //this->f16
    super(fname,speed);//super-->Enemy的构造函数
    this.score=score;
   }
   getScore(){
    console.log("击落"+this.fname+"得"+this.score+"分");
   }
   //Object.setPrototypeOf(Plane.prototype,Enemy.prototype)
  }
  var f16=new Plane("F16",1000,5);
  f16.fly();
  f16.getScore();
  // 模仿Plane类型，实现Bee类型
  class Bee extends Enemy{
   constructor(fname,speed,award){
    super(fname,speed);
    this.award=award;
   }
   getAward(){ //这里时定义方法不是对象
    console.log("击落"+this.fname+"得奖励"+this.award);
   }
  }
   //Object.setPrototypeOf(Bee.prototype,Enemy.prototype)
   var Bee_1=new Bee("Bee_1",1200,"一条命");
   Bee_1.fly();
   Bee_1.getAward();
 </script> //执行结果：
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
   }
})

点击此超链接跳转到Tom哥的博文分类和索引页面
Tom哥的博客博文分类和索引页面地址：https://blog.csdn.net/tom_wong666/article/details/84137820