TypeScript: avoid the type any

What is the type any in TypeScript?

In TypeScript, the any type is a special type that can represent any value. When a variable or parameter is declared with the type any, it can be assigned a value of any type, including numbers, strings, objects, and other custom types.

This is in contrast to other types in TypeScript, such as number or string, which can only hold values of a specific type. The any type is often used in situations where the type of a value is not known at compile time or when working with dynamic or untyped data.

Why using any with TypeScript is bad?

Using the any type in TypeScript can be problematic because it effectively turns off the type checking that TypeScript provides. When a variable or parameter is declared with the type any, the compiler will not generate any type errors or warnings, even if the variable is later used in a way that is inconsistent with its intended type. This can lead to subtle bugs and type-related issues that are difficult to detect and fix.

In addition to the potential for bugs, using the any type also diminishes one of the main benefits of using TypeScript, which is the ability to catch type-related errors early in the development process. When the any type is overused, it can also make code less readable and harder to maintain.

In other words, if you use TypeScript with the any type, you are juse using JavaScript.

The any type should be used sparingly, typically only in cases where the type of a value is truly unknown and cannot be determined, otherwise using the more specific types available will help you to write more safe and maintainable code.

It's also worth noting that sometimes even when you know the type of an object, you might want to use unknown instead of any as unknown is a more restrictive type.

How to stop using the any type with TypeScript?

If you find that you are using the any type excessively in your TypeScript code, there are a few ways to stop using it and make your code safer and more maintainable:

• Use more specific types: Instead of using any, try to use more specific types when declaring variables and parameters, such as number, string, boolean, or custom types like classes and interfaces.
• Use type inference: TypeScript can often infer the types of variables and parameters based on the values that are assigned to them. Take advantage of this by not explicitly declaring types and let the compiler do it for you.
• Use type unions and intersection: TypeScript allows to express complex types using a combination of multiple types using | for union and & for intersection. This way you can express more complex types without using any.
• Use unknown: Instead of using any, use the unknown type when you don't know the type of an object. unknown is more restrictive than any, which means that if you assign an unknown type to a variable, you will have to check its type before using it.
• Use assertions and casting: When you have to work with an existing codebase, assertions and casting can be a good way to work around the any type. Be mindful of the fact that this can make code less safe if done excessively.

By following these best practices, you can make your TypeScript code safer and more maintainable, and take advantage of the benefits that TypeScript provides.

How to check good type use with TypeScript?

Codiga provides rules (like no-any-type-function) to enforce that TypeScript best practices (such as not using the any type) are enforced.

To use Codiga and ensure you follow TypeScript best practices:

1. Download Codiga for your IDE
   • VS Code
   • JetBrains
   • VisualStudio
2. Add a codiga.yml file at the root of your project with the content below (you will be using the typescript-best-practices ruleset)

If you also want to check your code at each pull and push request, install Codiga on your repository as well:

• GitHub
• GitLab
• Bitbucket

You can explore the rules and test them yourself by visiting the ruleset on the Codiga Hub.