Typographie: TS7006: Le paramètre 'xxx' a implicitement un type 'any'

En testant mon UserRouter, j'utilise un fichier 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"
    ]
  },
  {
  ...
  }
]

Construire mon application, j'obtiens l'erreur TS suivante

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;

Vous utilisez le --noImplicitAnyet TypeScript ne connaît pas le type d' Usersobjet. Dans ce cas, vous devez définir explicitement le usertype.

changez cette ligne:

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

pour ça:

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

Ou définissez le type de votre Usersobjet:

//...
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');
//...

Dans votre tsconfig.jsonfichier, définissez le paramètre ci- "noImplicitAny": falsedessous compilerOptionspour éliminer cette erreur.

J'ai rencontré cette erreur et j'ai constaté que c'était parce que le paramètre "strict" était défini sur true dans le fichier tsconfig.json. Réglez-le simplement sur "faux" (évidemment). Dans mon cas, j'avais généré le fichier tsconfig à partir de l'invite cmd et j'ai simplement manqué le paramètre "strict", qui était situé plus bas dans le fichier.

si vous obtenez une erreur car le paramètre 'element' a implicitement un type 'any' .Vetur (7006) dans vueJs

avec l'erreur:

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

vous pouvez le corriger en définissant ces variables comme suit.

code corrigé:

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

La solution très triée et efficace est ci-dessous: -

Ajoutez la règle ci-dessous dans votre fichier tsconfig.json: -

"noImplicitAny": false

Puis redémarrez votre projet.

Reproduction d'erreur minimale

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)

Solution recommandée: --resolveJsonModule

Le moyen le plus simple pour votre cas est d'utiliser l' --resolveJsonModuleoption du compilateur:

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

---

Il existe des alternatives pour d'autres cas que l'importation JSON statique.

Option 1: type d'utilisateur explicite (simple, pas de vérification)

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

Option 2: protecteurs de type (au milieu)

Les protections de type sont un bon milieu entre la simplicité et les types forts:

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

Vous pouvez même passer aux fonctions d'assertion (TS 3.7+) pour vous débarrasser ifet renvoyer une erreur à la place.

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

Option 3: bibliothèque système de type Runtime (sophistiquée)

Une bibliothèque de vérification de type d'exécution comme io-tsou ts-runtimepeut être intégrée pour des cas plus complexes.

---

Solutions non recommandées

noImplicitAny: false sape de nombreux contrôles utiles du système de types:

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)

Il vaut également mieux fournir un Usertype explicite pour user. Cela évitera de se propager anyaux types de couches internes. Au lieu de cela, la saisie et la validation sont conservées dans le code de traitement JSON de la couche API externe.