Forskjellen mellom 'object', {} og Object i TypeScript

Prøver å finne ut forskjellen mellom disse to typene i TypeScript:

foo: object

og

bar: {}

og type: Object ?

Eksempel: prøve å tilordne et objekt til variabelen som skal håndtere overskriftsinformasjon for en forespørsel:

headers: object;

Resulterer i en feil:

Type 'object' kan ikke tildeles til '{ [key: string]: string }'.

Den samme tilstanden oppstår hvis man bruker headers: {}, noe som fører til konklusjonen at {} har noen litt mindre strenge krav.

Svar #1

TypeScript har tre forvirrende typer: {}, Object og object. Du kan ikke tilordne undefined eller null til noen av disse typene med mindre strictNullChecks kompilatoralternativet er deaktivert.

{}

{} inneholder ikke-null verdier, det vil si alle verdier unntatt undefined og null. Merk at {} ikke refererer til objekter uten egenskaper.

Objekt

Object inneholder verdier med vanlige innebygde instans-egenskaper (constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString og valueOf). Det er strengere enn {} siden det krever noen innebygde egenskaper. For eksempel kan undefined, null og { toString() { return 1; } } ikke tildeles Object (jf. @golmschenk sin kommentar).

objekt

object inneholder ikke-primitive verdier, det vil si verdier som ikke er av typen Undefined, Null, Boolean, Number, BigInt, String eller Symbol. object ble introdusert i TypeScript 2.2.

Dermed :

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 }

Svar #2

Følgende eksempel viser hvordan forskjellige typer objekter oppfører seg forskjellig:

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

Med det kan vi si:

  • {} som er det samme som typen Object, er den minst spesifikke. Du kan tilordne objekter, arrayer og primitive verdier til den.
  • object er mer spesifikt og ligner på { [key: string]: any }. Du kan tilordne objekter og matriser til det, men ikke primitive typer.
  • { [key: string]: string } er den mest spesifikke, som ikke tillater at noen primitive typer, arrayer eller objekter med en ikke-streng verdi tildeles til den.

Lenke til TypeScript-lekeplass

Relaterte artikler