Are TypeScript’s types mandatory?

TypeScript's type system is optional and static. This means you can opt to use types in your code, but once you do, TypeScript enforces type checking at compile time.

Optional Nature

TypeScript extends JavaScript with a type system. Since TypeScript is a superset of JavaScript, you can write plain JavaScript code without using TypeScript's type system. For example:

javascript
function add(a, b) {
  return a + b;
}

This code does not specify types for parameters a and b, so they can be of any type.

Enforceability

Once you specify types for variables or function parameters, TypeScript enforces type checking to ensure your code is type-correct at compile time. For example:

typescript
function add(a: number, b: number): number {
  return a + b;
}

Here, the parameters a and b of the function add are specified as number. If you attempt to pass non-numeric parameters, the TypeScript compiler throws an error:

typescript
add('hello', 5); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

Example

In a previous project, we used TypeScript to ensure type safety for API response data. For example, we have a function for processing user information that expects an object with a specific structure:

typescript
interface User {
  id: number;
  name: string;
  age: number;
}

function processUser(user: User) {
  console.log(`Processing user: ${user.name}`);
}

// When we fetch user information from an API and pass it to the processUser function, TypeScript ensures the passed object conforms to the User interface structure.

This type enforcement helps us avoid many runtime errors, such as misspelled property names or incorrect data types, thereby improving code reliability and maintainability.

In summary, TypeScript's type system is designed to help developers write safer and more maintainable code, although it is optional; once adopted, the type safety it provides is mandatory.