JavaScript中方對象拷貝方法

這篇文章主要講解了“JavaScript中方對象拷貝方法”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“JavaScript中方對象拷貝方法”吧！

說到javascript中的對象拷貝，首先我們想到的是Object.assign()

JSON.parse(JSON.stringify()),還有ES6的展開操作符[...]

因為在js中=運算符 對于對象來說，不能創建副本，只是對該對象的引用

運算符

var x = {
  a: 1,
  b: 2,
};
y = x;
x.a = 10;
console.log(x); //{a:10, b:2}
console.log(y); //{a:10, b:2}

所以在進行對象操作時，運算符等于號（=）不可取

Object.assign()

var x = {
  a: 1,
  b: 2,
};
y = Object.assign({}, x);
x.a = 10;
console.log(x); //{a:10, b:2}
console.log(y); //{a:1, b:2}

初看，不會發現異常，因為所要的就是我們所要的結果，把對象結構弄再稍微復雜些再看

var x = {
  a: 1,
  b: 2,
  c: {
    d: 3,
  },
};
y = Object.assign({}, x);

x.a = 5;
console.log(x); //{a:5, b:2, c:{d:3}}
console.log(y); //{a:5, b:2, c:{d:3}}

x.c.d = 10;
console.log(x); //{a:5, b:2, c:{d:10}}
console.log(y); //{a:5, b:2, c:{d:10}}

此時就發現坑了，那么已經證明了Object.assign()只是實現了對象的淺拷貝

Object.assign()還需要注意的一點是，原型鏈上屬性的不可枚舉對象是無法復制的，看一下代碼：

var x = {
  a: 1,
};
var y = Object.create(x, {
  b: {
    value: 2,
  },
  c: {
    value: 3,
    enumerable: true,
  },
});
var z = Object.assign({}, y);
console.log(z); //{c:3}

拿到z的值很讓人意外，因為x是y的原型鏈，所以x不會被復制

屬性b是不可枚舉屬性，也不會被復制

只有c具有可枚舉描述，他可以被枚舉，所以才能被復制

以上的坑也可以很好的被解決，且往下看：

深拷貝JSON.parse(JSON.stringify())

解決淺拷貝的坑

var x = {
  a: 1,
  b: 2,
  c: {
    d: 3,
  },
};
y = JSON.parse(JSON.stringify(x));
x.a = 5;
x.c.d = 10;
console.log(x); //{a:5, b:2, c:{d:10}}
console.log(y); //{a:1, b:2, c:{d:3}}

當然普通的對象，此種復制方式已經是基本是完美了，那么他的坑在哪里呢

var x = {
  a: 1,
  b: function b() {
    return "2";
  },
};
y = JSON.parse(JSON.stringify(x));
z = Object.assign({}, x);

console.log(y); //{a:1}
console.log(z); //{a:1, b:function b(){return '2'}}

從結果看來，Object.assign()可以復制方法，JSON.parse(JSON.stringify())不可以

再來看第第二個坑：

var x = {
  a: 1,
  b: {
    c: 2,
    d: 3,
  },
};

x.c = x.b;
x.d = x.a;
x.b.c = x.c;
x.b.d = x.d;

var y = JSON.parse(JSON.stringify(x));
console.log(x);

/*
Uncaught TypeError: Converting circular structure to JSON

    at JSON.stringify (<anonymous>)
    at <anonymous>:8:25

*/

報錯了，其結果表明JSON.parse(JSON.stringify()),不能拷貝循環引用對象

再來看看Object.assign()

var x = {
  a: 1,
  b: {
    c: 2,
    d: 3,
  },
};

x.c = x.b;
x.d = x.a;
x.b.c = x.c;
x.b.d = x.d;

var y = Object.assign({}, x);
console.log(x);
/*
[object Object]{
a:1, 
b:[object, Object], 
d:[object, Object], 
d:1
}
*/

使用展開操作符[... ]

對象字面量的展開操作符目前是ECMAScript的第 3 階段提案，拷貝對象更加簡單了

var x = [
  "a",
  "b",
  "c",
  "d",
  {
    e: 1,
  },
];
var y = [...x];
console.log(y); //['a', 'b', 'c', 'd', {'e':1}]

var m = {
  a: 1,
  b: 2,
  c: ["d", "e"],
};
var n = {
  ...m,
};
console.log(n); //{a:1, b:2, c:['d', 'e']}

需要注意的是展開操作符也是淺拷貝。那么復制對象這廝真的這么難搞嗎？

自己造輪子：

function copy(x) {
  var y = {};
  for (m in x) {
    y[m] = x[m];
  }
  return y;
}
var o = {
  a: 1,
  b: 2,
  c: {
    d: 3,
    e: 4,
  },
};
var p = copy(o);

有人說這么干應該沒多大問題了吧。那么只能呵呵了，繼續走

var x = {};

Object.defineProperty(x, "m", {
  value: 5,
  writable: false,
});

console.log(x.m); //5
x.m = 25; //這一步沒報錯，但是也沒執行
console.log(x.m); //5

感謝各位的閱讀，以上就是“JavaScript中方對象拷貝方法”的內容了，經過本文的學習后，相信大家對JavaScript中方對象拷貝方法這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！