typescript - Valfria typade omedelbart destrukturerade parametrar?

Hur skriver jag valfria typade parametrar som omedelbart destrueras?

För att ge ett exempel vill jag att följande funktion ska kunna anropas utan att ange någon parameter.

const foo = ({bar}: {bar?: boolean}) => {};

Som det är nu, klagar TypeScript på att en parameter saknas.

Svar #1

Antagligen är du missnöjd med följande fel:

const fooBad = ({ bar }?: { bar?: boolean }) => {}; // error!
// ┌──────────> ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
// A binding pattern parameter cannot be optional in an implementation signature.

Vilket är logiskt, eftersom du inte kan destrukturera undefined. Vad du kan göra, i TypeScript, är att använda en standardfunktionparameter. Detta behandlas som en valfri parameter från den anropande sidan av funktionen (så du kan utelämna den), och på implementeringssidan sätts ett värde på parametern om den är undefined.

Så, vad vill du destrukturera om någon anropar foo()? Jag antar att du vill att bar ska vara undefined, eller hur? Det skulle alltså innebära att du antingen skickar in något som {bar: undefined}, eller (eftersom bar är valfri) det tomma objektet {}:

const foo = ({ bar }: { bar?: boolean } = {}) => {
  console.log(bar);
};

Jag har lagt till console.log(bar) så att du kan se vad det blir när du anropar det:

foo(); // undefined
foo({}); // undefined
foo({bar: true}); // true

Ser bra ut för mig. Hoppas det hjälper; lycka till!

Länk till kod

Svar #2

Detta är inte möjligt, helt enkelt eftersom det inte fungerar i JavaScript heller. Ta till exempel denna bit av JS:

const foo = ({bar}) => {
  ...
};

foo({ bar: 123 }); // works
foo(); // error

Att anropa foo utan en objektparameter kommer att resultera i detta undantag:

Uncaught TypeError: Cannot destructure property `bar` of 'undefined' or 'null'.

Detta händer eftersom funktionsimplementeringen ovan nästan är samma som att skriva:

const foo = (arg1) => {
  let bar = arg1.bar;
};

foo();

Undantaget skulle vara nästan detsamma här, eftersom arg1.bar försöker komma åt en egenskap på ett objekt som är undefined.

Kort sagt, JavaScript känner inte till "valfria" parametrar vid körning, därför tillåter inte heller TypeScript dem.

Relaterade artiklar