摘要：一可以用作對象的復(fù)制可以用作對象的合并注意目標(biāo)對象自身也會改變。對象四返回一個(gè)數(shù)組，包括對象自身的不含繼承的所有可枚舉屬性不含屬性的鍵名。該方法返回被凍結(jié)的對象。方法判斷一個(gè)對象是否被凍結(jié)。

JavaScript對Object對象的一些常用操作總結(jié)。

1.可以用作對象的復(fù)制

var obj = { a: 1 };
var copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }

2.可以用作對象的合并

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 } 注意目標(biāo)對象自身也會改變。

3.目標(biāo)對象o1自身也發(fā)生了改變，假如不想讓o1改變，可以把三個(gè)對象合并到一個(gè)空的對象中，操作如下：

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

注意：以下幾個(gè)地方
1.繼承屬性和不可枚舉屬性是不能拷貝的

var obj = Object.create({foo: 1}, { // foo 是個(gè)繼承屬性
    bar: {
        value: 2  // bar 是個(gè)不可枚舉屬性。
    },
    baz: {
        value: 3,
        enumerable: true  // baz 是個(gè)自身可枚舉屬性
    }
});

var copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }

2.原始類型會被包裝為 object

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

Object.create()的不止是有一個(gè)參數(shù)，其實(shí)還有第二個(gè)參數(shù)！
Object.create(proto, [ propertiesObject ])第二個(gè)參數(shù)是可選的，主要用于指定我們創(chuàng)建的對象的一些屬性，（例如：是否可讀、是否可寫，是否可以枚舉等等）可以通過下面案例來了解第二個(gè)參數(shù)！

var o;
o = Object.create(Object.prototype, {
  // foo會成為所創(chuàng)建對象的數(shù)據(jù)屬性
  foo: { writable:true, configurable:true, value: "hello" },
  // bar會成為所創(chuàng)建對象的訪問器屬性
  bar: {
    configurable: false,
    get: function() { return 10 },
    set: function(value) { console.log("Setting `o.bar` to", value) }
}})

// 創(chuàng)建一個(gè)以另一個(gè)空對象為原型，且擁有一個(gè)屬性p的對象
o = Object.create({}, { p: { value: 42 } })

// 省略了的屬性特性默認(rèn)為false,所以屬性p是不可寫,不可枚舉,不可配置的
o.p = 24
o.p
//42

o.q = 12
for (var prop in o) {
   console.log(prop)
}
//"q"

delete o.p
//false

//創(chuàng)建一個(gè)可寫的,可枚舉的,可配置的屬性p
o2 = Object.create({}, { p: { value: 42, writable: true, enumerable: true, configurable: true } });

用來判斷兩個(gè)值是否是同一個(gè)值。

下面是一些例子，面試中可能會提及

Object.is("haorooms", "haorooms");     // 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
Object.keys(obj)

返回一個(gè)由一個(gè)給定對象的自身可枚舉屬性組成的數(shù)組，數(shù)組中屬性名的排列順序和使用 for...in 循環(huán)遍歷該對象時(shí)返回的順序一致 （兩者的主要區(qū)別是 一個(gè) for-in 循環(huán)還會枚舉其原型鏈上的屬性）。

let arr = ["a", "b", "c"];
console.log(Object.keys(arr));
// ["0", "1", "2"]
 
/* Object 對象 */
let obj = { foo: "bar", baz: 42 },
keys = Object.keys(obj);
console.log(keys);
// ["foo","baz"]  

Object.keys返回一個(gè)數(shù)組，包括對象自身的（不含繼承的）所有可枚舉屬性（不含 Symbol 屬性）的鍵名。

// simple array
var arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // console: ["0", "1", "2"]

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

// array like object with random key ordering
var anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(anObj)); // console: ["2", "7", "100"]

// getFoo is a property which isn"t enumerable
var myObj = Object.create({}, {
  getFoo: {
    value: function () { return this.foo; }
  } 
});
myObj.foo = 1;
console.log(Object.keys(myObj)); // console: ["foo"]

方法返回一個(gè)給定對象自己的所有可枚舉屬性值的數(shù)組，值的順序與使用for...in循環(huán)的順序相同 ( 區(qū)別在于 for-in 循環(huán)枚舉原型鏈中的屬性 )。 Object.values會過濾屬性名為 Symbol 值的屬性。

var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(an_obj)); // ["b", "c", "a"]
 
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj)); // ["a", "b", "c"]

返回一個(gè)給定對象自身可枚舉屬性的鍵值對數(shù)組，其排列與使用 for...in 循環(huán)遍歷該對象時(shí)返回的順序一致（區(qū)別在于 for-in 循環(huán)也枚舉原型鏈中的屬性）。

const obj = { foo: "bar", baz: 42 };
console.log(Object.entries(obj)); // [ ["foo", "bar"], ["baz", 42] ]     
const simuArray = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(simuArray)); // [ ["0", "a"], ["1", "b"], ["2", "c"] ]

1.刪除對象中的某個(gè)值，前面案例中也謝了可以直接用delete

var obj = {b:123};
delete o.p // 或delete  obj[b];

2.遍歷對象
2.1for-in遍歷

var obj = {a: "ss", b: "bb", c: "cc"};
for (var i in obj){
    console.log(i+":"+obj[i]);
}

2.2forEach遍歷,先通過Object.keys()返回一個(gè)數(shù)組

Object.keys(obj).forEach((value, index)=>{
    console.log(value, index,obj[value]);
});
//等同于
Object.keys(obj).forEach(function (value, index,c) {
    console.log(value, index,obj[value]);
});

2.3jQuery的$.each()方法：它接受兩個(gè)參數(shù)，分別指代屬性名和屬性值

$.each(obj,function(key,value){
    console.log(key+": "+value)

1.Object.freeze() 方法可以凍結(jié)一個(gè)對象，凍結(jié)指的是不能向這個(gè)對象添加新的屬性，不能修改其已有屬性的值，不能刪除已有屬性，以及不能修改該對象已有屬性的可枚舉性、可配置性、可寫性。也就是說，這個(gè)對象永遠(yuǎn)是不可變的。該方法返回被凍結(jié)的對象。

2.Object.isFrozen() 方法判斷一個(gè)對象是否被凍結(jié)（frozen）。

3.Object.isExtensible() 方法判斷一個(gè)對象是否是可擴(kuò)展的（是否可以在它上面添加新的屬性）。

4.Object.isSealed() 方法判斷一個(gè)對象是否是密封的（sealed）。

5.Object.seal() 方法可以讓一個(gè)對象密封，并返回被密封后的對象。密封對象是指那些不能添加新的屬性，不能刪除已有屬性，以及不能修改已有屬性的可枚舉性、可配置性、可寫性，但可能可以修改已有屬性的值的對象。

6.Object.getOwnPropertyNames(obj)返回一個(gè)數(shù)組，包含對象自身的所有屬性（不含 Symbol 屬性，但是包括不可枚舉屬性）的鍵名。

7.Object.getOwnPropertySymbols(obj)返回一個(gè)數(shù)組，包含對象自身的所有 Symbol 屬性的鍵名。

8.Reflect.ownKeys(obj)返回一個(gè)數(shù)組，包含對象自身的所有鍵名，不管鍵名是 Symbol 或字符串，也不管是否可枚舉。

9.hasOwnProperty()判斷對象自身屬性中是否具有指定的屬性。

JavaScript字符串操作方法大全，包含ES6方法

JavaScript常用數(shù)組操作方法，包含ES6方法