Object.assign()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Die Object.assign()
statische Methode
kopiert alle enumerablen
eigenen Eigenschaften von einem oder mehreren
Quellobjekten in ein Zielobjekt. Sie gibt das modifizierte Zielobjekt
zurück.
Probieren Sie es aus
const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source);
console.log(target);
// Expected output: Object { a: 1, b: 4, c: 5 }
console.log(returnedTarget === target);
// Expected output: true
Syntax
Object.assign(target)
Object.assign(target, source1)
Object.assign(target, source1, source2)
Object.assign(target, source1, source2, /* …, */ sourceN)
Parameter
target
-
Das Zielobjekt — das Objekt, auf das die Eigenschaften der Quellen angewendet werden und das nach der Modifikation zurückgegeben wird.
source1
, …,sourceN
-
Die Quellobjekte — Objekte, die die anzuwendenden Eigenschaften enthalten.
Rückgabewert
Das Zielobjekt.
Beschreibung
Eigenschaften im Zielobjekt werden durch Eigenschaften in den Quellen überschrieben, wenn sie denselben Schlüssel haben. Eigenschaften späterer Quellen überschreiben die früherer.
Die Object.assign()
-Methode kopiert nur enumerable und eigene Eigenschaften von einem Quellobjekt in ein Zielobjekt. Sie verwendet [[Get]]
auf der Quelle und [[Set]]
am Ziel, daher ruft sie Getter und Setter auf. Dadurch weist sie die Eigenschaften zu, anstatt neue Eigenschaften zu kopieren oder zu definieren. Dies kann sie ungeeignet machen, um neue Eigenschaften in ein Prototyp zu integrieren, wenn die Merge-Quellen Getter enthalten.
Zum Kopieren von Eigenschaftsdefinitionen (einschließlich ihrer Enumerierbarkeit) in Prototypen, verwenden Sie stattdessen Object.getOwnPropertyDescriptor()
und Object.defineProperty()
.
Sowohl String
- als auch Symbol
-Eigenschaften werden kopiert.
Im Falle eines Fehlers, z. B. wenn eine Eigenschaft nicht beschreibbar ist, wird ein TypeError
ausgelöst, und das target
-Objekt wird geändert, falls vor Auftreten des Fehlers Eigenschaften hinzugefügt wurden.
Beispiele
Klonen eines Objekts
const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }
Warnung für Deep Clone
Für Deep Cloning müssen wir Alternativen wie structuredClone()
verwenden, da Object.assign()
Werte der Eigenschaften kopiert.
Wenn der Quellwert ein Verweis auf ein Objekt ist, wird nur der Referenzwert kopiert.
const obj1 = { a: 0, b: { c: 0 } };
const obj2 = Object.assign({}, obj1);
console.log(obj2); // { a: 0, b: { c: 0 } }
obj1.a = 1;
console.log(obj1); // { a: 1, b: { c: 0 } }
console.log(obj2); // { a: 0, b: { c: 0 } }
obj2.a = 2;
console.log(obj1); // { a: 1, b: { c: 0 } }
console.log(obj2); // { a: 2, b: { c: 0 } }
obj2.b.c = 3;
console.log(obj1); // { a: 1, b: { c: 3 } }
console.log(obj2); // { a: 2, b: { c: 3 } }
// Deep Clone
const obj3 = { a: 0, b: { c: 0 } };
const obj4 = structuredClone(obj3);
obj3.a = 4;
obj3.b.c = 4;
console.log(obj4); // { a: 0, b: { c: 0 } }
Zusammenführen von Objekten
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 }, target object itself is changed.
Zusammenführen von Objekten mit denselben Eigenschaften
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 }
Die Eigenschaften werden von anderen Objekten, die in der Parameterreihenfolge später kommen, überschrieben, wenn sie dieselben Eigenschaften haben.
Kopieren von Symbol-typisierten Eigenschaften
const o1 = { a: 1 };
const o2 = { [Symbol("foo")]: 2 };
const obj = Object.assign({}, o1, o2);
console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)
Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
Eigenschaft auf der Prototyp-Kette und nicht-enumerable Eigenschaften können nicht kopiert werden
const obj = Object.create(
// foo is on obj's prototype chain.
{ foo: 1 },
{
bar: {
value: 2, // bar is a non-enumerable property.
},
baz: {
value: 3,
enumerable: true, // baz is an own enumerable property.
},
},
);
const copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }
Primitive werden zu Objekten umgewandelt
const v1 = "abc";
const v2 = true;
const v3 = 10;
const v4 = Symbol("foo");
const obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// Primitives will be wrapped, null and undefined will be ignored.
// Note, only string wrappers can have own enumerable properties.
console.log(obj); // { "0": "a", "1": "b", "2": "c" }
Ausnahmen unterbrechen die laufende Kopieraufgabe
const target = Object.defineProperty({}, "foo", {
value: 1,
writable: false,
}); // target.foo is a read-only property
Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
// TypeError: "foo" is read-only
// The Exception is thrown when assigning target.foo
console.log(target.bar); // 2, the first source was copied successfully.
console.log(target.foo2); // 3, the first property of the second source was copied successfully.
console.log(target.foo); // 1, exception is thrown here.
console.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied.
console.log(target.baz); // undefined, the third source will not be copied either.
Kopieren von Accessoren
const obj = {
foo: 1,
get bar() {
return 2;
},
};
let copy = Object.assign({}, obj);
console.log(copy);
// { foo: 1, bar: 2 }
// The value of copy.bar is obj.bar's getter's return value.
// This is an assign function that copies full descriptors
function completeAssign(target, ...sources) {
sources.forEach((source) => {
const descriptors = Object.keys(source).reduce((descriptors, key) => {
descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
return descriptors;
}, {});
// By default, Object.assign copies enumerable Symbols, too
Object.getOwnPropertySymbols(source).forEach((sym) => {
const descriptor = Object.getOwnPropertyDescriptor(source, sym);
if (descriptor.enumerable) {
descriptors[sym] = descriptor;
}
});
Object.defineProperties(target, descriptors);
});
return target;
}
copy = completeAssign({}, obj);
console.log(copy);
// { foo:1, get bar() { return 2 } }
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-object.assign |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
assign |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support