jQuery对象的操作

参考一篇不错的文章：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object

1、创建对象：

var person = new Object();

或

var person = {};

2、对象属性：

　　2.1、为对象添加属性：

person.firstname = "Bill";    // 为person对象添加firstname属性

person.lastname = "Gates";    // 为person对象添加lastname属性

person.age = 56;    // 为person对象添加age属性

person.eyecolor = "blue";    // 为person对象添加eyecolor属性

　　2.2、对象的属性：

person.length;    // 返回person对象的长度

　　2.3、Object的原型对象:prototype：

　　　　（1） Object.prototype 属性的属性特性：

writable	false
enumerable	false
configurable	false

　　　　（2）几乎所有的 JavaScript 对象都是 Object 的实例；一个典型的对象继承了Object.prototype的属性（包括方法），尽管这些属性可能被遮蔽（也被称为覆盖）。改变Object原型，会通过原型链，而改变所有对象；除非这些属性和方法被其他对原型链更里层的改动所覆盖。这提供了一个非常强大的、但有潜在危险的机制，来覆盖或扩展对象行为。

　　　　（3）Object.prototype.constructor：返回创建实例对象的 Object 构造函数的引用。注意，此属性的值是对函数本身的引用，而不是一个包含函数名称的字符串。对原始类型来说，如1，true和"test"，该值只可读。

var o = {};

o.constructor === Object; // true

var o = new Object;

o.constructor === Object; // true

var a = [];

a.constructor === Array; // true

var a = new Array;

a.constructor === Array // true

var n = new Number(3);

n.constructor === Number; // true

function Tree(name) {

   this.name = name;

}

var theTree = new Tree("Redwood");

console.log( "theTree.constructor is " + theTree.constructor );

// 输出结果：

theTree.constructor is function Tree(name) {

  this.name = name;

}

3、方法：

　　3.1、Object.assign()：通过复制一个或多个对象来创建一个新的对象

const object1 = {

  a: 1,

  b: 2,

  c: 3

};

const object2 = Object.assign({}, object1);

console.log(object2.c);    //

/*

* 复制一个对象

*/

var obj = { a: 1 };

var copy = Object.assign({}, obj);

console.log(copy);     // { a: 1 }

/*

* 深拷贝问题

*/

function test() {

  'use strict';

  let obj1 = { a: 0 , b: { c: 0}};

  let obj2 = Object.assign({}, obj1);

  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}

  obj1.a = 1;

  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}

  console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}

  obj2.a = 2;

  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}

  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}}

  obj2.b.c = 3;

  console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}}

  console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}}

  // Deep Clone

  obj1 = { a: 0 , b: { c: 0}};

  let obj3 = JSON.parse(JSON.stringify(obj1));

  obj1.a = 4;

  obj1.b.c = 4;

  console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}

}

test();

/*

* 合并对象

*/

var o1 = { a: 1 };

var o2 = { b: 2 };

var o3 = { c: 3 };

var obj = Object.assign(o1, o2, o3);

console.log(obj); // { a: 1, b: 2, c: 3 }

console.log(o1);  // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变。

/*

* 合并具有相同属性的对象

*/

var o1 = { a: 1, b: 1, c: 1 };

var o2 = { b: 2, c: 2 };

var o3 = { c: 3 };

var obj = Object.assign({}, o1, o2, o3);

console.log(obj); // { a: 1, b: 2, c: 3 }

/*

* 拷贝 symbol 类型的属性

*/

var o1 = { a: 1 };

var o2 = { [Symbol('foo')]: 2 };

var obj = Object.assign({}, o1, o2);

console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)

Object.getOwnPropertySymbols(obj); // [Symbol(foo)]

/*

* 继承属性和不可枚举属性是不能拷贝的

*/

var obj = Object.create({foo: 1}, { // foo 是个继承属性。

    bar: {

        value: 2  // bar 是个不可枚举属性。

    },

    baz: {

        value: 3,

        enumerable: true  // baz 是个自身可枚举属性。

    }

});

var copy = Object.assign({}, obj);

console.log(copy); // { baz: 3 }

/*

* 原始类型会被包装为对象

*/

var v1 = "abc";

var v2 = true;

var v3 = 10;

var v4 = Symbol("foo")

var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);

// 原始类型会被包装，null 和 undefined 会被忽略。

// 注意，只有字符串的包装对象才可能有自身可枚举属性。

console.log(obj); // { "0": "a", "1": "b", "2": "c" }

/*

* 异常会打断后续拷贝任务

*/

var target = Object.defineProperty({}, "foo", {

    value: 1,

    writable: false

}); // target 的 foo 属性是个只读属性。

Object.assign(target, {bar: 2}, {foo2: 3, foo: 3, foo3: 3}, {baz: 4});

// TypeError: "foo" is read-only

// 注意这个异常是在拷贝第二个源对象的第二个属性时发生的。

console.log(target.bar);  // 2，说明第一个源对象拷贝成功了。

console.log(target.foo2); // 3，说明第二个源对象的第一个属性也拷贝成功了。

console.log(target.foo);  // 1，只读属性不能被覆盖，所以第二个源对象的第二个属性拷贝失败了。

console.log(target.foo3); // undefined，异常之后 assign 方法就退出了，第三个属性是不会被拷贝到的。

console.log(target.baz);  // undefined，第三个源对象更是不会被拷贝到的。

/*

* 拷贝访问器

*/

var obj = {

  foo: 1,

  get bar() {

    return 2;

  }

};

var copy = Object.assign({}, obj);

// { foo: 1, bar: 2 }

// copy.bar的值来自obj.bar的getter函数的返回值

console.log(copy); 

// 下面这个函数会拷贝所有自有属性的属性描述符

function completeAssign(target, ...sources) {

  sources.forEach(source => {

    let descriptors = Object.keys(source).reduce((descriptors, key) => {

      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);

      return descriptors;

    }, {});

    // Object.assign 默认也会拷贝可枚举的Symbols

    Object.getOwnPropertySymbols(source).forEach(sym => {

      let descriptor = Object.getOwnPropertyDescriptor(source, sym);

      if (descriptor.enumerable) {

        descriptors[sym] = descriptor;

      }

    });

    Object.defineProperties(target, descriptors);

  });

  return target;

}

var copy = completeAssign({}, obj);

console.log(copy);

// { foo:1, get bar() { return 2 } }

　　3.2、Object.create(proto, [propertiesObject])：使用指定的原型对象及其属性去创建一个新的对象。

　　例外：如果proto参数不是 null 或一个对象，则抛出一个 TypeError 异常。

/*

* 使用Object.create()来实现类式继承

*/

// Shape - 父类(superclass)

function Shape() {

  this.x = 0;

  this.y = 0;

}

// 父类的方法

Shape.prototype.move = function(x, y) {

  this.x += x;

  this.y += y;

  console.info('Shape moved.');

};

// Rectangle - 子类(subclass)

function Rectangle() {

  Shape.call(this); // call super constructor.

}

// 子类续承父类

Rectangle.prototype = Object.create(Shape.prototype);

Rectangle.prototype.constructor = Rectangle;

// 因为使用“.prototype =...”后,constructor会改变为“=...”的那个

// constructor，所以要重新指定.constructor 为自身。

var rect = new Rectangle();

console.log('Is rect an instance of Rectangle?',

  rect instanceof Rectangle); // true

console.log('Is rect an instance of Shape?',

  rect instanceof Shape); // true

rect.move(1, 1); // Outputs, 'Shape moved.'

/*

* 如果你希望能继承到多个对象，则可以使用混入的方式

*/

function MyClass() {

     SuperClass.call(this);

     OtherSuperClass.call(this);

}

// 继承一个类

MyClass.prototype = Object.create(SuperClass.prototype);

// 混合其它

Object.assign(MyClass.prototype, OtherSuperClass.prototype);

// 重新指定constructor

MyClass.prototype.constructor = MyClass;

MyClass.prototype.myMethod = function() {

     // do a thing

};

/*

* 使用 Object.create 的 propertyObject参数

*/

var o;

// 创建一个原型为null的空对象

o = Object.create(null);

o = {};

// 以字面量方式创建的空对象就相当于:

o = Object.create(Object.prototype);

o = Object.create(Object.prototype, {

  // foo会成为所创建对象的数据属性

  foo: {

    writable:true,

    configurable:true,

    value: "hello"

  },

  // bar会成为所创建对象的访问器属性

  bar: {

    configurable: false,

    get: function() { return 10 },

    set: function(value) {

      console.log("Setting `o.bar` to", value);

    }

  }

});

function Constructor(){}

o = new Constructor();

// 上面的一句就相当于:

o = Object.create(Constructor.prototype);

// 当然,如果在Constructor函数中有一些初始化代码,Object.create不能执行那些代码

// 创建一个以另一个空对象为原型,且拥有一个属性p的对象

o = Object.create({}, { p: { value: 42 } })

// 省略了的属性特性默认为false,所以属性p是不可写,不可枚举,不可配置的:

o.p = 24

o.p

//

o.q = 12

for (var prop in o) {

   console.log(prop)

}

//"q"

delete o.p

//false

//创建一个可写的,可枚举的,可配置的属性p

o2 = Object.create({}, {

  p: {

    value: 42,

    writable: true,

    enumerable: true,

    configurable: true

  }

});

　　3.3、Object.defineProperty()：直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回这个对象。

　　　　如果对象中不存在指定的属性，Object.defineProperty()就创建这个属性。当描述符中省略某些字段时，这些字段将使用它们的默认值。拥有布尔值的字段的默认值都是false。value，get和set字段的默认值为undefined。一个没有get/set/value/writable定义的属性被称为“通用的”，并被“键入”为一个数据描述符。

/*

* 创建属性

*/

var o = {}; // 创建一个新对象

// 在对象中添加一个属性与数据描述符的示例

Object.defineProperty(o, "a", {

  value : 37,

  writable : true,

  enumerable : true,

  configurable : true

});

// 对象o拥有了属性a，值为37

// 在对象中添加一个属性与存取描述符的示例

var bValue;

Object.defineProperty(o, "b", {

  get : function(){

    return bValue;

  },

  set : function(newValue){

    bValue = newValue;

  },

  enumerable : true,

  configurable : true

});

o.b = 38;

// 对象o拥有了属性b，值为38

// o.b的值现在总是与bValue相同，除非重新定义o.b

// 数据描述符和存取描述符不能混合使用

Object.defineProperty(o, "conflict", {

  value: 0x9f91102,

  get: function() {

    return 0xdeadbeef;

  }

});

// throws a TypeError: value appears only in data descriptors, get appears only in accessor descriptors

/*

* 修改属性

* Writable 属性：当writable属性设置为false时，该属性被称为“不可写”。它不能被重新分配。

*/

var o = {}; // Creates a new object

Object.defineProperty(o, 'a', {

  value: 37,

  writable: false

});

console.log(o.a); // logs 37

o.a = 25; // No error thrown

// (it would throw in strict mode,

// even if the value had been the same)

console.log(o.a); // logs 37. The assignment didn't work.

// strict mode

(function() {

  'use strict';

  var o = {};

  Object.defineProperty(o, 'b', {

    value: 2,

    writable: false

  });

  o.b = 3; // throws TypeError: "b" is read-only

  return o.b; // returns 2 without the line above

}());

/*

* 修改属性

* Enumerable 特性：enumerable定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举

*/

var o = {};

Object.defineProperty(o, "a", { value : 1, enumerable:true });

Object.defineProperty(o, "b", { value : 2, enumerable:false });

Object.defineProperty(o, "c", { value : 3 }); // enumerable defaults to false

o.d = 4; // 如果使用直接赋值的方式创建对象的属性，则这个属性的enumerable为true

for (var i in o) {

  console.log(i);

}

// 打印 'a' 和 'd' (in undefined order)

Object.keys(o); // ["a", "d"]

o.propertyIsEnumerable('a'); // true

o.propertyIsEnumerable('b'); // false

o.propertyIsEnumerable('c'); // false

/*

* 修改属性

* Configurable 特性：configurable特性表示对象的属性是否可以被删除，以及除writable特性外的其他特性是否可以被修改。

*/

var o = {};

Object.defineProperty(o, "a", { get : function(){return 1;},

                                configurable : false } );

// throws a TypeError

Object.defineProperty(o, "a", {configurable : true});

// throws a TypeError

Object.defineProperty(o, "a", {enumerable : true});

// throws a TypeError (set was undefined previously)

Object.defineProperty(o, "a", {set : function(){}});

// throws a TypeError (even though the new get does exactly the same thing)

Object.defineProperty(o, "a", {get : function(){return 1;}});

// throws a TypeError

Object.defineProperty(o, "a", {value : 12});

console.log(o.a); // logs 1

delete o.a; // Nothing happens

console.log(o.a); // logs 1

/*

* 添加多个属性和默认值

*/

var o = {};

o.a = 1;

// 等同于 :

Object.defineProperty(o, "a", {

  value : 1,

  writable : true,

  configurable : true,

  enumerable : true

});

// 另一方面，

Object.defineProperty(o, "a", { value : 1 });

// 等同于 :

Object.defineProperty(o, "a", {

  value : 1,

  writable : false,

  configurable : false,

  enumerable : false

});

/*

* 一般的 Setters 和 Getters

*/

function Archiver() {

  var temperature = null;

  var archive = [];

  Object.defineProperty(this, 'temperature', {

    get: function() {

      console.log('get!');

      return temperature;

    },

    set: function(value) {

      temperature = value;

      archive.push({ val: temperature });

    }

  });

  this.getArchive = function() { return archive; };

}

var arc = new Archiver();

arc.temperature; // 'get!'

arc.temperature = 11;

arc.temperature = 13;

arc.getArchive(); // [{ val: 11 }, { val: 13 }]

或者

var pattern = {

    get: function () {

        return 'I alway return this string,whatever you have assigned';

    },

    set: function () {

        this.myname = 'this is my name string';

    }

};

function TestDefineSetAndGet() {

    Object.defineProperty(this, 'myproperty', pattern);

}

var instance = new TestDefineSetAndGet();

instance.myproperty = 'test';

// 'I alway return this string,whatever you have assigned'

console.log(instance.myproperty);

// 'this is my name string'

console.log(instance.myname);

　　3.4、Object.entries()：返回一个数组，其元素是与直接在object上找到的可枚举属性键值对相对应的数组。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

const obj = { foo: 'bar', baz: 42 };

console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// array like object

const obj = { 0: 'a', 1: 'b', 2: 'c' };

console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// array like object with random key ordering

const anObj = { 100: 'a', 2: 'b', 7: 'c' };

console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo is property which isn't enumerable

const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });

myObj.foo = 'bar';

console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]

// non-object argument will be coerced to an object

console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// iterate through key-value gracefully

const obj = { a: 5, b: 7, c: 9 };

for (const [key, value] of Object.entries(obj)) {

  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"

}

// Or, using array extras

Object.entries(obj).forEach(([key, value]) => {

console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"

});

/*

* 将Object转换为Map

*/

var obj = { foo: "bar", baz: 42 };

var map = new Map(Object.entries(obj));

console.log(map);     // Map { foo: "bar", baz: 42 }

　　3.5、Object.freeze() ：可以冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。

/*

* 冻结对象

*/

var obj = {

  prop: function() {},

  foo: 'bar'

};

// 新的属性会被添加, 已存在的属性可能

// 会被修改或移除

obj.foo = 'baz';

obj.lumpy = 'woof';

delete obj.prop;

// 作为参数传递的对象与返回的对象都被冻结

// 所以不必保存返回的对象（因为两个对象全等）

var o = Object.freeze(obj);

o === obj; // true

Object.isFrozen(obj); // === true

// 现在任何改变都会失效

obj.foo = 'quux'; // 静默地不做任何事

// 静默地不添加此属性

obj.quaxxor = 'the friendly duck';

// 在严格模式，如此行为将抛出 TypeErrors

function fail(){

  'use strict';

  obj.foo = 'sparky'; // throws a TypeError

  delete obj.quaxxor; // throws a TypeError

  obj.sparky = 'arf'; // throws a TypeError

}

fail();

// 试图通过 Object.defineProperty 更改属性

// 下面两个语句都会抛出 TypeError.

Object.defineProperty(obj, 'ohai', { value: 17 });

Object.defineProperty(obj, 'foo', { value: 'eit' });

// 也不可能设置属性

// 下面两个语句都会抛出 TypeError.

Object.setPrototypeOf(obj, { x: 20 })

obj.__proto__ = { x: 20 }

/*

* 冻结数组

*/

// 冻结的数组像一个元组。

// 元组(tuple):与数组类似,但元组一旦初始化就不能修改

let a=[0];

Object.freeze(a);

// 数组a现在不能被更改了.

a[0]=1;

a.push(2);

// a=[0]

// 冻结的数组可以正常地拆包.

let b, c;

[b,c]=Object.freeze([1,2]);

// b=1, c=2

/*

* 不是常量的冻结对象（浅冻结）

*/

obj1 = {

  internal: {}

};

Object.freeze(obj1);

obj1.internal.a = 'aValue';

obj1.internal.a // 'aValue'

/*

* 深冻结函数.

*/

function deepFreeze(obj) {

  // 取回定义在obj上的属性名

  var propNames = Object.getOwnPropertyNames(obj);

  // 在冻结自身之前冻结属性

  propNames.forEach(function(name) {

    var prop = obj[name];

    // 如果prop是个对象，冻结它

    if (typeof prop == 'object' && prop !== null)

      deepFreeze(prop);

  });

  // 冻结自身(no-op if already frozen)

  return Object.freeze(obj);

}

obj2 = {

  internal: {}

};

deepFreeze(obj2);

obj2.internal.a = 'anotherValue';

obj2.internal.a; // undefined

　　3.6、Object.getOwnPropertyDescriptor() ：返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）　　

　　该方法允许对一个属性的描述进行检索。在 Javascript 中，属性由一个字符串类型的“名字”（name）和一个“属性描述符”（property descriptor）对象构成。更多关于属性描述符类型以及他们属性的信息可以查看：Object.defineProperty.

var o, d;

o = { get foo() { return 17; } };

d = Object.getOwnPropertyDescriptor(o, "foo");

// d {

//   configurable: true,

//   enumerable: true,

//   get: /*the getter function*/,

//   set: undefined

// }

o = { bar: 42 };

d = Object.getOwnPropertyDescriptor(o, "bar");

// d {

//   configurable: true,

//   enumerable: true,

//   value: 42,

//   writable: true

// }

o = {};

Object.defineProperty(o, "baz", {

  value: 8675309,

  writable: false,

  enumerable: false

});

d = Object.getOwnPropertyDescriptor(o, "baz");

// d {

//   value: 8675309,

//   writable: false,

//   enumerable: false,

//   configurable: false

// }

　　3.7、Object.getOwnPropertyNames()：返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

　　Object.getOwnPropertyNames() 返回一个数组，该数组对元素是 obj自身拥有的枚举或不可枚举属性名称字符串。数组中枚举属性的顺序与通过 for...in 循环（或 Object.keys）迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

/*

* 使用 Object.getOwnPropertyNames()

*/

var arr = ["a", "b", "c"];

console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]

// 类数组对象

var obj = { 0: "a", 1: "b", 2: "c"};

console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

// 使用Array.forEach输出属性名和属性值

Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {

  console.log(val + " -> " + obj[val]);

});

// 输出

// 0 -> a

// 1 -> b

// 2 -> c

//不可枚举属性

var my_obj = Object.create({}, {

  getFoo: {

    value: function() { return this.foo; },

    enumerable: false

  }

});

my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort()); // ["foo", "getFoo"]

/*

* 只获取不可枚举的属性

*/

var target = myObject;

var enum_and_nonenum = Object.getOwnPropertyNames(target);

var enum_only = Object.keys(target);

var nonenum_only = enum_and_nonenum.filter(function(key) {

    var indexInEnum = enum_only.indexOf(key);

    if (indexInEnum == -1) {

        // 没有发现在enum_only健集中意味着这个健是不可枚举的,

        // 因此返回true 以便让它保持在过滤结果中

        return true;

    } else {

        return false;

    }

});

console.log(nonenum_only);

　　3.8、Object.getOwnPropertySymbols() ：返回一个给定对象自身的所有 Symbol 属性的数组。

　　　　与Object.getOwnPropertyNames()类似，您可以将给定对象的所有符号属性作为 Symbol 数组获取。请注意，Object.getOwnPropertyNames()本身不包含对象的 Symbol 属性，只包含字符串属性。

　　　　因为所有的对象在初始化的时候不会包含任何的 Symbol，除非你在对象上赋值了 Symbol 否则Object.getOwnPropertySymbols()只会返回一个空的数组。

var obj = {};

var a = Symbol("a");

var b = Symbol.for("b");

obj[a] = "localSymbol";

obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); //

console.log(objectSymbols)         // [Symbol(a), Symbol(b)]

console.log(objectSymbols[0])      // Symbol(a)

　　3.9、Object.getPrototypeOf() ：返回指定对象的原型（内部[[Prototype]]属性的值）

var proto = {};

var obj = Object.create(proto);

Object.getPrototypeOf(obj) === proto; // true

var reg = /a/;

Object.getPrototypeOf(reg) === RegExp.prototype; // true

JavaScript中的 Object 是构造函数（创建对象的包装器）。

一般用法是：

var obj = new Object();

所以：

Object.getPrototypeOf( Object );               // ƒ () { [native code] }

Object.getPrototypeOf( Function );             // ƒ () { [native code] }

Object.getPrototypeOf( Object ) === Function.prototype;        // true

Object.getPrototypeOf( Object )是把Object这一构造函数看作对象，

返回的当然是函数对象的原型，也就是 Function.prototype。

正确的方法是，Object.prototype是构造出来的对象的原型。

var obj = new Object();

Object.prototype === Object.getPrototypeOf( obj );              // true

Object.prototype === Object.getPrototypeOf( {} );               // true

Object.getPrototypeOf('foo');

// TypeError: "foo" is not an object (ES5 code)

Object.getPrototypeOf('foo');

// String.prototype                  (ES2015 code)

　　3.10、Object.is()：判断两个值是否是相同的值

　　　　Object.is() 判断两个值是否相同。如果下列任何一项成立，则两个值相同：

- - 两个值都是 undefined
  - 两个值都是 null
  - 两个值都是 true 或者都是 false
  - 两个值是由相同个数的字符按照相同的顺序组成的字符串
  - 两个值指向同一个对象
  - 两个值都是数字并且
    - 都是正零 +0
    - 都是负零 -0
    - 都是 NaN
    - 都是除零和 NaN 外的其它同一个数字

　　　　这种相等性判断逻辑和传统的 == 运算符所用的不同，== 运算符会对它两边的操作数做隐式类型转换（如果它们类型不同），然后才进行相等性比较，（所以才会有类似 "" == false 为 true 的现象），但 Object.is 不会做这种类型转换。

　　　　这与===运算符也不一样。===运算符（和==运算符）将数字值-0和+0视为相等，并认为Number.NaN不等于NaN。

Object.is('foo', 'foo');     // true

Object.is(window, window);   // true

Object.is('foo', 'bar');     // false

Object.is([], []);           // false

var test = { a: 1 };

Object.is(test, test);       // true

Object.is(null, null);       // true

// 特例

Object.is(0, -0);            // false

Object.is(-0, -0);           // true

Object.is(NaN, 0/0);         //true

　　3.11、Object.isExtensible() ：判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）

　　　　默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。

// 新对象默认是可扩展的.

var empty = {};

Object.isExtensible(empty); // === true

// ...可以变的不可扩展.

Object.preventExtensions(empty);

Object.isExtensible(empty); // === false

// 密封对象是不可扩展的.

var sealed = Object.seal({});

Object.isExtensible(sealed); // === false

// 冻结对象也是不可扩展.

var frozen = Object.freeze({});

Object.isExtensible(frozen); // === false

Object.isExtensible(1);

// TypeError: 1 is not an object (ES5 code)

Object.isExtensible(1);

// false                         (ES6 code)

　　3.12、Object.isFrozen()：判断一个对象是否被冻结

　　一个对象是冻结的是指它不可扩展，所有属性都是不可配置的，且所有数据属性（即没有getter或setter组件的访问器的属性）都是不可写的。

// 一个对象默认是可扩展的,所以它也是非冻结的.

Object.isFrozen({}); // === false

// 一个不可扩展的空对象同时也是一个冻结对象.

var vacuouslyFrozen = Object.preventExtensions({});

Object.isFrozen(vacuouslyFrozen) //=== true;

// 一个非空对象默认也是非冻结的.

var oneProp = { p: 42 };

Object.isFrozen(oneProp) //=== false

// 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,

// 因为p属性仍然是可以配置的(而且可写的).

Object.preventExtensions(oneProp);

Object.isFrozen(oneProp) //=== false

// ...如果删除了这个属性,则它会成为一个冻结对象.

delete oneProp.p;

Object.isFrozen(oneProp) //=== true

// 一个不可扩展的对象,拥有一个不可写但可配置的属性,则它仍然是非冻结的.

var nonWritable = { e: "plep" };

Object.preventExtensions(nonWritable);

Object.defineProperty(nonWritable, "e", { writable: false }); // 变得不可写

Object.isFrozen(nonWritable) //=== false

// 把这个属性改为不可配置,会让这个对象成为冻结对象.

Object.defineProperty(nonWritable, "e", { configurable: false }); // 变得不可配置

Object.isFrozen(nonWritable) //=== true

// 一个不可扩展的对象,拥有一个不可配置但可写的属性,则它仍然是非冻结的.

var nonConfigurable = { release: "the kraken!" };

Object.preventExtensions(nonConfigurable);

Object.defineProperty(nonConfigurable, "release", { configurable: false });

Object.isFrozen(nonConfigurable) //=== false

// 把这个属性改为不可写,会让这个对象成为冻结对象.

Object.defineProperty(nonConfigurable, "release", { writable: false });

Object.isFrozen(nonConfigurable) //=== true

// 一个不可扩展的对象,值拥有一个访问器属性,则它仍然是非冻结的.

var accessor = { get food() { return "yum"; } };

Object.preventExtensions(accessor);

Object.isFrozen(accessor) //=== false

// ...但把这个属性改为不可配置,会让这个对象成为冻结对象.

Object.defineProperty(accessor, "food", { configurable: false });

Object.isFrozen(accessor) //=== true

// 使用Object.freeze是冻结一个对象最方便的方法.

var frozen = { 1: 81 };

Object.isFrozen(frozen) //=== false

Object.freeze(frozen);

Object.isFrozen(frozen) //=== true

// 一个冻结对象也是一个密封对象.

Object.isSealed(frozen) //=== true

// 当然,更是一个不可扩展的对象.

Object.isExtensible(frozen) //=== false

Object.isFrozen(1);

// TypeError: 1 is not an object (ES5 code)

Object.isFrozen(1);

// true                          (ES2015 code)

　　　　3.13、Object.isSealed() ：判断一个对象是否被密封

　　如果这个对象是密封的，则返回 true，否则返回 false。密封对象是指那些不可扩展的，且所有自身属性都不可配置且因此不可删除（但不一定是不可写）的对象。

// 新建的对象默认不是密封的.

var empty = {};

Object.isSealed(empty); // === false

// 如果你把一个空对象变的不可扩展,则它同时也会变成个密封对象.

Object.preventExtensions(empty);

Object.isSealed(empty); // === true

// 但如果这个对象不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的.

var hasProp = { fee: "fie foe fum" };

Object.preventExtensions(hasProp);

Object.isSealed(hasProp); // === false

// 如果把这个属性变的不可配置,则这个对象也就成了密封对象.

Object.defineProperty(hasProp, "fee", { configurable: false });

Object.isSealed(hasProp); // === true

// 最简单的方法来生成一个密封对象,当然是使用Object.seal.

var sealed = {};

Object.seal(sealed);

Object.isSealed(sealed); // === true

// 一个密封对象同时也是不可扩展的.

Object.isExtensible(sealed); // === false

// 一个密封对象也可以是一个冻结对象,但不是必须的.

Object.isFrozen(sealed); // === true ，所有的属性都是不可写的

var s2 = Object.seal({ p: 3 });

Object.isFrozen(s2); // === false， 属性"p"可写

var s3 = Object.seal({ get p() { return 0; } });

Object.isFrozen(s3); // === true ，访问器属性不考虑可写不可写,只考虑是否可配置

Object.isSealed(1);

// TypeError: 1 is not an object (ES5 code)

Object.isSealed(1);

// true                          (ES2015 code)

　　3.14、 Object.keys() ：返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in 循环遍历该对象时返回的顺序一致（两者的主要区别是一个 for-in 循环还会枚举其原型链上的属性）。

　　Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的对象上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致。

/* Array 对象 */

let arr = ["a", "b", "c"];

console.log(Object.keys(arr));

// ['0', '1', '2']

/* Object 对象 */

let obj = { foo: "bar", baz: 42 },

    keys = Object.keys(obj);

// CCAC: Chrome Console Auto Copy

copy(keys);

// ["foo","baz"]

/* 类数组 对象 */

let obj = { 0 : "a", 1 : "b", 2 : "c"};

console.log(Object.keys(obj));

// ['0', '1', '2']

注意：

var obj = { 0:"a", 1:"b", 2:{3:"c", 4:"d"}};

console.log(Object.keys(obj));

// (3) ["0", "1", "2"]

// 类数组 对象, 随机 key 排序

let anObj = { 100: 'a', 2: 'b', 7: 'c' }; 

console.log(Object.keys(anObj));

// ['2', '7', '100']

/* getFoo 是个不可枚举的属性 */

var my_obj = Object.create(

   {},

   { getFoo : { value : function () { return this.foo } } }

);

my_obj.foo = 1;

console.log(Object.keys(my_obj));

// ['foo']

Object.keys("foo");

// TypeError: "foo" is not an object (ES5 code)

Object.keys("foo");

// ["0", "1", "2"]                   (ES2015 code)

　　3.15、Object.preventExtensions()：让一个对象变的不可扩展，也就是永远不能再添加新的属性。

　　如果一个对象可以添加新的属性，则这个对象是可扩展的。Object.preventExtensions()将对象标记为不再可扩展，因此它将永远不会具有超出它被标记为不可扩展的属性。注意，一般来说，不可扩展对象的属性可能仍然可被删除。尝试将新属性添加到不可扩展对象将静默失败或抛出TypeError（最常见但不排除其他情况，如在strict mode中）。

　　Object.preventExtensions()仅阻止添加自身的属性。但属性仍然可以添加到对象原型。

　　一旦使其不可扩展，就无法再对象进行扩展。

// Object.preventExtensions将原对象变的不可扩展,并且返回原对象.

var obj = {};

var obj2 = Object.preventExtensions(obj);

obj === obj2;  // true

// 字面量方式定义的对象默认是可扩展的.

var empty = {};

Object.isExtensible(empty) //=== true

// ...但可以改变.

Object.preventExtensions(empty);

Object.isExtensible(empty) //=== false

// 使用Object.defineProperty方法为一个不可扩展的对象添加新属性会抛出异常.

var nonExtensible = { removable: true };

Object.preventExtensions(nonExtensible);

Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // 抛出TypeError异常

// 在严格模式中,为一个不可扩展对象的新属性赋值会抛出TypeError异常.

function fail()

{

  "use strict";

  nonExtensible.newProperty = "FAIL"; // throws a TypeError

}

fail();

// 一个不可扩展对象的原型是不可更改的,__proto__是个非标准魔法属性,可以更改一个对象的原型.

var fixed = Object.preventExtensions({});

fixed.__proto__ = { oh: "hai" }; // 抛出TypeError异常

Object.preventExtensions(1);

// TypeError: 1 is not an object (ES5 code)

Object.preventExtensions(1);

// 1                             (ES2015 code)

　　3.16、Object.seal() ：可以让一个对象密封，并返回被密封后的对象。密封对象将会阻止向对象添加新的属性，并且会将所有已有属性的可配置性（configurable）置为不可配置（false），即不可修改属性的描述或删除属性。但是可写性描述（writable）为可写（true）的属性的值仍然可以被修改。

　　通常情况下，一个对象是可扩展的（可以添加新的属性）。密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会静默失败或抛出TypeError 异常（严格模式）。

　　不会影响从原型链上继承的属性。但 __proto__ ( ) 属性的值也会不能修改。

var obj = {

    prop: function () {},

    foo: "bar"

  };

// 可以添加新的属性,已有属性的值可以修改,可以删除

obj.foo = "baz";

obj.lumpy = "woof";

delete obj.prop;

var o = Object.seal(obj);

assert(o === obj);

assert(Object.isSealed(obj) === true);

// 仍然可以修改密封对象上的属性的值.

obj.foo = "quux";

// 但你不能把一个数据属性重定义成访问器属性.

Object.defineProperty(obj, "foo", { get: function() { return "g"; } }); // 抛出TypeError异常

// 现在,任何属性值以外的修改操作都会失败.

obj.quaxxor = "the friendly duck"; // 静默失败,新属性没有成功添加

delete obj.foo; // 静默失败,属性没有删除成功

// ...在严格模式中,会抛出TypeError异常

function fail() {

  "use strict";

  delete obj.foo; // 抛出TypeError异常

  obj.sparky = "arf"; // 抛出TypeError异常

}

fail();

// 使用Object.defineProperty方法同样会抛出异常

Object.defineProperty(obj, "ohai", { value: 17 }); // 抛出TypeError异常

Object.defineProperty(obj, "foo", { value: "eit" }); // 成功将原有值改变

　　3.17、Object.setPrototypeOf() ：设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或 null

　　如果对象的[[Prototype]]被修改成不可扩展(通过 Object.isExtensible()查看)，就会抛出 TypeError异常。如果prototype参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将obj的[[Prototype]]修改为新的值。

　　Object.setPrototypeOf()是ECMAScript 6最新草案中的方法，相对于 Object.prototype.__proto__ ，它被认为是修改对象原型更合适的方法。

var dict = Object.setPrototypeOf({}, null);

/*

* 向一个原型附加一个链

*/

function Mammal() {

  this.isMammal = 'yes';

}

function MammalSpecies(sMammalSpecies) {

  this.species = sMammalSpecies;

}

MammalSpecies.prototype = new Mammal();

MammalSpecies.prototype.constructor = MammalSpecies;

var oCat = new MammalSpecies('Felis');

console.log(oCat.isMammal);

// 'yes'

function Animal() {

  this.breathing = 'yes';

}

Object.appendChain(oCat, new Animal());

console.log(oCat.breathing);

// 'yes'

/*

* 将一个基本类型转化为对应的对象类型并添加到原型链上

*/

function Symbol() {

  this.isSymbol = 'yes';

}

var nPrime = 17;

console.log(typeof nPrime); // 'number'

var oPrime = Object.appendChain(nPrime, new Symbol());

console.log(oPrime); // '17'

console.log(oPrime.isSymbol); // 'yes'

console.log(typeof oPrime); // 'object'

/*

* 给函数类型的对象添加一个链，并添加一个新的方法到那个链上

*/

function Person(sName) {

  this.identity = sName;

}

var george = Object.appendChain(new Person('George'), 'console.log("Hello guys!!");');

console.log(george.identity); // 'George'

george(); // 'Hello guys!!'

　　3.18、Object.values()：返回一个给定对象自己的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )

　　Object.values()返回一个数组，其元素是在对象上找到的可枚举属性值。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

var obj = { foo: "bar", baz: 42 };

console.log(Object.values(obj)); // ['bar', 42]

// 类数组对象

var obj = { 0: 'a', 1: 'b', 2: 'c' };

console.log(Object.values(obj)); // ['a', 'b', 'c']

注意：

var obj = { 0: 'a', 1: 'b', 2: { 3: 'c' , 4: 'd' } };

console.log(Object.values(obj));

// ["a", "b", {…}] 内置的对象没有扩展成数组

// 随机键值的类数组对象

var an_obj = { 100: 'a', 2: 'b', 7: 'c' };

console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo 是不可枚举属性

var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });

my_obj.foo = "bar";

console.log(Object.values(my_obj)); // ['bar']

// 参数是非对象会转变成对象

console.log(Object.values("foo")); // ['f', 'o', 'o']

4、Object 实例和Object 原型对象：

　　JavaScript中的所有对象都来自Object；所有对象从Object.prototype继承方法和属性，尽管它们可能被覆盖。例如，其他构造函数的原型将覆盖constructor属性并提供自己的toString()方法。Object原型对象的更改将传播到所有对象，除非受到这些更改的属性和方法将沿原型链进一步覆盖。

　　4.1、属性：Object.prototype.constructor：返回创建实例对象的 Object 构造函数的引用。注意，此属性的值是对函数本身的引用，而不是一个包含函数名称的字符串。对原始类型来说，如1，true和"test"，该值只可读。

// 所有对象都会从它的原型上继承一个 constructor 属性：

var o = {};

o.constructor === Object; // true

var o = new Object;

o.constructor === Object; // true

var a = [];

a.constructor === Array; // true

var a = new Array;

a.constructor === Array // true

var n = new Number(3);

n.constructor === Number; // true

/*

* 打印一个对象的构造函数

* 创建一个原型，Tree，以及该类型的对象，即theTree。 然后打印theTree对象的constructor属性。

*/

function Tree(name) {

   this.name = name;

}

var theTree = new Tree("Redwood");

console.log( "theTree.constructor is " + theTree.constructor );

// theTree.constructor is function Tree(name) {

//    this.name = name;

// }

/*

* 改变对象的 constructor

* 显示如何修改泛型对象的构造函数值。 只有true, 1 和"test"不受影响，因为他们有只读的原生构造函数。 这个例子也表明依靠对象的constructor属性并不总是安全的。

*/

function Type() { };

var    types = [

    new Array,

    [],

    new Boolean,

    true,        // remains unchanged

    new Date,

    new Error,

    new Function,

    function(){},

    Math,

    new Number,

    1,           // remains unchanged

    new Object,

    {},

    new RegExp,

    /(?:)/,

    new String,

    "test"       // remains unchanged

];

for(var i = 0; i < types.length; i++) {

    types[i].constructor = Type;

    types[i] = [ types[i].constructor, types[i] instanceof Type, types[i].toString() ];

};

console.log( types.join("\n") );

// 输出结果：

/*

function Type() {},false,

function Type() {},false,

function Type() {},false,false

function Boolean() {

    [native code]

},false,true

function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600

function Type() {},false,Error

function Type() {},false,function anonymous() {

}

function Type() {},false,function () {}

function Type() {},false,[object Math]

function Type() {},false,0

function Number() {

    [native code]

},false,1

function Type() {},false,[object Object]

function Type() {},false,[object Object]

function Type() {},false,/(?:)/

function Type() {},false,/(?:)/

function Type() {},false,

function String() {

    [native code]

},false,test

*/

　　4.2、方法：Object.prototype.hasOwnProperty()：返回一个布尔值，指示对象自身属性中是否具有指定的属性

　　所有继承了 Object 的对象都会继承到 hasOwnProperty 方法。这个方法可以用来检测一个对象是否含有特定的自身属性；和 in 运算符不同，该方法会忽略掉那些从原型链上继承到的属性。

// 使用 hasOwnProperty 方法判断属性是否存在

// 检测了对象 o 是否含有自身属性 prop：

o = new Object();

o.prop = 'exists';

function changeO() {

  o.newprop = o.prop;

  delete o.prop;

}

o.hasOwnProperty('prop');   // 返回 true

changeO();

o.hasOwnProperty('prop');   // 返回 false

// 自身属性与继承属性

// 下面的例子演示了 hasOwnProperty 方法对待自身属性和继承属性的区别：

o = new Object();

o.prop = 'exists';

o.hasOwnProperty('prop');             // 返回 true

o.hasOwnProperty('toString');         // 返回 false

o.hasOwnProperty('hasOwnProperty');   // 返回 false

// 遍历一个对象的所有自身属性

// 下面的例子演示了如何在遍历一个对象的所有属性时忽略掉继承属性，注意这里 for...in  循环只会遍历可枚举属性，
// 所以不应该基于这个循环中没有不可枚举的属性而得出 hasOwnProperty 是严格限制于可枚举项目的（如同 Object.getOwnPropertyNames()）。

var buz = {

    fog: 'stack'

};

for (var name in buz) {

    if (buz.hasOwnProperty(name)) {

        alert("this is fog (" + name + ") for sure. Value: " + buz[name]);

    }

    else {

        alert(name); // toString or something else

    }

}

// 使用 hasOwnProperty 作为属性名

// JavaScript 并没有保护 hasOwnProperty 属性名，因此某个对象是有可能存在使用这个属性名的属性，使用外部的 hasOwnProperty 获得正确的结果是需要的：

var foo = {

    hasOwnProperty: function() {

        return false;

    },

    bar: 'Here be dragons'

};

foo.hasOwnProperty('bar'); // 始终返回 false

// 如果担心这种情况，可以直接使用原型链上真正的 hasOwnProperty 方法

({}).hasOwnProperty.call(foo, 'bar'); // true

// 也可以使用 Object 原型上的 hasOwnProperty 属性

Object.prototype.hasOwnProperty.call(foo, 'bar'); // true

　　4.3、Object.prototype.isPrototypeOf()：用于测试一个对象是否存在于另一个对象的原型链上　　

// 本示例展示了 Baz.prototype, Bar.prototype, Foo.prototype 和 Object.prototype 在 baz 对象的原型链上：

function Foo() {}

function Bar() {}

function Baz() {}

Bar.prototype = Object.create(Foo.prototype);

Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true

console.log(Bar.prototype.isPrototypeOf(baz)); // true

console.log(Foo.prototype.isPrototypeOf(baz)); // true

console.log(Object.prototype.isPrototypeOf(baz)); // true

// 检查 baz 对象是否继承自 Foo.prototype：

if (Foo.prototype.isPrototypeOf(baz)) {

  // do something safe

}

　　4.4、Object.prototype.propertyIsEnumerable()：返回一个布尔值，表示指定的属性是否可枚举

　　每个对象都有一个propertyIsEnumerable方法。此方法可以确定对象中指定的属性是否可以被for...in循环枚举，但是通过原型链继承的属性除外。如果对象没有指定的属性，则此方法返回false。

// propertyIsEnumerable方法的基本用法

// 下面的例子演示了propertyIsEnumerable方法在普通对象和数组上的基本用法:

var o = {};

var a = [];

o.prop = 'is enumerable';

a[0] = 'is enumerable';

o.propertyIsEnumerable('prop');   //  返回 true

a.propertyIsEnumerable(0);        // 返回 true

// 用户自定义对象和引擎内置对象

// 下面的例子演示了用户自定义对象和引擎内置对象上属性可枚举性的区别.

var a = ['is enumerable'];

a.propertyIsEnumerable(0);          // 返回 true

a.propertyIsEnumerable('length');   // 返回 false

Math.propertyIsEnumerable('random');   // 返回 false

this.propertyIsEnumerable('Math');     // 返回 false

// 自身属性和继承属性

var a = [];

a.propertyIsEnumerable('constructor');         // 返回 false

function firstConstructor() {

  this.property = 'is not enumerable';

}

firstConstructor.prototype.firstMethod = function() {};

function secondConstructor() {

  this.method = function method() { return 'is enumerable'; };

}

secondConstructor.prototype = new firstConstructor;

secondConstructor.prototype.constructor = secondConstructor;

var o = new secondConstructor();

o.arbitraryProperty = 'is enumerable';

o.propertyIsEnumerable('arbitraryProperty');   // 返回 true

o.propertyIsEnumerable('method');              // 返回 true

o.propertyIsEnumerable('property');            // 返回 false

o.property = 'is enumerable';

o.propertyIsEnumerable('property');            // 返回 true

// 这些返回fasle，是因为，在原型链上propertyIsEnumerable不被考虑

// (尽管最后两个在for-in循环中可以被循环出来)。

o.propertyIsEnumerable('prototype');   // 返回 false (根据 JS 1.8.1/FF3.6)

o.propertyIsEnumerable('constructor'); // 返回 false

o.propertyIsEnumerable('firstMethod'); // 返回 false

　　4.5、Object.prototype.toLocaleString()：返回一个该对象的字符串表示。此方法被用于派生对象为了特定语言环境的目的（locale-specific purposes）而重载使用

　　toLocaleString 返回调用 toString() 的结果。

　　该函数提供给对象一个通用的toLocaleString 方法，即使不是全部都可以使用它。见下面的列表。

　　覆盖 `toLocaleString` 的对象

　　4.6、Object.prototype.toString()：返回一个表示该对象的字符串

　　每个对象都有一个toString()方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认情况下，toString()方法被每个Object对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 "[object type]"，其中type是对象的类型。以下代码说明了这一点：

var o = new Object();

o.toString(); // returns [object Object]

　　　　（1）覆盖默认的toString方法

// 可以自定义一个方法来取代默认的 toString() 方法。该 toString() 方法不能传入参数并且必须返回一个字符串。
// 自定义的 toString() 方法可以是任何我们需要的值，但如果它附带有关对象的信息，它将变的非常有用。

// 以下代码定义了Dog对象类型，并创建了一个Dog类型的theDog对象：

function Dog(name,breed,color,sex) {

   this.name=name;

   this.breed=breed;

   this.color=color;

   this.sex=sex;

}

var theDog = new Dog("Gabby","Lab","chocolate","female");

　　如果当前的对象调用了 toString() 方法，它将会返回从Object继承下来的 toString()方法的返回默认值：

theDog.toString(); // returns [object Object]

　　下面的代码中定义了一个叫做 dogToString() 的方法来覆盖默认的 toString() 方法。这个方法生成一个 "property = value;" 形式的字符串，该字符串包含了当前对象的 name， breed，color 和 sex 的值。

Dog.prototype.toString = function dogToString() {

  var ret = "Dog " + this.name + " is a " + this.sex + " " + this.color + " " + this.breed;

  return ret;

}

　　使用上述代码，任何时候在字符串上下文中使用theDog.toString()，JavaScript 都会自动调用 dogToString() 方法（dogToString()可以是一个匿名函数），并且返回以下字符串：

"Dog Gabby is a female chocolate Lab"

　　（2）使用toString()检测对象类型

　　可以通过toString() 来获取每个对象的类型。为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为thisArg。

var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]

toString.call(new String); // [object String]

toString.call(Math); // [object Math]

//Since JavaScript 1.8.5

toString.call(undefined); // [object Undefined]

toString.call(null); // [object Null]

　　4.7、Object.prototype.valueOf()：返回指定对象的原始值

JavaScript调用valueOf方法将对象转换为原始值。你很少需要自己调用valueOf方法；当遇到要预期的原始值的对象时，JavaScript会自动调用它。

默认情况下，valueOf方法由Object后面的每个对象继承。每个内置的核心对象都会覆盖此方法以返回适当的值。如果对象没有原始值，则valueOf将返回对象本身。

JavaScript的许多内置对象都重写了该函数，以实现更适合自身的功能需要。因此，不同类型对象的valueOf()方法的返回值和返回值类型均可能不同。

不同类型对象的valueOf()方法的返回值
对象	返回值
Array	返回数组对象本身。
Boolean	布尔值。
Date	存储的时间是从 1970 年 1 月 1 日午夜开始计的毫秒数 UTC。
Function	函数本身。
Number	数字值。
Object	对象本身。这是默认情况。
String	字符串值。
	Math 和 Error 对象没有 valueOf 方法。

你可以在自己的代码中使用valueOf将内置对象转换为原始值。创建自定义对象时，可以覆盖Object.prototype.valueOf()来调用自定义方法，而不是默认Object方法。

/*

* 使用 valueOf

*/

// Array：返回数组对象本身

var array = ["ABC", true, 12, -5];

console.log(array.valueOf() === array);   // true

// Date：当前时间距1970年1月1日午夜的毫秒数

var date = new Date(2013, 7, 18, 23, 11, 59, 230);

console.log(date.valueOf());   //

// Number：返回数字值

var num =  15.26540;

console.log(num.valueOf());   // 15.2654

// 布尔：返回布尔值true或false

var bool = true;

console.log(bool.valueOf() === bool);   // true

// new一个Boolean对象

var newBool = new Boolean(true);

// valueOf()返回的是true，两者的值相等

console.log(newBool.valueOf() == newBool);   // true

// 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型

console.log(newBool.valueOf() === newBool);   // false

// Function：返回函数本身

function foo(){}

console.log( foo.valueOf() === foo );   // true

var foo2 =  new Function("x", "y", "return x + y;");

console.log( foo2.valueOf() );

/*

ƒ anonymous(x,y

) {

return x + y;

}

*/

// Object：返回对象本身

var obj = {name: "张三", age: 18};

console.log( obj.valueOf() === obj );   // true

// String：返回字符串值

var str = "http://www.xyz.com";

console.log( str.valueOf() === str );   // true

// new一个字符串对象

var str2 = new String("http://www.xyz.com");

// 两者的值相等，但不全等，因为类型不同，前者为string类型，后者为object类型

console.log( str2.valueOf() === str2 );   // false

/*

* 改写 .prototype.valueof

*/

function MyNumberType(n) {

    this.number = n;

}

MyNumberType.prototype.valueOf = function() {

    return this.number;

};

var myObj = new MyNumberType(4);

myObj + 3; //

// 给定 undefined 和 null 类型使用 Object

// 将一个空的 Object 对象存到 o 中

var o = new Object();

var o = new Object(undefined);

var o = new Object(null);

// 使用 Object 生成布尔对象

// 将Boolean 对象存到 o 中

// 等价于 o = new Boolean(true);

var o = new Object(true);

// 等价于 o = new Boolean(false);

var o = new Object(Boolean());

巴特西

jQuery对象的操作

覆盖 `toLocaleString` 的对象

最新文章

热门文章

巴特西

jQuery对象的操作

覆盖 toLocaleString 的对象

最新文章

热门文章

　　覆盖 `toLocaleString` 的对象