Typescript returnerar objekt utan null- eller undefined-värden

Vi använder en cleanNullOrUndefined-funktion i vår kodbas, som tar bort nycklar i ett objekt om värdet på nyckeln är null eller undefined. Detta är inte vältypat och returnerar bara en Partial av det ursprungliga objektet vilket ger vissa fel på andra ställen.

Vad vi behöver är att skriva funktionen så att den returnerar objektet, med nycklar som är null eller undefined borttagna och härledda typer för de andra nycklarna.

Exempel :

const obj = {
  a: 1,
  b: 'string',
  c: false,
  d: null,
  e: undefined
}

// Desired return type

interface ReturnType {
  a: number,
  b: string,
  c: boolean
}

Jag verkar inte kunna förstå hur man gör det här.

Svar #1

Tänk på det här exemplet:

const obj = {
  a: 1,
  b: 'string',
  c: false,
  d: null,
  e: undefined
}

type Validate<T> = Pick<T, {
  [Prop in keyof T]: T[Prop] extends null | undefined ? never : Prop
}[keyof T]>;

// type Test = {
//     a: 1;
//     b: 'string';
//     c: false;
// }
type Test = Validate<{
  a: 1,
  b: 'string',
  c: false,
  d: null,
  e: undefined
}>

const util = <Obj,>(obj: Obj): Validate<Obj> => {
  return 'NOT IMPLEMENTED' as any
}

const result = util({
  a: 1,
  b: 'string',
  c: false,
  d: null,
  e: undefined
})

result.a // ok
result.e // error

Lekplats

Validate itererar genom varje objekts nyckel och kontrollerar om den sträcker sig över null | undefined eller inte. Om ja - returnera never, annars - returnera nyckelnamn Prop. [keyof T] - hämtar till slut alla värden från det nyskapade objektet. Pick - får i sin tur igen endast giltiga nycklar från T.

Svar #2

Följande är förmodligen halva svaret. Jag ville visa att du kan få destinationsobjektet med bara en rad (kedja) kod:

const obj = {
  a: 1,
  b: 'string',
  c: false,
  d: null,
  e: undefined
};

const dest = Object.keys(obj)
    .filter(a => obj[a] !== null && obj[a] !== undefined)
    .reduce((c, a) => { c[a] = obj[a]; return c; }, {});

console.log(dest);

Men det kan finnas mycket mer, bara för att få den resulterande typen att härledas korrekt. Frågan är - behöver du det verkligen? ;)

Relaterade artiklar