Ci sono almeno due design patterns comuni in Javascript: quello dei moduli e quello delle classi. Brevemente, quello dei moduli usa le closures per nascondere nomi e per incapsulare i dati privati, mentre quello delle classi usa la prototype chain per implementare le diverse variazioni dell'ereditarietà OOP. Delle librerie come 'prototype.js' sono tipiche per queste cose.

Questa sezione mostrerà come Typescript permette di emettere del codice Javascript consistente ed espressivo per implementare classi e moduli che è fortemente vicino alla proposta di Ecmascript 6. L'obiettivo di Typescript è quello di emettere quello che un programmatore scriverebbe per implementare una classe o un modulo, senza l'aiuto di strumenti. In questa sezione descriveremo anche come Typescript deduce il tipo della dichiarazione di una classe. Cominciamo con una semplice classe per BankAccount:

class BankAccount { 
 balance = 0; 
 deposit(credit: number) { 
   this.balance += credit; 
   return this.balance; 
 } 
} 

Questa classe produce il seguente codice:

var BankAccount = (function () { 
 function BankAccount() { 
   this.balance = 0; 
 } 
 BankAccount.prototype.deposit = function(credit) { 
   this.balance += credit; 
   return this.balance; 
 }; 
 return BankAccount; 
})(); 

Questa classe dichiara una variabile 'BankAccount' il quale valore è il costruttore per le istanze di 'BankAccount'. Se dovessimo dichiarare un'interfaccia per questo tipo, la scriveremmo così:

interface BankAccount { 
 balance: number; 
 deposit(credit: number): number; 
} 

Se scrivessimo per intero la dichiarazione per il costruttore 'BankAccount', avrebbe la seguente forma:

var BankAccount: new() => BankAccount;

La parola chiave 'new' indica che 'BankAccount' dev'essere chiamata come costruttore. E' tuttavia possibile definire una funzione in maniera che sia possibile chiamarla sia come funzione che come costruttore. Ad esempio l'oggetto Date in Javascript permette entrambi.

Se vogliamo che il nostro conto in banca (BankAccount) abbia un bilancio iniziale, possiamo aggiungere un costruttore in questa maniera:

class BankAccount { 
 balance: number; 
 constructor(initially: number) { 
   this.balance = initially; 
 } 
 deposit(credit: number) { 
   this.balance += credit; 
   return this.balance; 
 } 
} 

Questa versione di 'BankAccount' introduce un costruttore che assegna un valore iniziale a balance. Per semplificare le cose, si può usare questo zucchero semantico aggiuntivo per velocizzare la cosa:

class BankAccount { 
 constructor(public balance: number) { 
 } 
 deposit(credit: number) { 
   this.balance += credit; 
   return this.balance; 
 } 
} 

Nota la parola chiave 'public', che informa il compilatore che vogliamo mantenere 'balance' come campo pubblico. Public è il valore di default per i membri di una classe, ma possiamo anche specificare 'private' per mantenere privati alcuni membri. Nota che la visibilità privata è applicabile solamente a design-time tramite static type checking, non a run-time. Questa è una limitazione di Javascript che si spera verrà risolta in future versioni.

Typescript supporta l'ereditarietà, vediamo un esempio:

class CheckingAccount extends BankAccount { 
 constructor(balance: number) { 
   super(balance); 
 } 
 writeCheck(debit: number) { 
   this.balance -= debit; 
 } 
} 

In questo esempio 'CheckingAccount' deriva da 'BankAccount' e il costruttore di 'CheckingAccount' chiama quello di 'BankAccount' usando la parola chiave 'super'. Nel codice Javascript risultante, il prototype di 'CheckingAccount' si concatena con il prototype di 'BankingAccount'. 

Le classi in Typescript possono specificare anche dei membri statici. 

class Test{
  public static a: string;
}