Hello coders! π§ββοΈ
How many times in your career have you used the any
type in TypeScript? Well, most people use this special type everyday, however what if I told you you should completely stop using it?
That's right. As a TypeScript developer, you should stop using any
. Let's dive deeper into this and I'm sure I'll convince you at the end and you'll become a real TypeScript lover. π
any type in TypeScript
The any
type makes it into the category of "primitive types" in TypeScript. These are number
, string
, boolean
, BigInt
(from ES2020), symbol
(not very common), undefined
, null
, void
, never
, unknown
and lastly any
.
However any
is a special type, since it can be used when you don't want a particular value to cause typechecking errors.
TypeScript Documentation says:
When a value is of type any, you can access any properties of it (which will in turn be of type any), call it like a function, assign it to (or from) a value of any type, or pretty much anything else thatβs syntactically legal.
And that's the reason why, unless you have some real issue, like libraries with no typing or old JavaScript code, you should never use any
.
The unsafety of any
Since any
type prevents any type-check, you can do literally whatever you want to do with it. E.g.:
let bar: any = { foo = 1 };
bar.foo; // Ok
bar.hello; // Ok ?
bar(); // Ok ??
bar.trim(); // ok???
new bar(); // ok...
bar[0][1][4]; // what the hell??
This will not throw any compiler error and, unless really specific cases, it's absolutely wrong, since it totally destroys TypeScript purpose, type checking.
The type-safe any: unknown
Fortunately, for 100% code type-safety, there's an alternative for any
, the unknown
type.
The unknown
type works the same as any
, but with compiler errors if you don't specify the exact type you expect. For clarity, here's an example:
let safeBar: unknown = "Hello world";
safeBar.hello; // Error thrown
safeBar(); // Error thrown
// etc...
This could be useful in case you literally don't know what type a variable is. Check this other example:
function parseApiResponse(response: string): unknown {
try {
return JSON.parse(response);
} catch (error) {
return null;
}
}
const apiResponse = '{ "name": "John", "age": 30 }';
const parsedData = parseApiResponse(apiResponse);
if (typeof parsedData === 'object') {
// Now, you can safely access properties without TypeScript errors
const name = (parsedData as { name: string }).name;
const age = (parsedData as { age: number }).age;
console.log(`Name: ${name}, Age: ${age}`);
} else {
console.log('Failed to parse API response');
}
In this example, the "parseApiResponse" function returns data of type "unknown" because the actual structure of the data is not known at compile time. You can use type assertions (e.g., (parsedData as { name: string }).name)
to access properties safely when you've checked the type. This way, you maintain type safety even when dealing with data of an unknown structure.
How to prevent any in your code
You can start preventing any
in your code by modifying your tsconfig.json
file. Set the noImplicitAny
property to true
, to check if no type annotations are present for a variable. Normally, in that case, TypeScript will fall back to a type of any
for a variable when it cannot infer the type.
{
"compilerOptions": {
/* ... */
"noImplicitAny": true,
/* ... */
}
}
Check this example:
With noImplicitAny: false
:
function fn(s) {
// No error?
console.log(s.subtr(3));
}
fn(42);
With noImplicitAny: true
:
function fn(s) {
// Error: Parameter 's' implicitly has an 'any' type.
console.log(s.subtr(3));
}
If you use EsLint as your main linter, you may also install @typescript-eslint
plugin to get the noExplicitAny
rule. Example:
function fn(s: any): any {
// Error: Unexpected any. Specify a different type. - eslint@typescript-eslint/no-explicit-any
console.log(s);
return s;
}
Who am I?
I am an Italian high-school student who is interested in web-dev π§ββοΈ. If you'd like to support me, you can follow me here and on my GitHub, I would really appreciate it π
Top comments (1)
Watch this repo: github.com/eptastellar/Orbit