Erreur TS7006 dans TypeScript : pourquoi un paramètre reçoit implicitement le type any et comment y remédier

Introduction : Une erreur « effrayante » qui est en réalité votre alliée

Vous écrivez du code en TypeScript, tout va bien, et soudain — bam ! Un soulignement rouge. Le compilateur ronchonne : « TS7006 : Parameter 'xxx' implicitly has an 'any' type ». Une situation familière ? Si vous avez déjà rencontré cette erreur, vous n'êtes pas seul. Sur Stack Overflow, cette question a rassemblé des milliers de vues, et chaque jour, des dizaines de développeurs cherchent « Typescript TS7006 » pour trouver une réponse.

Mais mettons-nous d'accord tout de suite : cette erreur n'est pas un ennemi, mais le meilleur ami de votre code. Elle vous oblige à réfléchir aux types, rendant ainsi votre projet plus fiable. Dans cet article, nous allons voir pourquoi l'erreur TS7006 apparaît, comment la corriger et comment éviter de telles situations à l'avenir. C'est parti !

Qu'est-ce que TS7006 et pourquoi apparaît-elle ?

TS7006 est une erreur du compilateur TypeScript qui survient lorsque vous utilisez un paramètre de fonction sans spécifier explicitement son type, et que l'option noImplicitAny est activée dans votre projet. Cela semble compliqué ? En réalité, c'est très simple.

Imaginez que TypeScript est un professeur strict qui exige : « Dis-moi de quel type est ce paramètre ! ». Si vous restez silencieux (sans préciser le type) et que l'option noImplicitAny est activée, le professeur vous met une mauvaise note — c'est-à-dire une erreur.

Voici un exemple classique :

function greet(name) {  return `Bonjour, ${name}!`;}// Erreur : TS7006 : Parameter 'name' implicitly has an 'any' type

TypeScript ne sait pas ce qu'est name — une chaîne, un nombre ou un objet. Par défaut, il pourrait attribuer le type any (ce qui signifie « peu importe »), mais si la vérification stricte est activée, il exige une indication explicite.

Pourquoi est-ce utile ?

Le type any est comme un « trou noir » pour TypeScript. Il désactive la vérification des types pour ce paramètre, et vous perdez tous les avantages de TypeScript : l'autocomplétion, la vérification des erreurs à la compilation et l'auto-documentation du code. L'erreur TS7006 vous oblige à être honnête avec le compilateur.

5 façons de corriger TS7006 (avec exemples de code)

Examinons toutes les façons possibles de résoudre le problème. Des plus correctes aux « béquilles » (qui ont aussi leur raison d'être).

1. Spécifiez explicitement le type du paramètre (méthode recommandée)

La façon la plus évidente et correcte est d'ajouter simplement une annotation de type :

function greet(name: string): string {  return `Bonjour, ${name}!`;}

// Ou un exemple plus complexe avec un objetinterface User {  id: number;  name: string;  email: string;}

function processUser(user: User): void {  console.log(`Traitement de l'utilisateur : ${user.name}`);}

Cette méthode rend le code auto-documenté. Un autre développeur (ou vous-même dans un mois) comprendra immédiatement quelles données la fonction attend.

2. Utilisez des valeurs par défaut

TypeScript est assez intelligent pour déduire le type du paramètre à partir de la valeur par défaut :

function multiply(a: number, b = 10): number {  return a * b;}

// TypeScript comprendra tout seul que b est de type numbermultiply(5);     // 50multiply(5, 20); // 100

Cela fonctionne, mais soyez prudent : si vous oubliez de passer un argument, TypeScript ne générera pas d'erreur, mais utilisera simplement la valeur par défaut. Parfois c'est ce qu'il faut, parfois non.

3. Utilisez des paramètres rest avec un type

Si votre fonction accepte un nombre indéfini d'arguments du même type :

function sum(...numbers: number[]): number {  return numbers.reduce((acc, curr) => acc + curr, 0);}

console.log(sum(1, 2, 3, 4, 5)); // 15

Remarque : ...numbers: number[] est un tableau de nombres. Sans indication de type, l'erreur TS7006 apparaîtrait également ici.

4. Utilisez les génériques (generics) pour plus de flexibilité

Lorsque le type du paramètre peut être différent