Types de base

Types primitifs

// Boolean
let isDone: boolean = false;
let isActive: boolean = true;

// Number
let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;
let big: bigint = 100n;

// String
let color: string = "blue";
let sentence: string = La couleur est ${color};

// Array
let list: number[] = [1, 2, 3];
let list2: Array = [1, 2, 3];
let matrix: number[][] = [[1, 2], [3, 4]];

// Tuple
let tuple: [string, number] = ["hello", 10];
let rgb: [number, number, number] = [255, 0, 0];

// Enum
enum Color {
  Red,
  Green,
  Blue
}
let c: Color = Color.Green;

// Enum avec valeurs
enum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT"
}

// Const enum (optimisé)
const enum Status {
  Active = 1,
  Inactive = 0
}

// Any (éviter si possible)
let notSure: any = 4;
notSure = "maybe a string";
notSure = false;

// Unknown (préférer à any)
let value: unknown = 4;
if (typeof value === "number") {
  let num: number = value;  // OK après type guard
}

// Void
function logMessage(message: string): void {
  console.log(message);
}

// Null et Undefined
let u: undefined = undefined;
let n: null = null;

// Never (ne retourne jamais)
function error(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}

// Object
let obj: object = { name: "John" };
let obj2: { name: string; age: number } = {
  name: "John",
  age: 30
};

Type assertions

// Deux syntaxes
let someValue: unknown = "this is a string";
let strLength1: number = (someValue as string).length;
let strLength2: number = (someValue).length;

// Non-null assertion (!)
function processValue(value: string | null) {
  // Assert que value n'est pas null
  console.log(value!.toUpperCase());
}

// Const assertion
let x = "hello" as const;  // Type: "hello", pas string
let arr = [1, 2, 3] as const;  // Type: readonly [1, 2, 3]

let obj = {
  name: "John",
  age: 30
} as const;  // Propriétés readonly

// Satisfies (TypeScript 4.9+)
type Color = { r: number; g: number; b: number } | string;

const red = { r: 255, g: 0, b: 0 } satisfies Color;
// red.r est accessible (type inféré)

const blue = "#0000FF" satisfies Color;
// blue.toUpperCase() est accessible

Interfaces et Types

Interfaces

// Interface basique
interface User {
  id: number;
  name: string;
  email: string;
}

const user: User = {
  id: 1,
  name: "John",
  email: "john@example.com"
};

// Propriétés optionnelles
interface Config {
  color: string;
  width?: number;  // Optionnel
  height?: number;
}

// Propriétés readonly
interface Point {
  readonly x: number;
  readonly y: number;
}

let p: Point = { x: 10, y: 20 };
// p.x = 5;  // Erreur

// Index signatures
interface StringArray {
  [index: number]: string;
}

let myArray: StringArray = ["Bob", "Fred"];

interface Dictionary {
  [key: string]: any;
}

let dict: Dictionary = {
  name: "John",
  age: 30
};

// Méthodes
interface Calculator {
  add(a: number, b: number): number;
  subtract(a: number, b: number): number;
}

// Ou avec syntaxe propriété
interface Calculator2 {
  add: (a: number, b: number) => number;
  subtract: (a: number, b: number) => number;
}

// Extension d'interface
interface Person {
  name: string;
  age: number;
}

interface Employee extends Person {
  employeeId: string;
  department: string;
}

// Extension multiple
interface Timestamped {
  createdAt: Date;
  updatedAt: Date;
}

interface Article extends Person, Timestamped {
  title: string;
  content: string;
}

// Fusion d'interfaces (declaration merging)
interface Window {
  title: string;
}

interface Window {
  theme: string;
}

// Window a maintenant title et theme

// Call signatures
interface SearchFunc {
  (source: string, subString: string): boolean;
}

let mySearch: SearchFunc = function(src, sub) {
  return src.search(sub) > -1;
};

// Construct signatures
interface ClockConstructor {
  new (hour: number, minute: number): ClockInterface;
}

interface ClockInterface {
  tick(): void;
}

Type aliases

// Type alias basique
type ID = string | number;
type Point = { x: number; y: number };

// Union types
type Status = "pending" | "active" | "inactive";
type Result = Success | Failure;

// Intersection types
type Person = { name: string; age: number };
type Employee = { employeeId: string; department: string };
type Worker = Person & Employee;

const worker: Worker = {
  name: "John",
  age: 30,
  employeeId: "E123",
  department: "IT"
};

// Tuple types
type RGB = [number, number, number];
type RGBA = [...RGB, number];

// Function types
type MathOperation = (a: number, b: number) => number;
type Predicate = (value: T) => boolean;

// Recursive types
type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

type TreeNode = {
  value: T;
  children?: TreeNode[];
};

// Template literal types
type Greeting = Hello ${string};
type EventName = on${Capitalize};

// Interface vs Type
// Interface peut être étendue par declaration merging
// Type peut faire unions, intersections, mapped types
// Interface meilleure pour objets publics (classes, APIs)
// Type meilleur pour compositions complexes

Génériques

Bases des génériques

// Fonction générique
function identity(arg: T): T {
  return arg;
}

let output1 = identity("hello");
let output2 = identity(42);  // Type inféré

// Array générique
function firstElement(arr: T[]): T | undefined {
  return arr[0];
}

const first = firstElement([1, 2, 3]);  // number | undefined

// Multiple type parameters
function pair(first: T, second: U): [T, U] {
  return [first, second];
}

const p = pair("hello", 42);  // [string, number]

// Constraints (contraintes)
interface HasLength {
  length: number;
}

function logLength(arg: T): void {
  console.log(arg.length);
}

logLength("hello");  // OK
logLength([1, 2, 3]);  // OK
logLength({ length: 10, value: 3 });  // OK
// logLength(42);  // Erreur

// Contraintes avec keyof
function getProperty(obj: T, key: K): T[K] {
  return obj[key];
}

const person = { name: "John", age: 30 };
const name = getProperty(person, "name");  // string
const age = getProperty(person, "age");    // number
// getProperty(person, "invalid");  // Erreur

// Default type parameters
function createArray(length: number, value: T): T[] {
  return Array(length).fill(value);
}

const arr1 = createArray(3, "x");  // string[]
const arr2 = createArray(3, 0);  // number[]

Génériques avec classes

// Classe générique
class Container {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }

  setValue(value: T): void {
    this.value = value;
  }
}

const stringContainer = new Container("hello");
const numberContainer = new Container(42);

// Classe avec contraintes
class Collection {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  findById(id: number): T | undefined {
    return this.items.find(item => item.id === id);
  }
}

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

const users = new Collection();
users.add({ id: 1, name: "John" });

// Generic interfaces
interface Repository {
  getAll(): T[];
  getById(id: number): T | undefined;
  create(item: Omit): T;
  update(id: number, item: Partial): T;
  delete(id: number): void;
}

class UserRepository implements Repository {
  private users: User[] = [];

  getAll(): User[] {
    return this.users;
  }

  getById(id: number): User | undefined {
    return this.users.find(u => u.id === id);
  }

  create(data: Omit): User {
    const user: User = { id: Date.now(), ...data };
    this.users.push(user);
    return user;
  }

  update(id: number, data: Partial): User {
    const index = this.users.findIndex(u => u.id === id);
    this.users[index] = { ...this.users[index], ...data };
    return this.users[index];
  }

  delete(id: number): void {
    this.users = this.users.filter(u => u.id !== id);
  }
}

Types utilitaires

Partial, Required, Readonly

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

// Partial - Rend toutes propriétés optionnelles
type PartialUser = Partial;
// { id?: number; name?: string; email?: string; age?: number; }

function updateUser(id: number, updates: Partial) {
  // updates peut contenir n'importe quelle combinaison
}

updateUser(1, { name: "John" });
updateUser(1, { email: "john@example.com", age: 30 });

// Required - Rend toutes propriétés obligatoires
interface Config {
  host?: string;
  port?: number;
  timeout?: number;
}

type RequiredConfig = Required;
// { host: string; port: number; timeout: number; }

// Readonly - Rend toutes propriétés readonly
type ReadonlyUser = Readonly;

const user: ReadonlyUser = {
  id: 1,
  name: "John",
  email: "john@example.com",
  age: 30
};
// user.name = "Jane";  // Erreur

// Readonly avec arrays
type ReadonlyArray = readonly T[];

const numbers: ReadonlyArray = [1, 2, 3];
// numbers.push(4);  // Erreur
// numbers[0] = 10;  // Erreur

Pick, Omit, Extract, Exclude

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  role: "admin" | "user";
  createdAt: Date;
}

// Pick - Sélectionne propriétés
type UserPreview = Pick;
// { id: number; name: string; email: string; }

// Omit - Exclut propriétés
type UserWithoutPassword = Omit;
// Tous les champs sauf password

type PublicUser = Omit;

// Extract - Extrait types assignables à U
type Role = "admin" | "user" | "guest";
type AdminOrUser = Extract;
// "admin" | "user"

type Primitive = string | number | boolean | null | undefined;
type StringOrNumber = Extract;
// string | number

// Exclude - Exclut types assignables à U
type NonAdmin = Exclude;
// "user" | "guest"

type NonNullable = Exclude;
type Name = NonNullable;
// string

Record, Map types

// Record - Objet avec clés K et valeurs T
type PageInfo = Record;

const pages: PageInfo = {
  home: { title: "Home", url: "/" },
  about: { title: "About", url: "/about" },
  contact: { title: "Contact", url: "/contact" }
};

// Avec union de clés
type Page = "home" | "about" | "contact";
type PageData = Record;

// Dictionnaires typés
type UserRoles = Record;

const roles: UserRoles = {
  1: "admin",
  2: "user",
  3: "user"
};

// Map avec génériques
type ResponseMap = Record;

// Mapped types
type Nullable = {
  [P in keyof T]: T[P] | null;
};

type NullableUser = Nullable;
// Chaque propriété peut être null

// Mapped types avec modificateurs
type Mutable = {
  -readonly [P in keyof T]: T[P];
};

type Optional = {
  [P in keyof T]?: T[P];
};

type Concrete = {
  [P in keyof T]-?: T[P];
};

ReturnType, Parameters, ConstructorParameters

// ReturnType - Type de retour d'une fonction
function createUser(name: string, age: number) {
  return { name, age, id: Math.random() };
}

type User = ReturnType;
// { name: string; age: number; id: number; }

function getConfig() {
  return { host: "localhost", port: 3000 };
}

type Config = ReturnType;

// Parameters - Tuple des types de paramètres
type CreateUserParams = Parameters;
// [name: string, age: number]

function callWithParams(fn: typeof createUser, params: CreateUserParams) {
  return fn(...params);
}

// ConstructorParameters - Paramètres de constructeur
class Point {
  constructor(public x: number, public y: number) {}
}

type PointParams = ConstructorParameters;
// [x: number, y: number]

// InstanceType - Type d'instance d'une classe
type PointInstance = InstanceType;
// Point

// ThisParameterType - Type du paramètre this
function toHex(this: number) {
  return this.toString(16);
}

type Num = ThisParameterType;
// number

// OmitThisParameter - Retire this des paramètres
type ToHexFunction = OmitThisParameter;
// () => string

Awaited, Promise types

// Awaited - Type résolu d'une Promise
type Response = Awaited>;
// string

type NestedResponse = Awaited>>;
// number

async function fetchUser(): Promise {
  const response = await fetch("/api/user");
  return response.json();
}

type FetchedUser = Awaited>;
// User

// Avec génériques
type UnwrapPromise = T extends Promise ? U : T;

type A = UnwrapPromise>;  // string
type B = UnwrapPromise;           // string

// Utility pour async functions
type AsyncReturnType Promise> =
  T extends (...args: any) => Promise ? R : any;

type UserData = AsyncReturnType;
// User

Types conditionnels

Syntaxe de base

// Conditional type: T extends U ? X : Y
type IsString = T extends string ? true : false;

type A = IsString;   // true
type B = IsString;   // false

// Avec génériques
type TypeName =
  T extends string ? "string" :
  T extends number ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

type T0 = TypeName;    // "string"
type T1 = TypeName;    // "number"
type T2 = TypeName<() => void>; // "function"

// Infer keyword
type ReturnType = T extends (...args: any[]) => infer R ? R : any;

type Func = (x: string) => number;
type Return = ReturnType;  // number

// Infer avec arrays
type Flatten = T extends Array ? U : T;

type Str = Flatten;    // string
type Num = Flatten;      // number

// Infer avec Promises
type UnwrapPromise = T extends Promise ? U : T;

type P = UnwrapPromise>;  // string

// Nested infer
type DeepFlatten = T extends Array
  ? DeepFlatten
  : T;

type Deep = DeepFlatten;  // number

// Distributive conditional types
type ToArray = T extends any ? T[] : never;

type StrOrNum = ToArray;
// string[] | number[] (distribué)

// Non-distributive (avec tuple)
type ToArrayNonDist = [T] extends [any] ? T[] : never;

type Combined = ToArrayNonDist;
// (string | number)[]

// Filtrer types null/undefined
type NonNullable = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type DefiniteString = NonNullable;  // string

// Extraire types de fonction
type FunctionPropertyNames = {
  [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T];

interface User {
  id: number;
  name: string;
  save(): void;
  delete(): void;
}

type UserMethods = FunctionPropertyNames;
// "save" | "delete"

// Construire type depuis méthodes
type MethodsOnly = Pick>;

type UserMethodsType = MethodsOnly;
// { save(): void; delete(): void; }

// Deep Readonly
type DeepReadonly = {
  readonly [P in keyof T]: T[P] extends object
    ? DeepReadonly
    : T[P];
};

interface Config {
  database: {
    host: string;
    port: number;
    credentials: {
      user: string;
      password: string;
    };
  };
}

type ReadonlyConfig = DeepReadonly;
// Tous les niveaux sont readonly

// Deep Partial
type DeepPartial = {
  [P in keyof T]?: T[P] extends object
    ? DeepPartial
    : T[P];
};

// Require certain properties
type RequireKeys = T & Required>;

interface User {
  id?: number;
  name?: string;
  email?: string;
}

type UserWithId = RequireKeys;
// id est required, name et email optional

// Make certain properties optional
type PartialKeys =
  Omit & Partial>;

interface Product {
  id: number;
  name: string;
  price: number;
}

type ProductUpdate = PartialKeys;
// id required, name et price optional

// Function type helper
type Promisify = T extends (...args: infer A) => infer R
  ? (...args: A) => Promise
  : never;

type SyncFn = (x: number, y: string) => boolean;
type AsyncFn = Promisify;
// (x: number, y: string) => Promise