Error TS7006 en TypeScript: por qué el parámetro obtiene implícitamente el tipo any y cómo solucionarlo

Introducción: El error "aterrador" que en realidad es tu amigo

Estás escribiendo código en TypeScript, todo va bien, y de repente — ¡pum! Un subrayado rojo. El compilador refunfuña descontento: «TS7006: Parameter 'xxx' implicitly has an 'any' type». ¿Te suena esta situación? Si alguna vez te has encontrado con este error, no estás solo. En Stack Overflow, esta pregunta ha acumulado miles de visitas, y cada día decenas de desarrolladores buscan en Google «Typescript TS7006» en busca de una respuesta.

Pero pongámonos de acuerdo desde ya: este error no es un enemigo, sino el mejor amigo de tu código. Te obliga a pensar en los tipos y, por lo tanto, hace que tu proyecto sea más fiable. En este artículo, analizaremos por qué aparece el TS7006, cómo solucionarlo y cómo evitar estas situaciones en el futuro. ¡Allá vamos!

¿Qué es TS7006 y por qué aparece?

TS7006 es un error del compilador de TypeScript que ocurre cuando usas un parámetro de función sin especificar explícitamente su tipo, y en tu proyecto está activada la opción noImplicitAny. ¿Suena complicado? En realidad es muy sencillo.

Imagina que TypeScript es un profesor estricto que exige: «¡Dime de qué tipo es este parámetro!». Si te quedas callado (no especificas el tipo) y la opción noImplicitAny está activada, el profesor te pone un cero, es decir, un error.

Así es como se ve un ejemplo clásico:

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

TypeScript no sabe qué es name — una cadena, un número o un objeto. Por defecto, podría asignar el tipo any (que significa «da igual»), pero si la verificación estricta está activada, exige una especificación explícita.

¿Por qué es útil esto?

El tipo any es como un «agujero negro» para TypeScript. Desactiva la verificación de tipos para ese parámetro y pierdes todas las ventajas de TypeScript: autocompletado, verificación de errores en tiempo de compilación y autodocumentación del código. El error TS7006 te obliga a ser honesto con el compilador.

5 formas de solucionar TS7006 (con ejemplos de código)

Veamos todas las formas posibles de resolver el problema. Desde las más correctas hasta los «parches» (que también tienen derecho a existir).

1. Especifica explícitamente el tipo del parámetro (forma recomendada)

La forma más obvia y correcta es simplemente añadir una anotación de tipo:

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

// O un ejemplo más complejo con un objetointerface User {  id: number;  name: string;  email: string;}

function processUser(user: User): void {  console.log(`Procesando usuario: ${user.name}`);}

Esta forma hace que el código sea autodocumentado. Otro desarrollador (o tú mismo dentro de un mes) entenderá inmediatamente qué datos espera la función.

2. Usa valores por defecto

TypeScript es lo suficientemente inteligente como para inferir el tipo del parámetro a partir del valor por defecto:

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

// TypeScript entenderá por sí mismo que b es de tipo numbermultiply(5);     // 50multiply(5, 20); // 100

Esto funciona, pero ten cuidado: si olvidas pasar un argumento, TypeScript no mostrará un error, simplemente usará el valor por defecto. A veces es lo que necesitas, a veces no.

3. Usa parámetros rest con tipo

Si tu función acepta un número indefinido de argumentos del mismo tipo:

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

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

Observa: ...numbers: number[] — un array de números. Sin especificar el tipo, el error TS7006 aparecerá también aquí.

4. Usa genéricos (generics) para flexibilidad

Cuando el tipo del parámetro puede ser diferente