Texto mecanografiado: TS7006: el parámetro 'xxx' tiene implícitamente un tipo 'any'

Al probar mi UserRouter, estoy usando un archivo json

data.json

[
  {
    "id": 1,
    "name": "Luke Cage",
    "aliases": ["Carl Lucas", "Power Man", "Mr. Bulletproof", "Hero for Hire"],
    "occupation": "bartender",
    "gender": "male",
    "height": {
      "ft": 6,
      "in": 3
    },
    "hair": "bald",
    "eyes": "brown",
    "powers": [
      "strength",
      "durability",
      "healing"
    ]
  },
  {
  ...
  }
]

Al compilar mi aplicación, aparece el siguiente error de TS

ERROR in ...../UserRouter.ts
(30,27): error TS7006: Parameter 'user' implicitly has an 'any' type.

UserRouter.ts

import {Router, Request, Response, NextFunction} from 'express';
const Users = require('../data');

export class UserRouter {
  router: Router;

  constructor() {
  ...
  }

  /**
   * GET one User by id
   */
  public getOne(req: Request, res: Response, _next: NextFunction) {
    let query = parseInt(req.params.id);
 /*[30]->*/let user = Users.find(user => user.id === query);
    if (user) {
      res.status(200)
        .send({
          message: 'Success',
          status: res.status,
          user
        });
    }
    else {
      res.status(404)
        .send({
          message: 'No User found with the given id.',
          status: res.status
        });
    }
  }


}

const userRouter = new UserRouter().router;
export default userRouter;

Está utilizando --noImplicitAnyy TypeScript no sabe sobre el tipo de Usersobjeto. En este caso, debe definir explícitamente el usertipo.

cambia esta línea:

let user = Users.find(user => user.id === query);

para esto:

let user = Users.find((user: any) => user.id === query); 
// use "any" or someother interface to type this argument

O defina el tipo de su Usersobjeto:

//...
interface User {
    id: number;
    name: string;
    aliases: string[];
    occupation: string;
    gender: string;
    height: {ft: number; in: number;}
    hair: string;
    eyes: string;
    powers: string[]
}
//...
const Users = <User[]>require('../data');
//...

En su tsconfig.jsonarchivo, configure el parámetro "noImplicitAny": falsedebajo compilerOptionspara deshacerse de este error.

Encontré este error y descubrí que era porque el parámetro "estricto" estaba establecido en verdadero en el archivo tsconfig.json. Simplemente configúrelo "falso" (obviamente). En mi caso, había generado el archivo tsconfig desde el indicador de cmd y simplemente omití el parámetro "estricto", que se encontraba más abajo en el archivo.

si obtiene un error ya que el parámetro 'elemento' tiene implícitamente un tipo 'cualquiera'. Vetur (7006) en vueJs

con el error:

 exportColumns.forEach(element=> {
      if (element.command !== undefined) {
        let d = element.command.findIndex(x => x.name === "destroy");

puede arreglarlo definiendo las variables de la siguiente manera.

código corregido:

exportColumns.forEach((element: any) => {
      if (element.command !== undefined) {
        let d = element.command.findIndex((x: any) => x.name === "destroy");

Muy por debajo del corte y la solución efectiva está a continuación: -

Agregue la siguiente regla en su archivo tsconfig.json: -

"noImplicitAny": false

Luego reinicie su proyecto.

Reproducción mínima de errores

export const users = require('../data'); // presumes @types/node are installed
const foundUser = users.find(user => user.id === 42); 
// error: Parameter 'user' implicitly has an 'any' type.ts(7006)

Solución recomendada: --resolveJsonModule

La forma más sencilla para su caso es usar la --resolveJsonModuleopción del compilador:

import users from "./data.json" // `import` instead of `require`
const foundUser = users.find(user => user.id === 42); // user is strongly typed, no `any`!

---

Existen algunas alternativas para otros casos además de la importación JSON estática.

Opción 1: tipo de usuario explícito (simple, sin controles)

type User = { id: number; name: string /* and others */ }
const foundUser = users.find((user: User) => user.id === 42)

Opción 2: guardias de tipo (en el medio)

Los protectores de tipo son un buen término medio entre la simplicidad y los tipos fuertes:

function isUserArray(maybeUserArr: any): maybeUserArr is Array<User> {
  return Array.isArray(maybeUserArr) && maybeUserArr.every(isUser)
}

function isUser(user: any): user is User {
  return "id" in user && "name" in user
}

if (isUserArray(users)) {
  const foundUser = users.find((user) => user.id === 42)
}

Incluso puede cambiar a funciones de aserción (TS 3.7+) para deshacerse ify lanzar un error en su lugar.

function assertIsUserArray(maybeUserArr: any): asserts maybeUserArr is Array<User> {
  if(!isUserArray(maybeUserArr)) throw Error("wrong json type")
}

assertIsUserArray(users)
const foundUser = users.find((user) => user.id === 42) // works

Opción 3: biblioteca del sistema de tipos de tiempo de ejecución (sofisticado)

Una biblioteca de verificación de tipo de tiempo de ejecución como io-tso ts-runtimepuede integrarse para casos más complejos.

---

Soluciones no recomendadas

noImplicitAny: false socava muchas comprobaciones útiles del sistema de tipos:

function add(s1, s2) { // s1,s2 implicitely get `any` type
  return s1 * s2 // `any` type allows string multiplication and all sorts of types :(
}
add("foo", 42)

También es mejor proporcionar un Usertipo explícito para user. Esto evitará propagarse anya los tipos de capa interna. En cambio, la escritura y la validación se mantienen en el código de procesamiento JSON de la capa API externa.