Website-Suche

Unterschied zwischen 'object', {} und Object in TypeScript

Versuche herauszufinden, was der Unterschied zwischen diesen 2 Typen in TypeScript ist:

foo: object

und

bar: {}

und type: Object ?

Beispiel: Versuch, einem object die Variable zuzuweisen, die eigentlich die Kopfzeileninformationen für eine Anfrage verarbeiten soll:

headers: object;

Ergibt einen Fehler:

Der Typ 'object' kann nicht '{ [key: string]: string }' zugewiesen werden.

Die gleiche Bedingung tritt auf, wenn headers: {} verwendet wird, was zu dem Schluss führt, dass {} etwas weniger strenge Anforderungen hat.

Antwort #1

TypeScript hat drei verwirrende Typen: {}, Object und object. Sie können undefined oder null keinem dieser Typen zuweisen, außer wenn die strictNullChecks-Compileroption deaktiviert ist.

{}

{} enthält nicht-nullbare Werte, das heißt alle Werte außer undefined und null. Beachten Sie, dass {} sich nicht auf Objekte ohne Eigenschaften bezieht.

Objekt

Object enthält Werte mit gemeinsamen eingebauten Instanz-Eigenschaften (constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString und valueOf). Es ist strenger als {}, da es einige eingebaute Eigenschaften erfordert. Zum Beispiel können undefined, null und { toString() { return 1; } } nicht Object zugewiesen werden (vgl. @golmschenk Kommentar).

Objekt

object enthält nicht-primitives Werte, das heißt Werte, die nicht vom Typ Undefined, Null, Boolean, Number, BigInt, String oder Symbol sind. object wurde in TypeScript 2.2 eingeführt.

Also :

const x: {} = {};
const y: Object = {};
const z: object = {};
let headers: { [key: string]: string };
headers = x; // okay: {} is assignable to { [key: string]: string }
headers = y; // error: Object is not assignable to { [key: string]: string }
headers = z; // error: object is not assignable to { [key: string]: string }

Antwort #2

Das folgende Beispiel zeigt, wie sich verschiedene Objekttypen unterschiedlich verhalten:

var o: object;
o = { prop: 0 }; // OK
o = []; // OK
o = 42; // Error
o = "string"; // Error
o = false; // Error
o = null; // Error
o = undefined; // Error

var p: {}; // or Object
p = { prop: 0 }; // OK
p = []; // OK
p = 42; // OK
p = "string"; // OK
p = false; // OK
p = null; // Error
p = undefined; // Error

var q: { [key: string]: any };
q = { prop: 0 }; // OK
q = []; // OK
q = 42; // Error
q = "string"; // Error
q = false; // Error
q = null; // Error
q = undefined; // Error

var r: { [key: string]: string };
r = { prop: 'string' }; // OK
r = { prop: 0 }; // Error
r = []; // Error
r = 42; // Error
r = "string"; // Error
r = false; // Error
r = null; // Error
r = undefined; // Error

Damit können wir sagen:

  • {}, das dem Typ Object entspricht, ist am wenigsten spezifisch. Sie können Objekte, Arrays und Primitive ihm zuweisen.
  • object ist spezifischer und ähnlich wie { [key: string]: any }. Sie können Objekte und Arrays darauf zuweisen, aber keine primitiven Werte.
  • { [key: string]: string } ist das spezifischste, das keine primitiven Typen, Arrays oder Objekte mit einem Nicht-String-Wert zugewiesen werden darf.

Link zum TypeScript-Spielplatz

Verwandte Artikel