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(); // 对象合并（浅拷贝）---源对象的任何变化，都会反映到目标对象上面。

对象的理解/定义

所有事物都是对象：字符串、数值、数组、函数...
内建对象，比如 String、Date、Array 等等。
定义1：对象就是无序的属性集合；
定义2：对象只是带有属性和方法的特殊数类型。
定义3：是一组键值对，值可以是数据或函数。
js 允许自定义对象
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.hasOwnProperty('age');

1.4删除属性
delete

1.5 对象都有的3个属性

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

2.对象的方法

对象都有的方法：

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

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

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

new法
对象字面量法

2.5 object.create(null);

工厂方式

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

构造函数

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

原型模式
5.1 可通过对象实例访问原型中的值，但不能通过实例改写原型中的值。在实例中创建该某个属性，该属性会屏蔽原型中同名的属性，或者说阻止访问原型中的属性，而不是修改。
5.2 delete 可删除实例中的属性，让我们重新访问原型中的属性。
5.4 实例的指针仅指向原型，而不是构造函数。添加是可以的。
组合使用构造函数和原型模式用构造函数定义实例属性原型定义方法和共享的属性
动态原型模式
寄生构造函数模式；
稳妥构造函数模式
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})`
     }
}

对象与实例的关系

isPrototypeOf()

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

hasOwnProperty()

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

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对象