JS的核心 ----对象Object，面向对象编程 es5+es6

简介：
总所周知，js是面向对象的语言。
未完待续

一些汇总：

Object.create(); // 建立对象;第一个参数是这个对象的原型
Object.keys(); // 读取自身属性--遍历对象的属性，返回数组
Object.getOwnPropertyNames(); // 读取自身属性--遍历对象的属性
Object.getOwnPropertySymbols(); // 读取自身属性--遍历对象的属性
Object.values();// 读取键值，返回数组，按照属性（not键值）的大小飘絮
Object.entries();// 读取属性和键值，返回数组
Object.defineProperty(); //为对象一次定义多个属性
Object.isExtensible(); // 判断对象是否可扩展
Object.preventExtensions(obj);// 设置原对象不可配置或者禁止扩展;
Object.seal();// 设置原对象不可配置或者禁止扩展;
Object.isSealed(); // 检测对象是否封闭
Object.freeze(); // 将对象冻结；对象不可扩展， 不可配置，全部数据为只读
Object.isFrozen(); // 检测对象是否冻结
Object.getOwnPropertyDescriptor(obj,property);// 获取该属性的描述对象
Object.getPrototypeOf(p);// 查询对象的原型
Object.setPrototypeOf(); //修改原型对象
Object.isExtensible();
Object.name(); // 返回对象、函数名
Object.is(); // 比较是否相等（没有===细微差异）；+0不等于-0；NaN不等于自身
Object.assign(); // 对象合并（浅拷贝）---源对象的任何变化，都会反映到目标对象上面。

对象的理解/定义

1. 全部事物都是对象：字符串、数值、数组、函数...
2. 内建对象，好比 String、Date、Array 等等。
3. 定义1：对象就是无序的属性集合；
4. 定义2：对象只是带有属性和方法的特殊数类型。
5. 定义3：是一组键值对，值能够是数据或函数。
6. js 容许自定义对象
7. Object 结构提供了“字符串—值”的对应

1.对象的属性

1.0 属性类型：

数据属性和访问器属性

数据属性[[]]
[[Configurable]]
[[Enumerable]]
[[Writable]]
[[Value]]

访问器属性[[]]
[[Configurable]]
[[Enumerable]]
[[get]]
[[set]]

1.1 访问/读取对象的属性

经过点（.）或方括号([])运算符

1.2 枚举/遍历对象属性

（1）for...in

for...in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。

（2）Object.keys(obj)

Object.keys返回一个数组，包括对象自身的（不含继承的）全部可枚举属性（不含 Symbol 属性）的键名。

（3）Object.getOwnPropertyNames(obj)

Object.getOwnPropertyNames返回一个数组，包含对象自身的全部属性（不含 Symbol 属性，可是包括不可枚举属性）的键名。

（4）Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols返回一个数组，包含对象自身的全部 Symbol 属性的键名。

（5）Reflect.ownKeys(obj)

Reflect.ownKeys返回一个数组，包含对象自身的全部键名，无论键名是 Symbol 或字符串，也无论是否可枚举。

1.3 检测属性

hasOwnProperty(),该方法能够检测一个属性是否存在**实例**中。  返回值是 true/false  
in运算符

in操做符 :经过实例可以访问给定属性， 返回true ,无论该属性实在实例中仍是原型中。

例如： "name" in person1;  返回true/false   ;            

propertyIsEnumerable()
isPrototypeOf()

var person={fname:"Bill",lname:"Gates",age:56}; 
person.hasOwnPropertry('age');

1.4删除属性
delete

1.5 对象都有的3个属性

原型属性：o.isPrototypeOf(p);// 检测对象是不是p的的原型
类属性
可扩展性

2.对象的方法

对象都有的方法：

• Object.prototype里的对象方法
• toString();
• toLocalString();
• ValueOf()

3.建立对象/对象实例化

一共有9种方法（new法 对象字面量法 工厂方法 构造函数法 原型法 组合法 ）

1. new法
2. 对象字面量法

2.5 object.create(null);

1. 工厂方式

   function person(){var o =new Object(); *** ;return o ;}var child = haha();----缺点不知道实例和对象之间的关系

2. 构造函数

   function Person(){}  ;var person1 = new Person(); 缺点，里面的方法函数会在每一个实例中构建一遍。 都会在实例上构建一遍；就算把方法函数转移至构造函数外部，但会产生全局函数。

3. 原型模式
   5.1 可经过对象实例访问原型中的值，但不能经过实例改写原型中的值。在实例中建立该某个属性，该属性会屏蔽原型中同名的属性，或者说阻止访问原型中的属性，而不是修改。
   5.2 delete 可删除实例中的属性，让咱们从新访问原型中的属性。

   5.4 实例的指针仅指向原型，而不是构造函数。添加是能够的。

4. 组合使用 构造函数和原型模式 用构造函数定义实例属性 原型定义方法和共享的属性
5. 动态原型模式
6. 寄生构造函数模式；
7. 稳妥构造函数模式
8. es6 class类法

构造函数法 vs 工厂法：
区别：构造函数没有显示的建立对象，而是将对象的属性和方法赋值给this对象，且没有return;
好处：解决了对象的类型，可将实例标识为一种特定的类型；
自己的缺点，要么建立对象的方法时，建立全局函数。要么继续内部Function，这样会致使几个实例建立几个
例：

function Obj () {
          this.age = 18;
      }
    //   不用new
      console.log(Obj()); // undefined
    //  用new
      console.log(new Obj()); //Obj {age: 18}

Function

function Point(x, y) { // 用 构造函数建立对象的属性
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () { // 用原型建立方法
  return '(' + this.x + ', ' + this.y + ')';
};

var p = new Point(1, 2);

es6 可经过类去建立多个具备相同属性和方法的对象；

class Point{
    constructor(x,y){ // 构造方法 this关键字则表明实例对象
       this.x= x;
       this.y= y     
     }
     toString() {
         return `(${this.x},${this.y})`
     }
}

对象与实例的关系

1. isPrototypeOf()

这个方法用来判断，某个proptotype对象和某个实例之间的关系。

1. hasOwnProperty()

每一个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性究竟是本地属性，仍是继承自prototype对象的属性。

1. in运算符

in运算符能够用来判断，某个实例是否含有某个属性，无论是否是本地属性。

对象原型

读取设置对象的原型；__proto__
判断是不是这个原型：isPrototypeOf();
Object.getPrototypeOf(p);// 查询对象的原型
Object.setPrototypeOf(); //修改原型对象
super关键字

4.对象的继承

1.经过原型链的方式实现对象的继承

用obj集成obj1的属性
方法1：obj.__proto__=obj1;
方法2：var obj=Object.create(obj1);
方法3：

2.经过proxy代理的方式

3.构造函数的继承：

4.非构造函数的继承：

方法1：object();
object()函数，其实只作一件事，就是把子对象的prototype属性，指向父对象，从而使得子对象与父对象连在一块儿。

使用的时候，第一步先在父对象的基础上，生成子对象：
方法2：浅拷贝；
把父对象的属性，所有拷贝给子对象，也能实现继承
方法3：深拷贝；

5.其余

let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
//    value: 123,
//    writable: true,
//    enumerable: true,
//    configurable: true
//  }

有四个操做会忽略enumerable为false的属性。

for...in循环：只遍历对象自身的和继承的可枚举的属性。
Object.keys()：返回对象自身的全部可枚举的属性的键名。
JSON.stringify()：只串行化对象自身的可枚举的属性。
Object.assign()： 忽略enumerable为false的属性，只拷贝对象自身的可枚举的属性。

es6 对象的扩展

1.写法更加简洁，属性更加简洁

支持直接用变量、函数做为变量名为对象的属性和方法。

2.属性名表达式

3.读取对象的原型__proto__属性（先后各两个下划线），用来读取或设置当前对象的prototype对象