Texto datilografado: TS7006: O parâmetro 'xxx' tem implicitamente um tipo 'qualquer'

Ao testar meu UserRouter, estou usando um arquivo 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"
    ]
  },
  {
  ...
  }
]

Ao criar meu aplicativo, recebo o seguinte erro 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;

Você está usando o --noImplicitAnye TypeScript não sabe sobre o tipo de Usersobjeto. Nesse caso, você precisa definir explicitamente o usertipo.

mude esta linha:

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

por esta:

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

Ou defina o tipo do seu 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');
//...

No seu tsconfig.jsonarquivo, defina o parâmetro "noImplicitAny": falseem compilerOptionspara se livrar desse erro.

Eu contei esse erro e descobri que era porque o parâmetro "strict" foi definido como true no arquivo tsconfig.json. Apenas defina "false" (obviamente). No meu caso, eu havia gerado o arquivo tsconfig a partir do prompt do cmd e simplesmente perdi o parâmetro "strict", localizado mais abaixo no arquivo.

Se você receber um erro como o parâmetro 'elemento' implicitamente tem um tipo 'qualquer' .Vetur (7006) em vueJs

com o erro:

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

você pode corrigi-lo definindo essas variáveis ​​como qualquer uma das seguintes.

código corrigido:

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

O corte muito ordenado e a solução eficaz estão abaixo: -

Adicione a regra abaixo no seu arquivo tsconfig.json: -

"noImplicitAny": false

Em seguida, reinicie seu projeto.

Reprodução mínima de erros

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)

Solução recomendada: --resolveJsonModule

A maneira mais simples para o seu caso é usar a --resolveJsonModuleopção de compilador:

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

---

Existem algumas alternativas para outros casos além da importação JSON estática.

Opção 1: Tipo de usuário explícito (simples, sem verificações)

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

Opção 2: Protetores de tipo (em meio)

As proteções de tipo são um bom meio termo entre simplicidade e tipos fortes:

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)
}

Você pode até mudar para as funções de asserção (TS 3.7+) para se livrar ife gerar um erro.

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

Opção 3: Biblioteca do sistema do tipo tempo de execução (sofisticada)

Uma biblioteca de verificação do tipo de tempo de execução como io-tsou ts-runtimepode ser integrada para casos mais complexos.

---

Soluções não recomendadas

noImplicitAny: false compromete muitas verificações úteis do 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)

Também é melhor fornecer um Usertipo explícito para user. Isso evitará a propagação anypara os tipos de camada interna. Em vez disso, a digitação e a validação são mantidas no código de processamento JSON da camada API externa.