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