«inconnu» contre «tout»

TypeScript 3.0 introduit le unknowntype, selon leur wiki:

unknown est désormais un nom de type réservé, car il s'agit désormais d'un type intégré. En fonction de votre utilisation prévue de unknown, vous voudrez peut-être supprimer complètement la déclaration (en favorisant le type inconnu nouvellement introduit), ou la renommer en autre chose.

Quelle est la difference entre unknownet any? Quand devrions-nous utiliser unknownplus any?

Vous pouvez en savoir plus sur unknownle PR ou l' annonce RC , mais l'essentiel est:

[..] inconnu qui est l'homologue de type sécurisé de tout. Tout ce qui est assignable à unknown, mais unknown n'est assignable à rien d'autre qu'à lui-même et à aucun sans une assertion de type ou un rétrécissement basé sur le flux de contrôle. De même, aucune opération n'est autorisée sur un inconnu sans d'abord affirmer ou se restreindre à un type plus spécifique.

Quelques exemples:

let vAny: any = 10;          // We can assign anthing to any
let vUnknown: unknown =  10; // We can assign anthing to unknown just like any 


let s1: string = vAny;     // Any is assigable to anything 
let s2: string = vUnknown; // Invalid we can't assign vUnknown to any other type (without an explicit assertion)

vAny.method();     // ok anything goes with any
vUnknown.method(); // not ok, we don't know anything about this variable

L'utilisation suggérée est:

Il y a souvent des moments où nous voulons décrire le type le moins capable dans TypeScript. Ceci est utile pour les API qui veulent signaler «cela peut être n'importe quelle valeur, vous devez donc effectuer un certain type de vérification avant de l'utiliser». Cela oblige les utilisateurs à introspecter en toute sécurité les valeurs renvoyées.

La différence entre unknown et any est décrite comme:

Tout comme any, toute valeur est assignable à unknown; cependant, contrairement à any, vous ne pouvez accéder à aucune propriété sur des valeurs avec le type unknown, ni les appeler / les construire. De plus, les valeurs de type unknownne peuvent être affectées qu'à unknownou any.

Pour répondre à votre question de savoir quand utiliser unknownover any:

Ceci est utile pour les API qui veulent signaler «cela peut être n'importe quelle valeur, vous devez donc effectuer un certain type de vérification avant de l'utiliser». Cela oblige les utilisateurs à introspecter en toute sécurité les valeurs renvoyées.

Jetez un œil à l' annonce TypeScript 3.0 pour des exemples de vérification de type d'une variable de type unknownet une explication plus détaillée.

any type:

Le anytype représente toutes les valeurs JS possibles. Chaque type est attribuable au type any. Par conséquent, le type anyest un supertype universel du système de type. Le compilateur TS autorisera toute opération sur les valeurs tapées any. Par exemple:

let myVar: any;

myVar[0];
myVar();
myVar.length;
new myVar();

Dans de nombreuses occasions, c'est trop indulgent de la part du compilateur TS. c'est-à-dire qu'il permettra des opérations dont nous aurions pu savoir qu'elles entraînent une erreur d'exécution.

unknown type:

Le unknowntype représente (comme any) toutes les valeurs JS possibles. Chaque type est attribuable au type unknown. Par conséquent, le type unknownest un autre supertype universel du système de type (à côté any). Cependant, le compilateur TS ne permet aucune opération sur les valeurs typées unknown. De plus, le unknowntype ne peut être attribué qu'au type any. Un exemple clarifiera ceci:

let myVar: unknown;

let myVar1: unknown = myVar;   // No error
let myVar2: any = myVar;       // No error
let myVar3: boolean = myVar;   // Type 'unknown' is not assignable to type 'boolean'

// The following operations on myVar all give the error:
// Object is of type 'unknown'
myVar[0];
myVar();
myVar.length;
new myVar();