Introduction


Si vous êtes familier avec TypeScript, vous savez que ses principaux intérêts sont :

  • le typage (évidemment !)
  • la possibilité d’utiliser les dernières fonctionnalités JavaScript sans se préoccuper de leur compatibilité dans les différents navigateurs
  • une facilité de lecture et de navigation dans le code dans la plupart des éditeurs de code


En TypeScript, le typage reste néanmoins optionnel, et offre même un type any qui permet d’y associer n’importe quel autre type connu. On comprend donc bien qu’utiliser le type any à outrance diminue la robustesse du typage et par conséquent la maintenabilité du code.


TypeScript 3.0 (juillet 2018) a implémenté un nouveau type : unknown.


Définition


Le type unknown est l’alternative “sécuritaire” de any. N’importe quel type peut être assigné à unknown, mais unknown ne peut être assigné qu’à lui-même et any.


// Anything is assignable to unknown
function myFirstFunction(value: any) {
 let x: unknown;
 x = 123;
 x = "hello";
 x = [1, 2, 3];
}

// unknown assignable only to itself and any
function mySecondFunction(x: unknown) {
 let v1: any = x; // ok
 let v2: unknown = x; // ok 
 let v3: string = x; // Error
}


Ainsi, aucune opération n’est autorisée sur un unknown sans l’avoir préalablement restreint à un type plus spécifique.


Exemples


Nous pouvons par exemple utiliser unknown dans une fonction destinée à vérifier le type de la valeur reçue en paramètre.


function isArray(x: unknown): boolean {
 return Array.isArray(x);
}


Nous pouvons également l’utiliser dans une fonction acceptant une valeur dont nous ne connaissons préalablement pas le type, et retournant une chaîne de caractères différente selon le type reçu.


function printType(x: unknown): string {
 if (typeof x === "string") {
  return `${x} is a string`;
 }
 if (typeof x === "number") {
  return `${x} is a number`;
 } 
 return `${x} is not a string nor a number`;
}


Conclusion


Dans certains cas, afin d’éviter l’utilisation du type any, il peut être intéressant d’utiliser le type unknown. Il permet effectivement moins de flexibilité et donc a priori plus de robustesse.