對象小總結(jié)

    javascript中常見的原有對象有以下幾種:

（開頭都是大寫字母--構(gòu)造函數(shù)的名字也要求開頭大寫）
Object對象
Array對象
包裝對象和Boolean對象
Number對象
String對象
Math對象
Date對象
RegExp對象
JSON對象
console對象
屬性描述對象

    1.對象（小寫object）是JavaScript的核心概念。JavaScript的所有數(shù)據(jù)都可以被視為對象。

    2.簡單說，所謂對象闯传，就是一種無序的數(shù)據(jù)集合欲虚，由若干個“鍵值對”（key-value）構(gòu)成垦藏。

    3.所有全局變量都是頂層對象(瀏覽器的頂層對象就是window對象)的屬性

    4.對象的每一個“鍵名”又稱為“屬性”它的“鍵值”可以是任何數(shù)據(jù)類型幢竹。如果一個屬性的值為函數(shù)莫换，通常把這個屬性稱為“方法”，它可以像函數(shù)那樣調(diào)用响蕴。

    5.所謂“屬性”谆焊，就是對象的狀態(tài)；所謂“方法”浦夷，就是對象的行為（完成某種任務(wù)）

    6.歸屬對象的變量是屬性,歸屬對象的函數(shù)是方法.

    Object對象實例的自定義方法:
    var o = new Object();
    o.valueOf = function (){
        return 2;
    };
    調(diào)用:o.valueOf();

    Object對象實例 的自定義屬性:
    var o = new Object();
    o.valueOf = 56;



    **7.對象的所有鍵名都是字符串,所以加不加引號都可以

    var o = {
      p1: 'Hello',
      p2: 'World'
    };       

    8.上面代碼中辖试，大括號就定義了一個對象，它被賦值給變量o劈狐。這個對象內(nèi)部包含一個鍵值對（又稱為“成員”）罐孝，p是“鍵名”（成員的名稱），字符串Hello World是“鍵值”（成員的值）肥缔。鍵名與鍵值之間用冒號分隔莲兢。如果對象內(nèi)部包含多個鍵值對，每個鍵值對之間用逗號分隔续膳。

    9.對象的生成方法改艇，通常有三種方法。以O(shè)bject對象為例除了像上面那樣直接使用大括號生成{}姑宽，還可以用new命令生成一個Object對象的實例(解釋：Object本身也是一個構(gòu)造函數(shù)可以用new生成實例對象遣耍，這個對象是Object型對象)，或者使用Object.create方法生成炮车，都是等價的。

    var o1 = {};
    var o2 = new Object();
    var o3 = Object.create(Object.prototype);

第一種：采用對象字面量的方式生成酣溃，內(nèi)部沒有調(diào)用new Object()瘦穆，而是采用JSON的初始化方式，寫法比較簡潔赊豌。
第二種：采用構(gòu)造函數(shù)的寫法清晰地表示了意圖
第三種：寫法一般用在需要對象繼承的場合扛或，第三種寫法詳見《面向?qū)ο缶幊獭芬徽隆?/p>

明辨是非

對象是一個具有多種屬性方法的內(nèi)容結(jié)構(gòu)
對象實例是構(gòu)造函數(shù)的具象化產(chǎn)品
對象實例都是對象(js中所有數(shù)據(jù)都可以被視為對象)

四種方法情況：
因此必須區(qū)分“構(gòu)造函數(shù)的方法”和“對象實例的方法”
(js中對象和構(gòu)造函數(shù)都要求大寫首字母，構(gòu)造函數(shù)在某種角度上講等價于對象)
function Cat(name, color) {
this.name = name;
this.color = color;
this.kk=88888;
this.hui1 = function () {
console.log(this.name);
};//①在構(gòu)造函數(shù)內(nèi)部定義的方法是給實例用的,拍出來的實例同方法名不相等因為兩個不同的實例,主體就不等,即不能被實例共享,棄用
}

    Cat.prototype.huit=function(){
        console.log('大家的huit方法')
    };//②在原型對象上部署的方法是給實例用的,不同實例同方法就相等,因為本質(zhì)表述的都是繼承對象原型的方法,即能夠被實例共享

//注意:對象本身也能用原型身上的方法屬性,但僅限于js原生內(nèi)置的,不能使用修改的內(nèi)置方法與自定義方法

    Cat.hui3=function(){
        console.log('對象的hui3方法');
    };//④在構(gòu)造函數(shù)上部署的方法,是構(gòu)造函數(shù)的方法相當(dāng)于Cat對象的靜態(tài)方法,不能被對象實例使用       

    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本身也是一個構(gòu)造函數(shù),可以用new命令生成一個Object對象實例（解釋：這個對象實例是Object型對象）
      通過new Object()生成的新對象實例,與字面量的寫法{}是等價的.

         所有構(gòu)造函數(shù)都有一個prototype屬性,指向(是)一個原型對象.
    ***即凡是定義在Object.prototype對象上面的屬性和方法,將被所有實例對象共享.（Object.prototype是原型鏈的頂端）
      
    3.Object() （沒深究）
       可以將任意值轉(zhuǎn)為對象, 這個方法常用于保證某個值一定是對象熙兔。
       如果參數(shù)是原始類型的值, Object函數(shù)可以將其轉(zhuǎn)為對應(yīng)的構(gòu)造函數(shù)生成的實例對象。
       如果Object方法的參數(shù)是一個對象艾恼，它總是返回原對象住涉。

Object 對象的靜態(tài)方法

所謂“靜態(tài)方法”是指部署在Object對象自身的方法 (構(gòu)造函數(shù)身上的方法)（實例不能用）
Object.keys()，Object.getOwnPropertyNames()
Object.keys方法和Object.getOwnPropertyNames方法很相似钠绍，一般用來遍歷對象的屬性
它們的參數(shù)都是一個對象舆声，都返回一個數(shù)組，該數(shù)組的成員都是對象自身的所有屬性名

由于JavaScript沒有提供計算對象屬性個數(shù)的方法，所以可以用這兩個方法代替
Object.keys(o).length
Object.getOwnPropertyNames(o).length

for in 遍歷對象的全部可枚舉的屬性名包括繼承來
它們?nèi)叩膮^(qū)別：
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循環(huán)中獲得對象自身的屬性媳握，可以采用hasOwnProperty方法判斷一下
為了在for...in循環(huán)中獲得對象自身的屬性碱屁，可以采用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對象的又一個靜態(tài)方法↓ 返回對象實例的原型對象
Object.keys() Object. getOwnPropertyNames()

因為這個原型對象是該實例原型鏈中最內(nèi)層的,所以它是獲取原型對象的標(biāo)準(zhǔn)方法
function Ft() {}
var f = new Ft ();
Object.getPrototypeOf(f) === Ft.prototype// true

Object.setPrototypeOf()[不常用]
Object對象的又一個靜態(tài)方法↓
Object.keys() Object. getOwnPropertyNames()

Object.setPrototypeOf()
接收兩個參數(shù)蛾找，第一個是現(xiàn)有對象娩脾，第二個是原型對象 ，并返回現(xiàn)有對象(它的原型對象已被設(shè)置)
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對象的又一個靜態(tài)方法↓
Object.keys() Object. getOwnPropertyNames()

Object.create()
它接受一個對象作為參數(shù)打毛，返回一個新對象 后者完全繼承前者的屬性方法柿赊，即原有對象成為新對象的原型
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的參數(shù)設(shè)為null
var o = Object.create(null);

o.valueOf()
// TypeError: o.valueOf is not a function

Object對象的實例方法

Object構(gòu)造函數(shù)生成的對象實例首先是對象隘冲，是哪一種對象闹瞧，是Object對象）

除了Object對象本身的方法，還有不少方法是部署在Object.prototype對象上的

所有對象實例 都繼承 Object.prototype的方法 原型鏈頂尖的男人

Object.prototype.valueOf()
valueOf方法的作用是返回一個對象的“值”展辞，默認(rèn)情況下返回對象本身【2個特殊：①包裝對象②new Date()】
var o = new Object();//一個Object(型)對象實例奥邮，一個構(gòu)造函數(shù)生出的實例
o.valueOf() === o // true
如果自定義實例的valueOf方法，就可以得到想要的結(jié)果
var o = new Object();
o.valueOf = function (){
return 2;};

1 + o // 3

Object.prototype.toString()
toString方法的作用是返回一個對象的字符串形式罗珍，默認(rèn)情況下返回類型字符串
var o1 = new Object();
o1.toString() // "[object Object]"

var o2 = [1,2,3,4];
o2.toString() // "1,2,3,4"
如果自定義實例的 toString方法洽腺，就可以得到想要的結(jié)果
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運算符返回一個布爾值 表示一個對象是否具有某個屬性 它不區(qū)分該屬性是自身還是繼承
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運算符返回一個布爾值藕坯，表示對象實例是否是某個構(gòu)造函數(shù)拍出來的
var v = new Vehicle();
v instanceof Vehicle // true
instanceof運算符的左邊是實例對象,右邊是構(gòu)造函數(shù)
它的運算實質(zhì)：檢查右邊構(gòu)造函數(shù)的prototype屬性所指向的原型對象,是否在左邊對象實例的原型鏈上
v instanceof Vehicle
// 等同于
Vehicle.prototype.isPrototypeOf(v)
由于instanceof對整個原型鏈上的對象都有效，因此同一個對象實例噪沙，可能會對多個構(gòu)造函數(shù)都返回true
var d = new Date();
d instanceof Date // true
d instanceof Object // true

toString()的應(yīng)用：判斷數(shù)據(jù)類型
var o = {};
o.toString() // "[object Object]"
結(jié)果返回一個字符串object Object炼彪，其中第二個Object表示該值的構(gòu)造函數(shù)。這是一個 比typeof運算符更準(zhǔn)確的判斷數(shù)據(jù)類型的方法

用call調(diào)用Object.prototype.toString可以得到一個實例的構(gòu)造函數(shù)
(復(fù)習(xí)：調(diào)用方法或函數(shù)一般用括號正歼，call()調(diào)用多了一個制定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]"