Simple types, also known as primitive types, are the fundamental building blocks for defining data in TypeScript. These types help enforce type safety and make your code more predictable.

List of Simple Types

1. string
2. number
3. boolean
4. null
5. undefined
6. symbol
7. bigint

Details and Examples

1. string

Represents textual data.

typescript
let firstName: string = "Alice";let greeting: string = `Hello, ${firstName}!`; // Template literals

2. number

Represents numeric values, including integers and floating-point numbers.

typescript
let age: number = 30;let height: number = 5.9;

3. boolean

Represents true or false.

typescript
let isActive: boolean = true;let hasPermission: boolean = false;

4. null

Represents the intentional absence of a value. Often used with union types.

typescript
let user: string | null = null;user = "Alice";

5. undefined

Indicates a variable has been declared but not initialized. Also used with union types.

typescript
let value: string | undefined = undefined;value = "Initialized";

6. symbol

Represents a unique, immutable value often used as object property keys.

typescript
const id: symbol = Symbol("id");const anotherId: symbol = Symbol("id");console.log(id === anotherId); // false

7. bigint

Used for arbitrarily large integers. (Requires ES2020 or later)

typescript
let bigNumber: bigint = 1234567890123456789012345678901234567890n;

Type Inference

If you do not explicitly declare a type, TypeScript infers it based on the assigned value.

typescript
let name = "Alice"; // Type inferred as stringlet age = 25;       // Type inferred as numberlet isStudent = true; // Type inferred as boolean

The any Type

The any type is a fallback for variables with unknown types. It disables type checking, making the variable accept any value.

typescript
let randomValue: any = "Hello";randomValue = 42;   // ValidrandomValue = true; // Valid

Note: Use any sparingly as it bypasses TypeScript's type safety.

Type Assertions

You can use type assertions to explicitly tell TypeScript the type of a value.

typescript
let value: any = "Hello";let length: number = (value as string).length;

Best Practices for Simple Types

1. Always Use Explicit Types
   This helps in understanding code and preventing unintended behaviors.

   typescript
   let score: number = 10; // Better than just 'let score = 10;'
   

2. Enable Strict Mode
   Enable strict or strictNullChecks in your tsconfig.json to ensure robust type safety.

3. Avoid Using any
   Instead, prefer unknown for safer handling of dynamic types.

Conclusion

Simple types form the foundation of TypeScript's type system. By leveraging these types effectively, you can write safer and more maintainable code. Would you like to explore how to combine simple types with advanced features like unions or type aliases?