TypeScript Cheatsheet

Bases & syntaxe

Déclaration de variable

let x: number = 10;
const y: string = "TypeScript";

Utilisez let pour des variables qui peuvent changer et const pour des valeurs immuables.

Types de base

let a: boolean = true;
let b: number = 42;
let c: string = "Hello";
let d: null = null;
let e: undefined = undefined;

Définissez le type des variables pour une meilleure sécurité et lisibilité.

Tableaux

let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["Alice", "Bob"];

Utilisez les tableaux de types pour stocker plusieurs éléments du même type.

Structures de données

Objets

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

const person: Person = { name: "Alice", age: 25 };

Définissez des structures complexes avec des propriétés typées.

Unions

let value: number | string = 10;

function printValue(value: number | string): void {
    console.log(value);
}

Utilisez les unions pour définir une variable qui peut être de plusieurs types.

Fonctions & methodes essentielles

Arrow Functions

const add = (a: number, b: number): number => a + b;

Les fonctions fléchées offrent une syntaxe plus concise et la capture automatique du this.

Fonction Callback

function filter(arr: number[], callback: (num: number) => boolean): number[] {
    return arr.filter(callback);
}

Utilisez les fonctions de rappel pour traiter des tableaux.

Patterns courants

Decorateurs

function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function(...args: any[]) {
        console.log(`Calling ${propertyKey} with arguments ${JSON.stringify(args)}`);
        return originalMethod.apply(this, args);
    };

    return descriptor;
}

class Calculator {
    @log
    add(a: number, b: number): number {
        return a + b;
    }
}

Les décorateurs sont utilisés pour ajouter des fonctionnalités aux classes et méthodes.

Operations avancees

Types génériques

function identity<T>(arg: T): T {
    return arg;
}

let output = identity<string>("myString");

Utilisez les types génériques pour créer des fonctions réutilisables et typées.

Promesses

function fetchData(): Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Data"), 1000);
    });
}

fetchData().then(data => console.log(data));

Utilisez les promesses pour gérer des opérations asynchrones.

Debugging & outils

Utilisation de console.log

let x = 5;
console.log(`The value of x is ${x}`);

La console est une méthode simple mais efficace pour le débogage.

Outils de développement

• TypeScript Playground: Un environnement en ligne pour tester du TypeScript.
• Visual Studio Code: Offre des fonctionnalités avancées pour développer en TypeScript avec un intellisense et des outils de débogage intégrés.