CODEWITHSUNDEEP
typescript
user762579
user762579

Reputation:

Typescript: TS7006: Parameter 'xxx' implicitly has an 'any' type

In testing my UserRouter, I am using a json file

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

Building my app, I get the following TS error 

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;

Upvotes: 474

Views: 993458

Answers (14)

Mounir bkr
Mounir bkr

Reputation: 1635

go to "tsconfig.json" and add this: "noImplicitAny": false,

{
  "compileOnSave": false,
   "compilerOptions": {
       "noImplicitAny": false,
       ........

Upvotes: 0

Emmanuel Iyen
Emmanuel Iyen

Reputation: 439

Or add the below on top of the code that has the error

// @ts-ignore: Object is possibly 'null'.

Upvotes: 1

DEV Tiago França
DEV Tiago França

Reputation: 1696

My case:


export default function ({user, path}) {
    return (
        //...
    )
}

I changed to

export default function ({user, path} : {
    user: string
    path: string
}) {
    return (
        //...
    )
}

Upvotes: 6

Saibamen
Saibamen

Reputation: 648

Just add "checkJs": false into jsconfig.json file

Upvotes: -5

Muhammad Abubakar Zorrain
Muhammad Abubakar Zorrain

Reputation: 105

try to declare the type of user. Such as

let user:Object = {sample object}

Follow this methid. As

let var:type = val

Upvotes: 1

Mohammed
Mohammed

Reputation: 1022

Make these changes in your compilerOptions section of tsconfig.json file this worked for me

"noImplicitAny": false

no need to set

"strict":false

And please wait 1 or two minutes compilation is very slow some pcs

Upvotes: 56

Nil Bor
Nil Bor

Reputation: 227

I found this issue in Angular to arguments of function.

Before my code giving error

Parameter 'event' implicitly has an 'any' type

Here Is code

changeInpValue(event)
{
    this.inp = event.target.value;
}

Here is the change, after the argument write : any and the error is solved

changeInpValue(event : any)
{
    this.inp = event.target.value;
}

Working fine for me.

Upvotes: 21

Chandan
Chandan

Reputation: 319

Parameter 'post' implicitly has an 'any' type in Angularcli Perhaps on project creation you've enabled Angular's strict mode in your app? Max recommends to disable strict mode If you've enabled strict mode, please disable it for this course by setting the strict property in tsconfig.json to false

Upvotes: 0

Sonika M K
Sonika M K

Reputation: 63

go to tsconfig.json and comment the line the //strict:true this worked for me

Upvotes: 3

Diullei
Diullei

Reputation: 12414

You are using the --noImplicitAny and TypeScript doesn't know about the type of the Users object. In this case, you need to explicitly define the user type.

Change this line:

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

to this:

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

Or define the type of your Users object:

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

Upvotes: 633

ford04
ford04

Reputation: 74500

Minimal error reproduction

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)

Recommended solution: --resolveJsonModule

The simplest way for your case is to use --resolveJsonModule compiler option: 
import users from "./data.json" // `import` instead of `require`
const foundUser = users.find(user => user.id === 42); // user is strongly typed, no `any`!

There are some alternatives for other cases than static JSON import.

Option 1: Explicit user type (simple, no checks)

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

Option 2: Type guards (middleground)

Type guards are a good middleground between simplicity and strong types: 
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)
}
You can even switch to assertion functions (TS 3.7+) to get rid of if and throw an error instead. 
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: Runtime type system library (sophisticated)

A runtime type check library like io-ts or ts-runtime can be integrated for more complex cases.

Not recommended solutions

noImplicitAny: false undermines many useful checks of the type system: 
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)

Also better provide an explicit User type for user. This will avoid propagating any to inner layer types. Instead typing and validating is kept in the JSON processing code of the outer API layer.

Upvotes: 6

Sunali Bandara
Sunali Bandara

Reputation: 410

if you get an error as Parameter 'element' implicitly has an 'any' type.Vetur(7006) in vueJs

with the error:

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

you can fixed it by defining thoes variables as any as follow.

corrected code:

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

Upvotes: 16

st_ahmed
st_ahmed

Reputation: 2561

In your tsconfig.json file set the parameter "noImplicitAny": false under compilerOptions to get rid of this error.

Upvotes: 219

Jeff Eastman
Jeff Eastman

Reputation: 131

I encounted this error and found that it was because the "strict" parameter was set to true in the tsconfig.json file. Just set it "false" (obviously). In my case I had generated the tsconfig file from the cmd prompt and simply missed the "strict" parameter, which was located further down in the file.

Upvotes: 1

Related Questions