对象小总结

    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]"