How you can declare a explicit variables in Typescript?

In TypeScript, declaring explicit variables is typically done by specifying the type of the variable. Type annotations provide a lightweight way to document the expected types of functions and variables. This helps the compiler understand and validate your code, while also making the code more readable and maintainable.

Basic Type Declaration

In TypeScript, you can declare basic types such as string, number, boolean, etc. For example:

typescript
let name: string = "Alice";
let age: number = 30;
let isActive: boolean = true;

Here, name is explicitly declared as a string type, age as a number type, and isActive as a boolean type.

Complex Type Declaration

When dealing with more complex data structures, such as arrays or objects, TypeScript also supports explicit type declarations:

typescript
let numbers: number[] = [1, 2, 3, 4];
let user: { name: string; age: number } = {
  name: "Bob",
  age: 25
};

In this example, numbers is declared as an array of number types. user is an object containing a name property of type string and an age property of type number.

Function Type Declaration

For functions, TypeScript allows you to explicitly define parameter types and return types:

typescript
function greet(name: string): string {
  return "Hello, " + name;
}

Here, the greet function accepts a parameter name of type string and returns a result of type string.

Type Aliases and Interfaces

To enhance code reusability and maintainability, you can use type aliases or interfaces to define complex type structures:

typescript
type User = {
  name: string;
  age: number;
};

interface IUser {
  name: string;
  age: number;
}

let user1: User = { name: "Charlie", age: 28 };
let user2: IUser = { name: "Dana", age: 34 };

Here, User and IUser both define types with the same structure, which can be used to declare variables user1 and user2.

Conclusion

In TypeScript, explicitly declaring variable types enhances code type safety, allowing potential errors to be caught earlier during development while also making the code clearer and more maintainable. By using simple type annotations to complex interface definitions, TypeScript provides powerful tools to help developers manage and maintain large codebases.