對象小總結
javascript中常見的原有對象有以下幾種:
（開頭都是大寫字母--構造函數的名字也要求開頭大寫）
Object對象
Array對象
包裝對象和Boolean對象
Number對象
String對象
Math對象
Date對象
RegExp對象
JSON對象
console對象
屬性描述對象
1.對象（小寫object）是JavaScript的核心概念。JavaScript的所有數據都可以被視為對象。
2.簡單說，所謂對象，就是一種無序的數據集合，由若干個“鍵值對”（key-value）構成。
3.所有全局變量都是頂層對象(瀏覽器的頂層對象就是window對象)的屬性
4.對象的每一個“鍵名”又稱為“屬性”它的“鍵值”可以是任何數據類型。如果一個屬性的值為函數，通常把這個屬性稱為“方法”，它可以像函數那樣調用。
5.所謂“屬性”，就是對象的狀態；所謂“方法”，就是對象的行為（完成某種任務）
6.歸屬對象的變量是屬性,歸屬對象的函數是方法.
Object對象實例的自定義方法:
var o = new Object();
o.valueOf = function (){
return 2;
};
調用:o.valueOf();
Object對象實例 的自定義屬性:
var o = new Object();
o.valueOf = 56;
**7.對象的所有鍵名都是字符串,所以加不加引號都可以
var o = {
p1: 'Hello',
p2: 'World'
};
8.上面代碼中，大括號就定義了一個對象，它被賦值給變量o。這個對象內部包含一個鍵值對（又稱為“成員”），p是“鍵名”（成員的名稱），字符串Hello World是“鍵值”（成員的值）。鍵名與鍵值之間用冒號分隔。如果對象內部包含多個鍵值對，每個鍵值對之間用逗號分隔。
9.對象的生成方法，通常有三種方法。以Object對象為例除了像上面那樣直接使用大括號生成{}，還可以用new命令生成一個Object對象的實例(解釋：Object本身也是一個構造函數可以用new生成實例對象，這個對象是Object型對象)，或者使用Object.create方法生成，都是等價的。
var o1 = {};
var o2 = new Object();
var o3 = Object.create(Object.prototype);
第一種：采用對象字面量的方式生成，內部沒有調用new Object()，而是采用JSON的初始化方式，寫法比較簡潔。
第二種：采用構造函數的寫法清晰地表示了意圖
第三種：寫法一般用在需要對象繼承的場合，第三種寫法詳見《面向對象編程》一章。
明辨是非
對象是一個具有多種屬性方法的內容結構
對象實例是構造函數的具象化產品
對象實例都是對象(js中所有數據都可以被視為對象)
四種方法情況：
因此必須區分“構造函數的方法”和“對象實例的方法”
(js中對象和構造函數都要求大寫首字母，構造函數在某種角度上講等價于對象)
function Cat(name, color) {
this.name = name;
this.color = color;
this.kk=88888;
this.hui1 = function () {
console.log(this.name);
};//①在構造函數內部定義的方法是給實例用的,拍出來的實例同方法名不相等因為兩個不同的實例,主體就不等,即不能被實例共享,棄用
}
Cat.prototype.huit=function(){
console.log('大家的huit方法')
};//②在原型對象上部署的方法是給實例用的,不同實例同方法就相等,因為本質表述的都是繼承對象原型的方法,即能夠被實例共享
//注意:對象本身也能用原型身上的方法屬性,但僅限于js原生內置的,不能使用修改的內置方法與自定義方法
Cat.hui3=function(){
console.log('對象的hui3方法');
};//④在構造函數上部署的方法,是構造函數的方法相當于Cat對象的靜態方法,不能被對象實例使用
var cat1 = new Cat('大毛', '白色');
var cat2 = new Cat('二毛', '黑色');
cat1.hui2=function(){
console.log('cat1的hui2方法');
};//③自定義實例身上的同名方法，將會覆蓋通過繼承原型得來的
console.log(cat1.hui1==cat2.hui1);//驗證①
console.log(cat1.huit==cat2.huit);//驗證②
cat1.hui2();//驗證③
Cat.hui3();//驗證④
重點說一下Object對象:
1.JavaScript提供一個原生Object對象(注意起首的O是大寫)
***所有其他類型對象都繼承于Object 對象（原型鏈...Object對象→Object.prototype→null）
2.Object本身也是一個構造函數,可以用new命令生成一個Object對象實例（解釋：這個對象實例是Object型對象）
通過new Object()生成的新對象實例,與字面量的寫法{}是等價的.
所有構造函數都有一個prototype屬性,指向(是)一個原型對象.
***即凡是定義在Object.prototype對象上面的屬性和方法,將被所有實例對象共享.（Object.prototype是原型鏈的頂端）
3.Object() （沒深究）
可以將任意值轉為對象, 這個方法常用于保證某個值一定是對象。
如果參數是原始類型的值, Object函數可以將其轉為對應的構造函數生成的實例對象。
如果Object方法的參數是一個對象，它總是返回原對象。
Object 對象的靜態方法
所謂“靜態方法”是指部署在Object對象自身的方法 (構造函數身上的方法)（實例不能用）
Object.keys()，Object.getOwnPropertyNames()
Object.keys方法和Object.getOwnPropertyNames方法很相似，一般用來遍歷對象的屬性
它們的參數都是一個對象，都返回一個數組，該數組的成員都是對象自身的所有屬性名
由于JavaScript沒有提供計算對象屬性個數的方法，所以可以用這兩個方法代替
Object.keys(o).length
Object.getOwnPropertyNames(o).length
for in 遍歷對象的全部可枚舉的屬性名包括繼承來
它們三者的區別：
Object.keys方法返回 '' 自身'' '' 可枚舉'' 的屬性名
Object.getOwnPropertyNames方法返回 '' 自身'' '' 全部'' 的屬性名
for in '' 全部'' '' 可枚舉'' 的屬性名
var a = ["Hello", "World"];
Object.keys(a)// ["0", "1"]
Object.getOwnPropertyNames(a)// ["0", "1", "length"]
var o = {a: 1, b: 2, c: 3};
for (var i in o) {
console.log(i);
}
// a b c
為了在for...in循環中獲得對象自身的屬性，可以采用hasOwnProperty方法判斷一下
為了在for...in循環中獲得對象自身的屬性，可以采用hasOwnProperty方法判斷一下
var o = {a: 1, b: 2, c: 3};
for ( var name in o ) {
if ( o.hasOwnProperty(name) ) {
console.log(name);
}}
等價于Object.keys(o)；
Object.getPrototypeOf()
Object對象的又一個靜態方法↓ 返回對象實例的原型對象
Object.keys() Object. getOwnPropertyNames()
因為這個原型對象是該實例原型鏈中最內層的,所以它是獲取原型對象的標準方法
function Ft() {}
var f = new Ft ();
Object.getPrototypeOf(f) === Ft.prototype// true
Object.setPrototypeOf()[不常用]
Object對象的又一個靜態方法↓
Object.keys() Object. getOwnPropertyNames()
Object.setPrototypeOf()
接收兩個參數，第一個是現有對象，第二個是原型對象 ，并返回現有對象(它的原型對象已被設置)
var a = {x: 1};
var b = {y: 2};
var c = Object.setPrototypeOf(a, b);
c.x //1 c自身的x屬性
c.y //2 c從它的原型對象b上繼承來的y屬性
Object.create()[不常用]
Object對象的又一個靜態方法↓
Object.keys() Object. getOwnPropertyNames()
Object.create()
它接受一個對象作為參數，返回一個新對象 后者完全繼承前者的屬性方法，即原有對象成為新對象的原型
var A = {
print: function () {
console.log('hello');
}
};
var B = Object.create(A);
B.print() // hello B從它的原型對象A上繼承來的print方法
下面三種方式生成的新對象是等價的
var o1 = new Object();
var o2 = Object.create(Object.prototype);// o2的原型對象是Object.prototype,o2就是Object對象實例
var o3 = {}; // 對象字面量方法
如果想要生成一個不繼承任何屬性（比如沒有toString和valueOf方法）的對象，可以將Object.create的參數設為null
var o = Object.create(null);
o.valueOf()
// TypeError: o.valueOf is not a function
Object對象的實例方法
Object構造函數生成的對象實例首先是對象，是哪一種對象，是Object對象）
除了Object對象本身的方法，還有不少方法是部署在Object.prototype對象上的
所有對象實例 都繼承 Object.prototype的方法 原型鏈頂尖的男人
Object.prototype.valueOf()
valueOf方法的作用是返回一個對象的“值”，默認情況下返回對象本身【2個特殊：①包裝對象②new Date()】
var o = new Object();//一個Object(型)對象實例，一個構造函數生出的實例
o.valueOf() === o // true
如果自定義實例的valueOf方法，就可以得到想要的結果
var o = new Object();
o.valueOf = function (){
return 2;};
1 + o // 3
Object.prototype.toString()
toString方法的作用是返回一個對象的字符串形式，默認情況下返回類型字符串
var o1 = new Object();
o1.toString() // "[object Object]"
var o2 = [1,2,3,4];
o2.toString() // "1,2,3,4"
如果自定義實例的 toString方法，就可以得到想要的結果
var o = new Object();
o.toString = function () {
return 'hello';};
o +'world' // "helloworld"
Object.prototype.hasOwnProperty()
hasOwnProperty方法是JavaScript之中唯一一個處理對象屬性時，不會遍歷原型鏈的方法
返回一個布爾值，用于判斷某個屬性是否定義在物件自身上
var o1 = new Object();
o1.hasOwnProperty('length') // false Object對象實例
var o2 = {a:1,b:65,h:'jj'};
o2.hasOwnProperty('a') // true Object對象實例
Object.hasOwnProperty('length') // true Object對象
//對象僅可以用原型上本身自帶的方法屬性,且不支持使用修改與自定義
in 運算符
in運算符返回一個布爾值 表示一個對象是否具有某個屬性 它不區分該屬性是自身還是繼承
var o = { p: 1 };
'p' in o // true
Object.prototype.isPrototypeOf() [多情]
對象實例的isPrototypeOf方法，用來判斷X是不是實例的原型對象
由于isPrototypeOf() 對整個原型鏈上的對象都有效，因此同一個實例，可能會有多個原型對象都返回true
var o1 = {};
var o2 = Object.create(o1);
var o3 = Object.create(o2);
//原型鏈 o3→o2→o1
o2.isPrototypeOf(o3) // true
o2 是 o3的原型對象
o1.isPrototypeOf(o3) // true
o1 是 o3的原型對象
instanceof運算符 [多情]
instanceof運算符返回一個布爾值，表示對象實例是否是某個構造函數拍出來的
var v = new Vehicle();
v instanceof Vehicle // true
instanceof運算符的左邊是實例對象,右邊是構造函數
它的運算實質：檢查右邊構造函數的prototype屬性所指向的原型對象,是否在左邊對象實例的原型鏈上
v instanceof Vehicle
// 等同于
Vehicle.prototype.isPrototypeOf(v)
由于instanceof對整個原型鏈上的對象都有效，因此同一個對象實例，可能會對多個構造函數都返回true
var d = new Date();
d instanceof Date // true
d instanceof Object // true
toString()的應用：判斷數據類型
var o = {};
o.toString() // "[object Object]"
結果返回一個字符串object Object，其中第二個Object表示該值的構造函數。這是一個 比typeof運算符更準確的判斷數據類型的方法
用call調用Object.prototype.toString可以得到一個實例的構造函數
(復習：調用方法或函數一般用括號，call()調用多了一個制定this的作用)
Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"
