TypeScript

// Création d'une variable contenant une valeur booléenne.
var maValeurBooleenne: boolean = false;
// Création d'une variable contenant une chaîne de caractère.
var maChaineDeCaractere: string = "Hello World";
// Création d'une variable contenant un nombre.
var monNombre: number = 1;
// Création d'une fonction retournant une chaîne de caractère.
function maFonction(): string {
    return "Ma valeur de retour";
}

function maFonction<T>(parametre: T) {
    // Contenu de la fonction.
}

class MaClasse<T> {
    maVariable : T;
    // Contenu de la classe.
}
// Création d'une instance de la classe "MaClasse" en définissant un type.
var monInstance = new MaClasse<string>();
monInstance.maVariable = "Hello World";

interface MonInterface {
    // Création d'une signature de variable.
    maVariable: string;
    // Création d'une signature de méthode.
    maMethode(parametre: string): void;
}
class MaClasse implements MonInterface {
    maVariable: string;
    maMethode(parametre: string): void {
        // Contenu de la méthode.
    }
}
// Précision du type de la variable en utilisant l'interface.
var instance: MonInterface = new MaClasse();

class MaClasseDeBase {
    private _firstname;
    private _lastname;
    public constructor(firstname: string, lastname: string) {
        this._firstname = firstname;
        this._lastname = lastname;
    }
    public direBonjour(): string {
        return "Bonjour " + this._firstname + ", " + this._lastname;
    }
}
// La classe hérite de "MaClasseDeBase".
class MaClasse extends MaClasseDeBase {
    public constructor(firstname: string, lastname: string) {
        // Accède au constructeur de "MaClasseDeBase".
        super(firstname, lastname);
    }
}
// Création d'une instance de "MaClasse" et 
// appel de la méthode: "direBonjour" de la classe parente : "MaClasseDeBase".
var monInstance: MaClasse = new MaClasse("Jean", "Dupond");
monInstance.direBonjour();

module mon.espace.de.nom {
    // Contenu du module: classe, fonction, etc.
}

enum Couleur {Bleu, Rouge, Vert};

enum Couleur {Bleu = 0, Rouge = 1, Vert = 2};

function maFonction(monParametre?: string) {
    // On teste si le paramètre "monParametre" a une valeur.
    //
    // Je ne suis pas spécialiste de TypeScript mais écrire
    // if (monParametre) {
    // n'est pas correct ; le type de la condition DOIT être booléen.
    //
    if (monParametre!="") {
        return monParametre;
    } else {
        // Dans le cas contraire, une valeur par défaut est retournée.
        return "Hello World";
    }
}
// La valeur retournée sera : "Hello World" sans avoir un message d'avertissement lors de la compilation.
var resultat: string = maFonction();
// La valeur retournée sera : "Ma valeur".
var resultat: string = maFonction("Ma valeur");

// La fonction autorise que le paramètre soit une chaîne de caractère ou un tableau de chaîne de caractère.
function maFonction(monParametre: string|string[]): void {
    if (typeof monParametre === "string") {
        // Traitement de ma chaîne de caractère.
    } else {
        // Traitement de mon tableau.
    }
}

// Création d'un alias basé sur le type "number".
type MonAlias = number;
// Utilisation de l'alias ci-dessus.
var monNombre: MonAlias = 1;