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...
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;
11 Answers
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');
//...
In your tsconfig.json file set the parameter "noImplicitAny": false under compilerOptions to get rid of this error.
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
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");
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.
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.
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)
}
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.
go to tsconfig.json and comment the line the //strict:true this worked for me
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
try to declare the type of user. Such as
let user:Object = {sample object}
Follow this methid. As
let var:type = val
Add the below rule in your tsconfig.json file:-
"strict": false /* does not allow all strict type-checking options. */,
Alexander Ross has covered the video game industry for a decade, writing deep dives on game design, esports tournaments, VR developments, and gaming culture.
