TypeScript

How many types of typescript it had ?

March 09, 2023

 TypeScript has several types that can be categorized into primitive types, complex types, and others. Here's a breakdown:

1. Primitive Types

  • string: Represents a sequence of characters (e.g., "hello", 'world').
  • number: Represents both integer and floating-point numbers (e.g., 42, 3.14).
  • boolean: Represents a true/false value (e.g., true, false).
  • null: Represents the intentional absence of any object value.
  • undefined: Represents a variable that has been declared but not assigned any value.
  • symbol: Represents a unique identifier.
  • bigint: Represents large integers (introduced in TypeScript 3.2).

2. Complex Types

  • array: A collection of values, which can be of any type (e.g., number[], Array<string>).
  • tuple: A fixed-size array with elements of different types (e.g., [string, number]).
  • object: A non-primitive type that can be a collection of properties and methods (e.g., { name: string, age: number }).

3. Other Types

  • any: A type that allows any kind of value, effectively disabling type-checking (e.g., let x: any = 42).
  • unknown: Similar to any, but safer because you can't perform operations on it until it's narrowed down (e.g., let y: unknown = 42).
  • void: Represents the absence of a value, often used for functions that don't return anything (e.g., function foo(): void {}).
  • never: Represents a value that never occurs, typically used for functions that throw errors or have infinite loops (e.g., function error(): never { throw new Error("error"); }).
  • object: A type for non-primitive values (objects, arrays, etc.), except null.

4. Specialized Types

  • literal types: Specific values as types (e.g., let color: 'red' | 'green' | 'blue';).
  • union types: A type that can be one of multiple types (e.g., let value: string | number;).
  • intersection types: Combines multiple types into one (e.g., type Employee = Person & Worker;).
  • type alias: Creates a new name for a type (e.g., type Point = { x: number, y: number };).

5. Generics

  • generics: Types that are defined with placeholders (e.g., function identity<T>(arg: T): T { return arg; }).

6. Enums

  • enum: A way to define a set of named constants (e.g., enum Color { Red, Green, Blue };).

These are the core types and concepts in TypeScript. Some of them can be combined or used in advanced type manipulations to create powerful type systems in applications.