create创建一个对象

  1. const obj = Object.create({a:1}, {b: {value: 2}})
  3. 第一个参数为对象，对象为函数调用之后返回新对象的原型对象，第二个参数为对象本身的实例方法（默认不能修改,不能枚举）
  4. obj.__proto__.a === 1      // true 
  6. obj.b = 3;
  7. console.log(obj.b)      // 2
  9. //创建一个可写的,可枚举的,可配置的属性p
  10. obj2 = Object.create({}, {
  11.   p: {
  12.     value: 2,       // 属性值
  13.     writable: true,     //  是否可以重写值
  14.     enumerable: true,   //是否可枚举
  15.     configurable: true  //是否可以修改以上几项配置
  16.   }
  17. });
  19. obj2.p = 3;
  20. console.log(obj2.p)     // 3
  21. 注意： enumerable 会影响以下
  22. for…in  遍历包括对象原型上属性
  23. Object.keys()   只能遍历自身属性
  24. JSON.stringify  只能序列化自身属性

defineProperty Object.defineProperty(object, prop, descriptor)定义对象属性

  1. 添加数据属性
  2. var obj = {};
  4. // 1.添加一个数据属性
  5. Object.defineProperty(obj, "newDataProperty", {
  6.     value: 101,
  7.     writable: true,
  8.     enumerable: true,
  9.     configurable: true
  10. });
  12. obj.newDataProperty    // 101
  14. // 2.修改数据属性
  15. Object.defineProperty(obj, "newDataProperty", {
  16.     writable:false
  17. });
  19. //添加访问器属性
  20. var obj = {};
  21. Object.defineProperty(obj, "newAccessorProperty", {
  22.     set: function (x) {
  23.         this.otherProperty = x;
  24.     },
  25.     get: function () {
  26.         return this.otherProperty;
  27.     },
  28.     enumerable: true,
  29.     configurable: true
  30. });
  31. 注意：  1.第一个参数必须为对象
  32.         2.descriptor 不能同时具有 （value 或 writable 特性）（get 或 set 特性）。
  33.         3.configurable 为false 时，不能重新修改装饰器

defineProperties Object.defineProperties(object, {prop1 : descriptor1, prop2 : descriptor2, …)

  1. var obj = {};
  2. Object.defineProperties(obj, {
  3.   'property1': {
  4.     value: true,
  5.     writable: true
  6.   },
  7.   'property2': {
  8.     value: 'Hello',
  9.     writable: false
  10.   }
  11.   // etc. etc.
  12. });

keys 遍历可枚举的属性，只包含对象本身可枚举属性，不包含原型链可枚举属性

  1. let arr = ["a", "b", "c"];
  2. let obj = { foo: "bar", baz: 42 };
  3. let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};
  5. Object.keys(arr)        // ['0', '1', '2']
  6. Object.keys(obj)        // ["foo","baz"]
  7. Object.keys(ArrayLike)  // ['0', '1', '2']

values 遍历可枚举的属性值，只包含对象本身可枚举属性值，不包含原型链可枚举属性值

  1. let arr = ["a", "b", "c"];
  2. let obj = { foo: "bar", baz: 42 };
  3. let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};
  5. Object.values(arr)      // ["a", "b", "c"]
  6. Object.values(obj)          // ["bar",42]
  7. Object.values(ArrayLike)    // ["a", "b", "c"]

assign Object.assign( target, source, source1 ) 方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（enumerable: false）

  1. const target = { a: 1, b: 1 };
  3. const source1 = { b: 2, c: 2 };
  4. const source2 = { c: 3 };
  6. Object.assign(target, source1, source2); target // {a:1, b:2, c:3}
  9. 特殊情况：
  10. let obj = {a: 1};
  11. Object.assign(obj, undefined) === obj  // true
  12. Object.assign(obj, null) === obj       // true
  14. Object.assign([1, 2, 3], [4, 5])        // [4, 5, 3]
  16. Object.assign方法实行的是浅拷贝，而不是深拷贝。
  18. const obj1 = {a: {b: 1}};
  19. const obj2 = Object.assign({}, obj1);
  21. obj1.a.b = 2;
  22. console.log(obj2.a.b) //2
  23. obj2.a.b = 3
  24. console.log(obj1.a.b) //3

getPrototypeOf 获取指定对象的原型（内部[[Prototype]]属性的值）

  1. const prototype1 = {};
  2. const object1 = Object.create(prototype1);
  4. console.log(Object.getPrototypeOf(object1) === prototype1);   // true
  6. 注意：Object.getPrototypeOf(Object) 不是 Object.prototype
  7.      Object.getPrototypeOf( Object ) === Function.prototype;  // true

setPrototypeOf 设置一个指定的对象的原型

  1. const obj = {a: 1}, proto = {b:2}
  3. Object.setPrototypeOf(obj, proto)
  5. obj.__proto__ === proto     //true

getOwnPropertyNames 与keys相似，但包含遍历包含不可枚举属性

  1. var my_obj = Object.create({}, {
  2.   getFoo: {
  3.     value: function() { return this.foo; },
  4.     enumerable: false
  5.   }
  6. });
  8. my_obj.foo = 1;
  10. Object.getOwnPropertyNames(my_obj).sort()   // ["foo", "getFoo"]

getOwnPropertyDescriptor 获取该属性的描述对象

  1. let obj = { foo: 123 };
  2. Object.getOwnPropertyDescriptor(obj, 'foo')
  3. //  { value: 123, writable: true, enumerable: true, configurable: true }

getOwnPropertyDescriptors 返回指定对象所有自身属性（非继承属性）的描述对象

  1. Object.getOwnPropertyDescriptors 方法，返回指定对象所有自身属性（非继承属性）的描述对象。
  3. const obj = {
  4.   foo: 123,
  5.   get bar() { return 'abc' }
  6. };
  8. console.dir(Object.getOwnPropertyDescriptors(obj))
  9. //   { foo:{ value: 123,
  10. //      writable: true,
  11. //      enumerable: true,
  12. //      configurable: true },
  13. //       bar:{ get: [Function: bar],
  14. //      set: undefined,
  15. //      enumerable: true,
  16. //      configurable: true } 
  17. //     }
  20. 使用场景：
  21. Object.assign() 方法只能拷贝源对象的可枚举的自身属性，同时拷贝时无法拷贝属性的特性，而且访问器属性会被转换成数据属性，也无法拷贝源对象的原型
  23. Object.create() 方法可以实现上面说的这些，配合getPrototypeOf，以及getOwnPropertyDescriptors实现全面浅拷贝
  25. Object.create(
  26.   Object.getPrototypeOf(obj), 
  27.   Object.getOwnPropertyDescriptors(obj) 
  28. );

entries 分割对象

  2. const obj = { foo: 'bar', baz: 42 };
  3. console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
  5. // array like object
  6. const obj = { 0: 'a', 1: 'b', 2: 'c' };
  7. console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
  9. //  string
  10. Object.entries('abc')   // [['0', 'a'], ['1', 'b'], ['2', 'c']]
  12. Object.entries(100)   // []

is 它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致

  1. Object.is('foo', 'foo')     // true
  3. Object.is({}, {})           // false
  5. 不同于 === 之处
  6. +0 === -0                   //true
  7. NaN === NaN                     // false
  9. Object.is(+0, -0)           // false
  10. Object.is(NaN, NaN)         // true
  12. // 特例
  13. Object.is(0, -0);            // false
  14. Object.is(0, +0);            // true
  15. Object.is(-0, -0);           // true
  16. Object.is(NaN, 0/0);         // true

preventExtensions 让一个对象变的不可扩展，也就是永远不能再添加新的属性&isExtensible 判断一个对象是否可扩展

  1. let empty = {}
  3. Object.isExtensible(empty)    //true
  4. empty.a = 1             //添加成功
  5. //将对象变为不可拓展
  6. Object.preventExtensions(empty)
  8. Object.isExtensible(empty)    //false
  10. empty.b = 2         //静默失败,不抛出错误
  12. empty.a = 5         //修改a属性值为5  修改成功
  14. 总结：
  15.      1.preventExtensions 可以让这个对象变的不可扩展，也就是不能再有新的属性。
  16.     2.需要注意的是不可扩展的对象的属性通常仍然可以被删除。
  17.     3.尝试给一个不可扩展对象添加新属性的操作将会失败，不过可能是静默失败，也可能会抛出 TypeError 异常（严格模式）。        
  18.     4.Object.preventExtensions 只能阻止一个对象不能再添加新的自身属性，仍然可以为该对象的原型添加属性。

seal将一个对象密封 isSealed 判断一个对象是否为密封的

  1. 密封对象是指那些不能添加新的属性，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性，但可能可以修改已有属性的值的对象。
  3. 1. 先讲seal 方法：
  4. var o2 = {b: 1}
  5. o2.d = 2    //添加成功
  6. var obj2 = Object.seal(o2);
  7. obj2 === o2         //true  方法返回原对象，栈指针指向同一块内存
  8. Object.isSealed(o2)   // true
  10. o2.b = 111       //修改b属性值成功
  13. o2.f = 222       //静默失败,属性f没有成功添加
  14. delete o2.b      //静默失败,属性b没有成功删除
  17. 2. 讲isSealed 方法：
  18. let o = {};
  19. Object.isSealed(o)    //false
  21. // 之后通过Object.preventExtensions方法将空对象设置为不可扩展。
  22. Object.preventExtensions(o);
  23. Object.isSealed(o)    // true
  25. 但是如果为非空对象呢？
  27. let o2 = {a: 1}
  28. Object.preventExtensions(o2);
  29. Object.isSealed(o2)    // false
  31. 因为属性 a 是可配置的（configurable为true），所以不是密封的对象，修改方法如下：
  32. let o2 = {a: 1}
  33. Object.preventExtensions(o2);
  34. Object.defineProperty(o2, "a", { configurable: false });
  35. Object.isSealed(o2)    //true
  38. 总结： 1.密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。
  39.       2.属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。
  40.       3.但属性的值仍然可以修改。
  41.       4.尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性，结果会静默失败或抛出TypeError 异常（严格模式）。

freeze 冻结一个对象&isFrozen 判断一个对象是否已经被冻结

  1. 冻结对象是指那些不能添加新的属性，不能修改已有属性的值，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性的对象。也就是说，这个对象永远是不可变的。
  3. 1.先讲freeze 方法：
  4. let o3 = {a: 1}
  6. o3.b = 2      //添加属性b成功
  7. Object.freeze(o3)
  9. Object.isFrozen(o3)    //true 对象已被冻结
  11. o3.a = 2       //修改属性a值失败
  12. o3.c = 5       //添加属性c失败
  13. delete o3.b   //删除属性b失败
  15. 2.再讲isfrozen 方法：
  17. let o4 = {a: 1}
  19. o4.b = 2     // 添加属性b成功
  20. Object.priventExtensions(o4)
  21. Object.defineProperties(o4, {
  22.     a: {configurable: false, writable: false},
  23.     b: {configurable: false, writable: false}
  24. })
  26. Object.isFrozen(o4)    //true o4 已经被冻结
  29. 总结：
  30.     1.冻结对象的所有自身属性都不可能以任何方式被修改。
  31.     2.任何尝试修改该对象的操作都会失败，可能是静默失败，也可能会抛出异常（严格模式中）。
  32.     3.数据属性的值不可更改，访问器属性（有getter和setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。
  33.     4.如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非它也是个冻结对象。
  36. 浅冻结与深冻结：
  37. (function () {
  38.     obj = {
  39.         internal :{}
  40.     };
  41.     Object.freeze(obj);//浅冻结
  42.     obj.internal.a = "aValue";
  43.     console.log(obj.internal.a);//"aValue"
  45.     //想让一个对象变得完全冻结,冻结所有对象中的对象,可以使用下面的函数.
  46.     function deepFreeze(o){
  47.         var prop,propKey;
  48.         Object.freeze(o);//首先冻结第一层对象
  49.         for(propKey in o){
  50.             prop = o[propKey];
  51.             if(!o.hasOwnProperty(propKey) || !(typeof prop === "object") || Object.isFrozen(prop)){
  52.                 continue;
  53.             }
  54.             deepFreeze(prop);//递归
  55.         }
  56.     }
  58.     deepFreeze(obj);
  59.     obj.internal.b = "bValue";//静默失败
  60.     console.log(obj.internal.b);//undefined
  61. })();

hasOwnProperty

  1. 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性
  3. let o = {a: 1 }
  5. o.hasOwnProperty('a')   //true
  6. o.hasOwnProperty('b')   //false   对象自身没有属性b
  7. o.hasOwnProperty('toString');  //false  不能检测对象原型链上的属性
  10. 如何遍历一个对象的所有自身属性，例子：
  11. var buz = {
  12.     fog: 'stack'
  13. };
  15. for (var name in buz) {
  16.     if (buz.hasOwnProperty(name)) {
  17.        console.log("this is fog (" + name + ") for sure. Value: " + buz[name]);
  18.     }
  19.     else {
  20.        console.log(name); // toString or something else
  21.     }
  22. }

isPrototypeOf

  1. isPrototypeOf方法用于测试一个对象是否存在于另一个对象的原型链上
  3. function Foo() {}
  4. function Bar() {}
  5. function Baz() {}
  7. Bar.prototype = Object.create(Foo.prototype);
  8. Baz.prototype = Object.create(Bar.prototype);
  10. var baz = new Baz();
  12. console.log(Baz.prototype.isPrototypeOf(baz)); // true
  13. console.log(Bar.prototype.isPrototypeOf(baz)); // true
  14. console.log(Foo.prototype.isPrototypeOf(baz)); // true
  15. console.log(Object.prototype.isPrototypeOf(baz)); // true

propertyIsEnumerable指定的属性是否可枚举

  1. obj.propertyIsEnumerable(prop)   prop为被测试的属性名
  3. 1. 一般情况下
  4. var o = {};
  5. var a = [];
  6. o.prop = 'is enumerable';
  7. a[0] = 'is enumerable';
  9. o.propertyIsEnumerable('prop');   //  返回 true
  10. a.propertyIsEnumerable(0);        // 返回 true
  13. 2. 浏览器内置对象
  14. var a = ['is enumerable'];
  16. a.propertyIsEnumerable(0);          // 返回 true
  17. a.propertyIsEnumerable('length');   // 返回 false
  19. Math.propertyIsEnumerable('random');   // 返回 false
  20. this.propertyIsEnumerable('Math');     // 返回 false
  22. 3. 自身属性和继承属性
  23. （原型链上propertyIsEnumerable不被考虑）
  25. var fn = function(){
  26.     this.prop = '123';
  27. }
  29. fn.prototype = { prototypeProp: true}
  31. var o = new fn()
  33. o.propertyIsEnumerable('prop')               // true
  34. o.propertyIsEnumerable('prototypeProp')   // false

caller 返回当前函数的调用者

  1. function test(){
  2.     if(test.caller == null){
  3.         alert("JavaScript顶层作用域调用了test()函数");
  4.     }else{
  5.         alert( test.caller + "函数调用了test()函数");
  6.     }
  7. };
  8. test(); // JavaScript顶层作用域调用了test()函数
  11. function callTest(){
  12.     test();
  13. }
  14. callTest(); // function callTest(){ test(); }函数调用了test()函数
  18. function callTest2(){
  19.     // setTimeout()或setInterval()中定时执行的函数也属于顶层作用域调用
  20.     setTimeout(test, 5000); // JavaScript顶层作用域调用了test()函数
  21. }
  22. callTest2();

valueOf 需要返回对象的原始值

  1. 备注：js对象中的valueOf()方法和toString()方法非常类似，但是，当需要返回对象的原始值而非字符串的时候才调用它，尤其是转换为数字的时候。如果在需要使用原始值的上下文中使用了对象，JavaScript就会自动调用valueOf()方法。
  3. const o = {a: 1, valueOf: function(){ return 123123 } }
  4. Number(o)    //123123
  6. // 给大家出一个题
  7. const o2 = {
  8.     x: 1,
  9.     valueOf: function(){
  10.         return this.x++
  11.     }
  12. }
  14. if(o2 == 1 && o2 == 2 && o2 == 3){
  15.     console.log('down')
  16.     console.log(o2.x)
  17. }else{
  18.     console.log('faild')
  19. }
  21. // Array：返回数组对象本身
  22. var array = ["CodePlayer", true, 12, -5];
  23. array.valueOf() === array;   // true
  25. // Date：当前时间距1970年1月1日午夜的毫秒数
  26. var date = new Date(2013, 7, 18, 23, 11, 59, 230);
  27. date.valueOf()     // 1376838719230
  29. // Number：返回数字值
  30. var num =  15.26540;
  31. num.valueOf()     // 15.2654
  33. // 布尔：返回布尔值true或false
  34. var bool = true;
  35. bool.valueOf() === bool    // true
  36. // new一个Boolean对象
  37. var newBool = new Boolean(true);
  38. // valueOf()返回的是true，两者的值相等
  39. newBool.valueOf() == newBool     // true
  40. // 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型
  41. newBool.valueOf() === newBool     // false
  43. // Function：返回函数本身
  44. function foo(){ 
  45. }
  46. foo.valueOf() === foo      // true
  47. var foo2 =  new Function("x", "y", "return x + y;");
  48. foo2.valueOf() === foo2    // true
  50. // Object：返回对象本身
  51. var obj = {name: "张三", age: 18};
  52. obj.valueOf() === obj        // true
  54. // String：返回字符串值
  55. var str = "http://www.365mini.com";
  56. str.valueOf() === str       // true
  57. // new一个字符串对象
  58. var str2 = new String("http://www.365mini.com");
  59. // 两者的值相等，但不全等，因为类型不同，前者为string类型，后者为object类型
  60. str2.valueOf() === str2      // false

getOwnPropertySymbols在给定对象自身上找到的所有 Symbol 属性的数组。

  1. var obj = {};
  2. var a = Symbol("a");
  3. var b = Symbol.for("b");
  5. obj[a] = "localSymbol";
  6. obj[b] = "globalSymbol";
  8. var objectSymbols = Object.getOwnPropertySymbols(obj);
  10. console.log(objectSymbols.length); // 2
  11. console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
  12. console.log(objectSymbols[0])      // Symbol(a)

toString toLocalString

  1. toString 方法不做过多介绍
  2. 区别：
  3. 当被转化的值是个时间对象时，toLocaleString会将转化的结果以本地表示。
  5. (new Date).toString(); //"Mon Nov 06 2017 13:02:46 GMT+0800 (China Standard Time)"
  7. (new Date).toLocaleString();  //"2017/11/6 下午1:03:12"
  9. 另外当被转化的值是个时间戳时，toLocaleString会把时间戳每三位添加一个逗号，代码如下。
  11. (Date.parse(new Date())).toLocaleString() //"1,509,944,637,000"
  13. (Date.parse(new Date())).toString() //"1509944643000"