generici - Možete li deklarirati tip literalnog objekta koji dopušta nepoznata svojstva u TypeScriptu?

U suštini želim osigurati da argument objekta sadrži sva potrebna svojstva, ali može sadržavati i bilo koja druga svojstva koja želi. Na primjer:

function foo(bar: { baz: number }) : number {
    return bar.baz;
}

foo({ baz: 1, other: 2 });

Ali to rezultira u:

Object literal may only specify known properties, and 'other' does not exist in type '{ baz: number; }'.

Odgovor #1

Da, možeš. Pokušaj ovo:

interface IBaz {
    baz: number;
    [key: string]: any;
}

function foo(bar: IBaz) : number {
    return bar.baz;
}

foo({ baz: 1, other: 2 });

Odgovor #2

Pa, mrzim odgovarati na vlastita pitanja, ali drugi odgovori su potaknuli malo razmišljanja... Ovo funkcionira:

function foo<T extends { baz: number }>(bar: T): void {
    console.log(bar.baz);
}

foo({baz: 1, other: 2});

Odgovor #3

Ako poznata polja dolaze iz generičkog tipa, način da se dozvole wildcardi je s T & {[key: string]: unknown}, sva polja koja su poznata moraju odgovarati ograničenjima tipa, a ostala polja su dopuštena (i smatraju se tipom unknown)

Evo primjera:

type WithWildcards<T> = T & { [key: string]: unknown };

function test(foo: WithWildcards<{baz: number}>) {}

test({ baz: 1 }); // works
test({ baz: 1, other: 4 }); // works
test({ baz: '', other: 4 }); // fails since baz isn't a number

Tada, ako imate generički tip T, možete dozvoliti wildcard polja s WithWildCards<T>

Imajte na umu da dodatna svojstva nisu označena kao pogreške ako objekt dolazi od bilo čega osim od literalnog objekta, TS vam samo govori da je s tipiziranjem dodavanje tog svojstva u literalno oblikovanom objektu suvišno.

Evo nekoliko drugih slučajeva u kojima dodatna svojstva jesu i nisu dopuštena

interface Foos{
  a?: string
  b?: string
}
type WithWildcards<T> = T & { [key: string]: unknown };

declare function acceptFoos(foo: Foos): void;
declare function acceptWild(foo: WithWildcards<Foos>):void

acceptFoos(  {a:'', other: ''}) // ERROR since the property is extraneous
const data = {a:'', other: ''}
acceptFoos(  data) // allowed since it is compatible, typescript doesn't force you to remove the properties
const notCompat = {other: ''}
acceptFoos(notCompat) //ERROR: Type '{ other: string; }' has no properties in common with type 'Foos'
acceptFoos({a:'', ...notCompat}) // this is also allowed 
acceptWild(notCompat) // allowed

Odgovor #4

Ako želite omogućiti nepoznata svojstva za cijeli objekt, možete koristiti Record

function doStuff(payload: Record<string|number, unknown>): Record<string|number, unknown> {
  return { anyProp: 'anyValue' }
}

Povezani članci