TypeScript, a superset of JavaScript, provides developers with static typing capabilities. This means you specify the data types that your variables and functions will accept, which improves code clarity, maintainability, and catches errors early in the development cycle.

This post delves into some fundamental TypeScript types you will come across frequently:

Primitive Types:

String:

Textual data enclosed in quotation marks (single or double). Used for names, descriptions, and other textual content.

let name: string = "Alice";

Number:

Represents numeric values, including integers and decimals.

let age: number = 30;

Boolean:

Represents true or false values. Often used in conditional statements and logical operations.

let isLoggedIn: boolean = true;

Undefined:

Represents a variable declared but not yet assigned a value.

let userId: undefined; // Usually followed by initialization
userId = 123;

Null:

Represents the intentional absence of a value.

let errorMessage: string | null = null; // Indicates a potential error message

Arrays:

Represent ordered collections of items of the same or compatible types. Defined using square brackets [] and specifying the element type.

let colors: string[] = ["red", "green", "blue"];

Tuples:

Represent fixed-length, ordered lists where each position can have a different type. Defined using square brackets [] with comma-separated types.

let user: [string, number] = ["Bob", 42]; // (name, age)

Enums:

Provide a way to define a set of named constants. Useful for representing fixed options or choices.

enum Color {
  Red = "red",
  Green = "green",
  Blue = "blue",
}

let favoriteColor: Color = Color.Green;

Any:

Used as a fallback type, indicating the variable can hold any type of value. While flexible, it bypasses type-checking benefits and should be used sparingly.

let userInput: any = prompt("Enter a value"); // Not recommended for most cases

Benefits of Using Types:

• Improved Code Clarity: Types make your code more readable and self-documenting.

• Early Error Detection: The compiler identifies potential type mismatches during development, preventing runtime errors.

• Enhanced Refactoring: Type safety ensures changes in one part of the codebase don't break other parts due to unexpected data types.

Conclusion:

Understanding and utilizing TypeScript's built-in types is an important step toward developing robust and maintainable applications. As you progress, learn more about advanced type concepts such as interfaces, generics, and user-defined types to improve your TypeScript skills.

That's wrap.

If you enjoyed this article, please like it and let me know in the comments what topics you would like to see covered in the next article.

You can reach me via X or LinkedIn.

Goodbye👋