Peut-on avoir des arguments déstructurés optionnels dans une fonction TypeScript ?

Je voudrais écrire une fonction qui prend un argument objet, utilise la déstructuration dans la signature de la fonction, et que cet argument soit optionnel :

myFunction({opt1, opt2}?: {opt1?: boolean, opt2?: boolean})

Cependant, TypeScript ne me permet pas ("Un paramètre de modèle de liaison ne peut pas être optionnel dans une signature d’implémentation.").

Bien sûr que je pourrais le faire si je ne déstructurais pas :

myFunction(options?: {opt1?: boolean, opt2?: boolean}) {
  const opt1 = options.opt1;
  const opt2 = options.opt1;
  ...

Il semble que ce devrait être la même chose, pourtant l'exemple du haut n'est pas autorisé.

J'aimerais utiliser une syntaxe déstructurée (1) parce qu'elle existe, qu'elle est agréable à utiliser, et il semble naturel que les deux fonctions ci-dessus devraient agir de la même manière, et (2) parce que je veux aussi une façon concise de spécifier des valeurs par défaut :

myFunction({opt1, opt2 = true}?: {opt1?: boolean, opt2?: boolean})

Sans déstructuration, je dois enterrer ces valeurs par défaut dans l’implémentation de la fonction, ou avoir un argument qui est en fait une classe avec un constructeur...

Réponse #1

Utilisez plutôt un paramètre par défaut :

function myFunction({ opt1, opt2 = true }: { opt1?: boolean; opt2?: boolean; } = {}) {
    console.log(opt2);
}

myFunction(); // outputs: true

C'est nécessaire afin de ne pas déstructurer undefined :

function myFunction({ opt1, opt2 }) {
}
    
// Uncaught TypeError: Cannot destructure property `opt1` of 'undefined' or 'null'.
myFunction();

Réponse #2

Vous ne pouvez pas déstructurer s'il n'y a pas d'objet donné en argument. Par conséquent, utilisez un objet par défaut dans les paramètres comme le mentionnait le message précédent :

type Options = { opt1?: boolean; opt2?: boolean; }

function myFunction({ opt1, opt2 }: Options = {}) {
    console.log(opt2, opt1);
}

myFunction() // undefined,  undefined 
myFunction({opt1: false}); // undefined,  false 
myFunction({opt2: true}); // true,  undefined

Ce que j'aimerais ajouter, c'est que ce modèle de déstructuration dans les paramètres apporte le plus de valeur lorsque les deux conditions suivantes sont remplies :

• Le nombre d'options est susceptible de changer
• Il pourrait potentiellement y avoir un changement dans l'API de la fonction, c'est-à-dire que les paramètres de la fonction sont susceptibles de changer.

Fondamentalement, la déstructuration vous donne plus de flexibilité puisqu'elle vous permet d'ajouter autant d'options que vous le souhaitez avec un minimum de modifications à l'API de la fonction.

Cependant, la version la plus basique serait plus simple :

// If the function is not likely to change often just keep it basic:
function myFunctionBasic( opt1? :boolean, opt2?: boolean ) {
    console.log(opt2, opt1);
}