TypeScript - Any Type: The Swiss Army Knife of Types

Bonjour là-bas, futurs superstars du codage ! Aujourd'hui, nous allons plonger dans une des fonctionnalités les plus polyvalentes (et parfois controversées) de TypeScript : le type any. Attachez vos ceintures, car nous allons entreprendre un voyage qui vous fera dire, "Any-thing is possible!" (Désolé, je ne pouvais pas résister à un petit jeu de mots sur les types !)

Qu'est-ce que le type Any ?

Avant de commencer, imaginons que vous êtes à un dîner de conviviale. Vous apportez un plat, mais vous ne savez pas ce que les autres apportent. C'est un peu comme le type any en TypeScript - il peut contenir n'importe quel type de valeur, tout comme votre assiette au dîner de conviviale peut contenir n'importe quel type d'aliment !

Peut représenter n'importe quelle valeur

Le type any est exactement ce que son nom suggère - il peut représenter n'importe quelle valeur en TypeScript. C'est comme un joker qui dit, "Eh TypeScript, je peux être ce que je veux être !"

Voici quelques exemples :

let maVariable: any = 42;
console.log(maVariable); // Output: 42

maVariable = "Hello, World!";
console.log(maVariable); // Output: Hello, World!

maVariable = true;
console.log(maVariable); // Output: true

maVariable = [1, 2, 3];
console.log(maVariable); // Output: [1, 2, 3]

Dans cet exemple, nous déclarons maVariable comme type any. Ensuite, nous lui affectons différents types de valeurs - un nombre, une chaîne, un booléen, et un tableau. TypeScript ne se plaint pas parce que any peut être, eh bien, n'importe quoi !

Paramètres de fonction de type any

Maintenant, disons que vous créez une fonction qui doit être très flexible. Vous voulez qu'elle accepte n'importe quel type de paramètre. C'est là que any entre en jeu !

function imprimeNimporteQuoi(arg: any): void {
console.log(arg);
}

imprimeNimporteQuoi(42);          // Output: 42
imprimeNimporteQuoi("TypeScript"); // Output: TypeScript
imprimeNimporteQuoi([1, 2, 3]);    // Output: [1, 2, 3]

Dans cet exemple, notre fonction imprimeNimporteQuoi peut accepter n'importe quel type d'argument. C'est comme un vigile sympa dans un club qui laisse tout le monde entrer !

Objet de type any

Parfois, vous pourriez vouloir créer un objet qui peut avoir des propriétés de n'importe quel type. Créons un sac magique qui peut contenir n'importe quoi :

let sacMagique: { [cle: string]: any } = {};

sacMagique.book = "Harry Potter";
sacMagique.wand = { wood: "Holly", core: "Plume de phoenix" };
sacMagique.spells = ["Expelliarmus", "Lumos", "Accio"];

console.log(sacMagique);
// Output:
// {
//   book: "Harry Potter",
//   wand: { wood: "Holly", core: "Plume de phoenix" },
//   spells: ["Expelliarmus", "Lumos", "Accio"]
// }

Ici, sacMagique est un objet qui peut avoir n'importe quel nombre de propriétés, chacune pouvant être de n'importe quel type. C'est comme le sac de Mary Poppins - il peut contenir n'importe quoi !

Pourquoi utiliser le type any ?

Vous pourriez vous demander, "Si TypeScript est tout au sujet des types, pourquoi voudrions-nous utiliser any ?" Excellent pregunta ! Voici quelques scénarios où any peut être utile :

1. Lorsque vous travaillez avec du contenu dynamique (comme des données provenant d'une API)
2. Lorsque vous migrez progressivement un projet JavaScript vers TypeScript
3. Lorsque vous traitez des bibliothèques tierces qui n'ont pas de définitions de types

Regardons un exemple de travail avec du contenu dynamique :

async function fetchUserData(userId: number): Promise<any> {
const response = await fetch(`https://api.example.com/users/${userId}`);
const userData = await response.json();
return userData; // Nous ne connaissons pas la structure exacte de userData, donc nous utilisons 'any'
}

// Utilisation
fetchUserData(123).then(user => {
console.log(user.name);  // TypeScript ne se plaindra pas, même si 'name' n'existe pas
});

Dans ce cas, nous ne sommes pas sûrs de la structure des données que nous recevons, donc nous utilisons any pour dire à TypeScript, "Fais-moi confiance, je sais ce que je fais !"

Assertions de type

Parfois, vous pourriez savoir plus sur le type d'une valeur que TypeScript. C'est là que les assertions de type entrent en jeu. C'est comme dire à TypeScript, "Je sais que tu penses que c'est any, mais fais-moi confiance, c'est en fait un type spécifique."

Voici comment vous pouvez utiliser les assertions de type :

let uneValeur: any = "Hello, TypeScript!";
let strLength: number = (uneValeur as string).length;

console.log(strLength); // Output: 20

Dans cet exemple, nous disons à TypeScript, "Eh, je sais que uneValeur est de type any, mais je suis certain qu'il s'agit en fait d'une chaîne. Donc, permets-moi de l'utiliser comme une chaîne."

Attention : Avec Grand Pouvoir Vient une Grande Responsabilité

Bien que any soit puissant, il devrait être utilisé avec parcimonie. Souvenez-vous, le principal avantage de TypeScript est sa vérification des types. En utilisant any, vous dites essentiellement à TypeScript de désactiver la vérification des types pour cette variable.

Voici un exemple de la manière dont any peut entraîner des erreurs en temps d'exécution :

let num: any = "42";
console.log(num.toFixed(2)); // Cela causera une erreur en temps d'exécution !

TypeScript ne se plaindra pas de ce code, mais il lancera une erreur lorsque vous l'exécuterez, car les chaînes n'ont pas une méthode toFixed.

Any vs. Unknown : L'Alternative Plus Sure

TypeScript 3.0 a introduit le type unknown, qui est un ersatz de type sécurisé de any. Alors que any vous permet de faire n'importe quoi sans vérification, unknown impose des vérifications de type.

Comparons any et unknown :

let anyVar: any = 10;
let unknownVar: unknown = 10;

let s1: string = anyVar;    // OK
let s2: string = unknownVar; // Erreur : Type 'unknown' n'est pas assignable au type 'string'

// Nous devons vérifier le type avant d'utiliser unknownVar
if (typeof unknownVar === 'string') {
let s3: string = unknownVar; // OK
}

Comme vous pouvez le voir, unknown est plus sûr car il vous oblige à vérifier le type avant de l'utiliser.

Table des Méthodes

Voici un tableau des méthodes courantes que vous pourriez utiliser avec any :

Méthode	Description	Exemple
typeof	Retourne une chaîne indiquant le type de l'opérande non évaluée	typeof anyVar === 'string'
instanceof	Teste si la propriété prototype d'un constructeur apparaît n'importe où dans la chaîne de prototype d'un objet	anyVar instanceof Array
Assertion de type	Dit au compilateur de traiter une valeur comme un type spécifique	(anyVar as string).length
Gardiens de type	Prédicats de type utilisateur définis qui aident à affiner le type d'une variable	if (isString(anyVar)) { ... }

Souvenez-vous, avec any, vous pouvez utiliser n'importe quelle méthode existant en JavaScript, mais vous perdez l'avantage de la vérification des types de TypeScript.

Et voilà, les amis ! Vous venez de faire un plongeon en profondeur dans le monde du type any en TypeScript. Souvenez-vous, bien que any puisse être un outil puissant, c'est comme un super-pouvoir - utilisez-le intelligemment et avec responsabilité. Bon codage, et puissent les types toujours être en votre faveur !

Credits: Image by storyset