Object

MDN-Object
思维导图

Object.png

1.Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象

语法：Object.assign(target, ...sources)

参数：
1.target:目标参数
2.sources:源对象

返回值：目标对象

注意：如果目标对象中的属性具有相同的键，则属性将会被源对象中的属性覆盖，后面的原对象的属性将类似地覆盖前面的源对象的属性。

因为Object.assign()拷贝的是属性值，。假如源对象的属性值是一个对象的引用，那么它也只指向那个引用;这里需要使用JSON.parse(JSON.stringify())

例子1：深拷贝问题
let obj1 = { a: 0 , b: { c: 0}}; 
let obj2 = Object.assign({}, obj1); 
console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} 
console.log(JSON.stringify(Object.assign({}, obj1))); // { 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}}

例子2：合并对象
const o1 = { a: 1 };
const o2 = { b: 2 };
const o3 = { c: 3 };

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

例子3：合并具有相同属性的对象
const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };

const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }

例子3：原始数据被包装为对象
const v1 = "abc";
const v2 = true;
const v3 = 10;
const v4 = Symbol("foo")

const obj = Object.assign({}, v1, null, v2, undefined, v3, v4); 
// 原始类型会被包装，null 和 undefined 会被忽略。
// 注意，只有字符串的包装对象才可能有自身可枚举属性。
console.log(obj); // { "0": "a", "1": "b", "2": "c" }

2.Object.create()方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。
3.Object.defineProperties() 方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象

语法：Object.defineProperties(obj, props)

参数：
1.obj:在其上定义或修改属性的对象
2.props:要定义其可枚举属性或修改的属性描述符的对象。

image.png

返回值：传递给函数的对象

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});
console.log(obj)//=>{property1: true, property2: "Hello"}

例子2：主要使用点在于get/set函数-设置计算属性

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  },
'property3': {
//可以在这个属性中修改其他属性的值
   set:function(newValue){
        this.property2 = newValue + 20
    },
   get:function(){
      return this.property2
   }
  }
});
obj.property3 = 30;
console.log(obj)//=>{property1: true, property2: "Hello"}
image.png

没有修改到property2的值，这是因为property2设置了writable为false,不可修改属性值

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: true
  },
'property3': {
    set:function(newValue){
        this.property2 = newValue + 20
    },
   get:function(){
      return this.property2
   }
  }
});
obj.property3 = 30
console.log(obj)

image.png

4.Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

语法：Object.defineProperty(obj, prop, descriptor)

参数：
obj:要定义属性的对象
prop:要定义或修改的属性的名称或 Symbol
descriptor:要定义或修改的属性描述符

返回值：被传递给函数的对象

注意：应当直接在 Object 构造器对象上调用此方法，而不是在任意一个 Object 类型的实例上调用

5.Object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）

语法：Object.entries(obj)
参数：obj:可以返回其可枚举属性的键值对的对象

返回值：定对象自身可枚举属性的键值对数组

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

例子1
var object1 = {
  a: 'somestring',
  b: 42
};
console.log(Object.entries(object1)) //=>[ ["a","somestring"],['b',42] ]

for (let [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`);
}
// "a: somestring"
// "b: 42"

例子2
const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });
myObj.foo = 'bar';
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]

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

例子3：
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"
});
image.png

6.Object.freeze() 方法可以冻结一个对象。

语法：Object.freeze(obj)

参数：obj：要被冻结的对象

返回值：被冻结的对象；返回传递的对象，而不是创建一个被冻结的副本

注意：一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性、以及不能修改已有属性的值。此外，冻结一个对象后该对象的原型也不能被修改。freeze()返回和传入的参数相同的对象；
如果一个属性的值是个对象，则这个对象的属性是可以修改的，除非它也是个冻结对象；
数组作为一种对象，被冻结，其元素不能被修改。没有数组元素可以被添加或移除；

例子1
const obj = {
  prop: 42
};

Object.freeze(obj);

obj.prop = 33;
// Throws an error in strict mode

console.log(obj.prop);
// expected output: 42

例子2：当其中一个属性是引用类型值,则该属性不会被冻结（浅冻结）
var obj = {
  a:[0,1,2],
  b:12
}
Object.freeze(obj)
obj.a.push(12)
console.log(obj);

image.png

深冻结：要使对象不可变，需要递归冻结每个类型为对象的属性
知识点：Object.getOwnPropertyNames()方法返回一个由指定对象的所有自身属性的属性名组成的数组

例子3：深冻结函数
// 深冻结函数.
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

7.Object.fromEntries() 方法把键值对列表转换为一个对象。

语法：Object.fromEntries(iterable);

参数：iterable：可迭代对象，类似 Array 、 Map或者其它实现了可迭代协议的对象

返回值：一个由该迭代对象条目提供对应属性的新对象

注意：该方法接收一个键值对的列表参数，并返回一个带有这些键值对的新对象。它生成一个具有两个元素的类数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值
Object.fromEntries()是Object.entries()的反转

例子1：Map 转化成 Object
const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
console.log(map)
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
image.png
例子2：Array 转化成 Object
const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }

例子3：对象转换
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1)
  .map(([ key, val ]) => [ key, val * 2 ])
);

console.log(object2);
// { a: 2, b: 4, c: 6 }

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

语法：Object.getPrototypeOf(object)

参数：obj：要返回其原型的对象

返回值：给定对象的原型。如果没有继承属性，则返回 null

例子1：
const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);//=>true

例子2：
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true

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

例子3：Object.getPrototypeOf(Object)  不是  Object.prototype
var obj = new Object();

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

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

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

9.Object.is() 方法判断两个值是否是相同的值

语法：Object.is(value1, value2);

参数：value1：第一个需要比较的值 value2：第二个需要比较的值

返回值：表示两个参数是否相同的布尔值

注意：这种相等性判断逻辑和传统的==运算不同，==运算符会对它两边的操作数做隐式类型转化，然后才做相等性比较，但是Object.is()不会做这种类型转化
Object.in()与===运算符的判定方式也不一样，===运算符和==运算符将数字值-0和+0视为相等，并认为Number.NaN不等于NaN

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

  • 两个值都是 undefined
  • 两个值都是 null
  • 两个值都是 true 或者都是 false
  • 两个值是由相同个数的字符按照相同的顺序组成的字符串
  • 两个值指向同一个对象
  • 两个值都是数字并且
    • 都是正零 +0
    • 都是负零 -0
    • 都是 NaN
    • 都是除零和 NaN 外的其它同一个数字
Object.is('foo', 'foo');     // true
Object.is(window, window);   // true

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

var foo = { a: 1 };
var bar = { a: 1 };
Object.is(foo, foo);         // true
Object.is(foo, bar);         // false

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

// 特例
Object.is(0, -0);            // false
Object.is(0, +0);            // true
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

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

语法：Object.isExtensible(obj)

参数：obj：需要检测的对象

返回值：表示给定对象是否可扩展的一个Boolean

注意：默认情况下，对象是可扩展的，即可为他们添加新的属性；Object.preventExtensions，Object.seal 或 Object.freeze方法都可以标记一个对象为不可扩展

// 新对象默认是可扩展的.
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

11.Object.isFrozen()方法判断一个对象是否被冻结

语法：Object.isFrozen(obj)

参数：obj：被检测的对象。

返回值：表示给定对象是否被冻结的Boolean

注意：一个对象的冻结是指它不可扩展，所有属性都是不可配置的，且所有数据属性(即没有getter或setter组件的访问器的属性)都是不可写的；
一个对象默认是可扩展的，所以它是非冻结的
让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象

// 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
// 因为p属性仍然是可以配置的(而且可写的).
var oneProp = { p: 42 };
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp) //=== false
//此时，如果删除了这个属性，则它会变成一个冻结对象
delete oneProp.p;
Object.isFrozen(oneProp) //=== 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

12.Object.isSealed() 方法判断一个对象是否被密封

语法：Object.isSealed(obj)
参数：obj：要被检查的对象。

返回值：表示给定对象是否被密封的一个Boolean

注意：如果这个对象是密封的，则返回 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

生成一个密封对象

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"可写

13.Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致

语法：Object.keys(obj)
参数：obj：要返回其枚举自身属性的对象

返回值：一个表示给定对象的所有可枚举属性的字符串数组

注意：如果你想获取一个对象的所有属性,，甚至包括不可枚举的，请查看Object.getOwnPropertyNames

例子1：数组
var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

例子2：类数组会按照key排序
var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj))//["2", "7", "100"]
var anObj = { 100: 'a', 2: 'b', 7: 'c' ,13:'d',8:'e'};
console.log(Object.keys(anObj))
["2", "7", "8", "13", "100"]

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

语法：Object.preventExtensions(obj)
参数：obj：将要变得不可扩展的对象

返回值：已经不可扩展的对象

注意：一般来说，不可扩展对象的属性可能仍然可被删除，
一旦将对象变为不可扩展的对象，就再也不能使其可扩展

// Object.preventExtensions将原对象变的不可扩展,并且返回原对象.
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2;  // true

15.hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

语法：obj.hasOwnProperty(prop)
参数：prop:要检测的属性的 String字符串形式表示的名称，或者 Symbol

返回值：用来判断某个对象是否含有指定的属性的布尔值 Boolean

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

例子1：即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true
o = new Object();
o.propOne = null;
o.hasOwnProperty('propOne'); // 返回 true
o.propTwo = undefined;  
o.hasOwnProperty('propTwo'); // 返回 true

例子2：自身属性和继承属性的区别
o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop');             // 返回 true
o.hasOwnProperty('toString');         // 返回 false
o.hasOwnProperty('hasOwnProperty');   // 返回 false

例子3：当某个对象占用该属性名的属性时，需要使用外部的`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

16.isPrototypeOf() 方法用于测试一个对象是否存在于另一个对象的原型链上。

语法：prototypeObj.isPrototypeOf(object)
参数：object：在该对象的原型链上搜寻

返回值：Boolean，表示调用对象是否在另一个对象的原型链上

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

17.propertyIsEnumerable() 方法返回一个布尔值，表示指定的属性是否可枚举。

语法：obj.propertyIsEnumerable(prop)
参数：prop:需要测试的属性名。

返回值：用来表示指定的属性名是否可枚举的布尔值。

例子1：对象和数组的基本用法
var o = {};
var a = [];
o.prop = 'is enumerable';
a[0] = 'is enumerable';

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

例子2：内置对象和用户自定义对象
var a = ['is enumerable'];

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

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

18.valueOf() 方法返回指定对象的原始值。

语法：object.valueOf()

返回值：返回值为该对象的原始值。

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

JavaSctipt的许多内置对象都重写了该函数，以实现更适合自身的功能需要；不同类型对象的valueOf方法的返回值和返回值类型可能不同
Array: 返回数组对象本身
Boolean: 布尔值
Date: 毫秒数
Function: 函数本身
Number: 数字值
Object： 对象本身
String: 字符串值

重写valueOf方法：MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; };MyNumberType是个对象

例子1：改写valueOf()方法
function MyNumberType(n) {
    this.number = n;
}

MyNumberType.prototype.valueOf = function() {
    return this.number;
};

var myObj = new MyNumberType(4);
myObj + 3; // 7

// 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());   // 1376838719230

// 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

19.Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。

语法：Object.seal(obj)
参数：obj:将要被密闭的对象

返回值：被密封的对象

注意：密封一个对象会让这个对象变得不能添加新的属性，且所有已有属性会变得不可配置。属性不可配置：属性变得不能删除，以及一个数据属性不能被重新定义成为访问器属性，但是属性值依然可以修改

var obj = {
  prop: function() {},
  foo: 'bar'
};

// 可以添加新的属性
// 可以更改或删除现有的属性
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

var o = Object.seal(obj);

o === obj; // true
Object.isSealed(obj); // === true

// 仍然可以修改密封对象的属性值
obj.foo = 'quux';


// 但是你不能将属性重新定义成为访问器属性
// 反之亦然
Object.defineProperty(obj, 'foo', {
  get: function() { return 'g'; }
}); // throws a TypeError

// 除了属性值以外的任何变化，都会失败.
obj.quaxxor = 'the friendly duck';
// 添加属性将会失败
delete obj.foo;
// 删除属性将会失败

// 在严格模式下，这样的尝试将会抛出错误
function fail() {
  'use strict';
  delete obj.foo; // throws a TypeError
  obj.sparky = 'arf'; // throws a TypeError
}
fail();

// 通过Object.defineProperty添加属性将会报错
Object.defineProperty(obj, 'ohai', {
  value: 17
}); // throws a TypeError
Object.defineProperty(obj, 'foo', {
  value: 'eit'
}); // 通过Object.defineProperty修改属性值

ES5中，如果参数不是一个对象，则会报错
Object.seal(1);
// TypeError: 1 is not an object (ES5 code)

Object.seal(1);
// 1

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

语法：Object.values(obj)
参数：obj:被返回可枚举属性值的对象

返回值：一个包含对象自身的所有可枚举属性值的数组

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

var obj = { foo: 'bar', baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

// array like object
var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj)); // ['a', 'b', 'c']

// array like object with random key ordering
// when we use numeric keys, the value returned in a numerical order according to the keys
var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo is property which isn't enumerable
var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
my_obj.foo = 'bar';
console.log(Object.values(my_obj)); // ['bar']

// non-object argument will be coerced to an object
console.log(Object.values('foo')); // ['f', 'o', 'o']

MDN-Object

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 215,076评论 6赞 497
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,658评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,732评论 0赞 350
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,493评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,591评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,598评论 1赞 293
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,601评论 3赞 415
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,348评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,797评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,114评论 2赞 330
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,278评论 1赞 344
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,953评论 5赞 339
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,585评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,202评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,442评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,180评论 2赞 367
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,139评论 2赞 352