Working with enumerated types (enum) is like working with numbers. The syntax is as follows:

enum FileAccess {Read, Write}; 

This generates the following JS code:

var FileAccess; 
(function (FileAccess) { 
    FileAccess[FileAccess["Read"] = 0] = "Read"; 
    FileAccess[FileAccess["Writer"] = 1] = "Writer"; 
})(FileAccess || (FileAccess = {})); 

Access to an enumerated type in both the languages is as follows:

var myVar: FileAccess = FileAccess.Read; // Equivalent to 0 

Defining an array with TS is also similar to JS. The following is an example:

// In both languages 
var myArray = []; 
// or 
var myArray = new Array(); 

With TS, array is a generic class. Then, you can specify the item's type contained in the array as follows:

var myArray = new Array<number>(); 

You can now access the common functions as follows:

var myArray = new Array<any>(); 
myArray.push("Hello !");   
myArray.push("1"); 
myArray.splice(0, 1); 
console.log(myArray); // "[1]" 

The syntax in TS to define a class is as follows:

class Writer { 
  constructor() { 
    // initialize some things here 
  } 
} 

This generates the following in JS:

var Writer = (function () { 
    function Writer() { 
    } 
    return Writer; 
})(); 

In both languages, you can create an instance of Writer:

var myInstance = new Writer(); 

You can also use modules that work as namespaces:

module MY_MODULE { 
  class Writer { 
    ... 
  } 
} 

Access:

var writer = new MY_MODULE.Writer(...); 

With JS and the conventions, you can write the following:

function Writer() { 
  this.myPublicMember = 0.0; // A public member 
  this._myPrivateMember = 1.0; // A member used as private 
} 

With TS, you can explicitly specify the access specifier of a member (public, private, and protected), which has been explained as follows:

Let's experiment using the Writer class:

// declare class 
class Writer { 
  // Union types. Can be a "string" or 
// an array of strings "Array<string>" 
  public message: string|string[]; 
  private _privateMessage: string = "private message"; 
  protected _protectedMessage: string; 
 
  // Constructor. Called by the "new" keyword 
  constructor(message: string|string[]) { 
    this.message = message; 
    this._protectedMessage = "Protected message !"; // Allowed 
} 
 
// A public function accessible from everywhere. 
// Returns nothing. Then, its return type is "void". 
public write(): void { 
  console.log(this.message); // Allowed 
  console.log(this._privateMessage); // Allowed 
  console.log(this._protectedMessage); // Allowed 
} 
} 
 
var writer = new Writer("My Public Message !"); 
console.log(writer.message); // Allowed 
console.log(writer._privateMessage); // Not allowed 
console.log(writer._protectedMessage); // Not allowed 

Let's create a new class that specializes the Writer class. The specialized classes can access all the public and protected members of the base class thanks to the inheritance. The extends keyword represents the inheritance.

Let's create a new class named BetterWriter that specializes (extends) the Writer class:

// The base class is "Writer" 
class BetterWriter extends Writer { 
  constructor(message: string|string[]) { 
    // Call the base class' constructor 
    super(message); 
} 
 
// We can override the "write" function 
public write(): void { 
  if (typeof this.message === "string") { 
    // Call the function "write" of the base class 
    // which is the "Writer" class 
    super.write(); 
  } 
  else { 
    for (var i=0; i < this.message.length; i++) { 
      console.log(this.message[i]); // Allowed 
      console.log(this._privateMessage); // Not allowed 
      console.log(this._protectedMessage); // Allowed 
    } 
  } 
} 
} 

Interfaces are used to create contracts. It means that if a class implements an interface, the class must provide all the functions and members defined in the interface. If not, it doesn't respect the contract, and the compiler will output an error.

All the defined functions are public and all the defined members are public.

With Babylon.js, a good example is to use the IDisposable interface. It means that the users can call the method named dispose(). This function's job is to deactivate and/or deallocate the systems used.

The following is an example:

interface IWriter { 
  // The class "Writer" must have the "message" member 
  message: string|string[]; 
  // The class "Writer" must provide the "resetMessages" function. 
  resetMessages(): void; 
} 
 
class Writer implements IWriter { 
  public message: string|string[]; 
... 
  constructor(...) { 
    ... 
} 
... 
// All functions declared in the interface are public. 
public resetMessages(): void { 
  this.message = this._privateMessage = this._protectedMessage = ""; 
} 
}