Typoskript: TS7006: Der Parameter 'xxx' hat implizit den Typ 'any'

Beim Testen meines UserRouter verwende ich eine JSON-Datei

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"
    ]
  },
  {
  ...
  }
]

Beim Erstellen meiner App wird der folgende TS-Fehler angezeigt

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;

Sie verwenden das --noImplicitAnyund TypeScript weiß nichts über den UsersObjekttyp. In diesem Fall müssen Sie den userTyp explizit definieren .

Ändern Sie diese Zeile:

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

dafür:

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

Oder definieren Sie den Typ Ihres UsersObjekts:

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

Stellen Sie in Ihrer tsconfig.jsonDatei den Parameter "noImplicitAny": falseunter ein compilerOptions, um diesen Fehler zu beseitigen.

Ich bin auf diesen Fehler gestoßen und habe festgestellt, dass der Parameter "strict" in der Datei tsconfig.json auf true gesetzt wurde. Setzen Sie es einfach (offensichtlich) auf "falsch". In meinem Fall hatte ich die tsconfig-Datei über die cmd-Eingabeaufforderung generiert und einfach den "strict" -Parameter übersehen, der sich weiter unten in der Datei befand.

Wenn Sie eine Fehlermeldung erhalten, hat der Parameter 'element' implizit den Typ 'any'. Veterur (7006) in vueJs

mit dem Fehler:

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

Sie können dies beheben, indem Sie diese Variablen wie folgt definieren.

korrigierter Code:

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

Sehr sortierte und effektive Lösung ist unten: -

Fügen Sie die folgende Regel in Ihre Datei tsconfig.json ein: -

"noImplicitAny": false

Starten Sie dann Ihr Projekt neu.

Minimale Fehlerwiedergabe

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)

Empfohlene Lösung: --resolveJsonModule

Der einfachste Weg für Ihren Fall ist die Verwendung der --resolveJsonModuleCompiler-Option:

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

---

Es gibt einige Alternativen für andere Fälle als den statischen JSON-Import.

Option 1: Expliziter Benutzertyp (einfach, keine Überprüfungen)

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

Option 2: Typwächter (Mittelgrund)

Typ Wachen sind ein guter Mittelgrund zwischen Einfachheit und starken Typen:

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

Sie können sogar zu Assertionsfunktionen (TS 3.7+) wechseln , um ifeinen Fehler zu beseitigen und stattdessen auszulösen .

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: Systembibliothek vom Typ Laufzeit (anspruchsvoll)

Eine Laufzeit-Typprüfbibliothek wie io-tsoder ts-runtimekann für komplexere Fälle integriert werden.

---

Nicht empfohlene Lösungen

noImplicitAny: false untergräbt viele nützliche Überprüfungen des Typsystems:

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)

Geben Sie auch besser einen expliziten UserTyp für an user. Dadurch wird eine Ausbreitung anyauf innere Schichttypen vermieden. Stattdessen wird die Eingabe und Validierung im JSON-Verarbeitungscode der äußeren API-Schicht beibehalten.