Class expressions

Cuando declaramos una class expressions, el nombre de nuestra clase sera opcional y en caso de que lo especifiquemos esta no sera accesible desde fuera del scope dela clase.
El tipo de la clase, no podrá ser instanciado directamente, pero si podemos realizar una igualación de tipos .

let Point = class {
    constructor(public x: number, public y: number) { }
    public length() {
        return Math.sqrt(this.x * this.x + this.y * this.y);
    }
};
var p = new Point(3, 4);  // p has anonymous class type
console.log(p.length());

Extending expressions

Hasta este momento heramos capaces de extender una clase mediante la palabra reservada extends, pero a la hora de extender un tipo solo podemos hacerlo si conocíamos con exactitud el tipo del cual íbamos a extender.
Ahora podemos extender una clase, a través de la llamada de una función y basándonos en su tipo de retorno (las clases retornas deben cumplir con la condición de que sus constructores tengan la misma firma),.

class ThingA {
    getGreeting() { return "Hello from A"; }
}

class ThingB {
    getGreeting() { return "Hello from B"; }
}

class Thingc {
   constructor(name: string) { }
   getGreeting() { return "Hello from c"; }
}
interface Greeter {
    getGreeting(): string;
}

interface GreeterConstructor {
    new (): Greeter;
}

function getGreeterBase(): GreeterConstructor {
    return Math.random() >= 0.5 ? ThingA : ThingB;
}

class Test extends getGreeterBase() {
    sayHello() {
        console.log(this.getGreeting());
    }
}

En este ejemplo la clase Test hereda la llamada a la función  getGreeterBase(), la cual retorna una interface del tipo  GreeterConstructor, como las clases ThingA y ThingB cumplen con la condición de poseer la misma firma en su constructor, estas pueden se retornadas por la función.
Ahora si en su lugar intentáramos que la funcióngetGreeterBase(), retornase una instancia de la clase ThingC el compilador nos arrojaría un error indicando que la clase  ThingC no cumple con la misma firma de constructor.

Abstract classes and methods

Cuando declaramos una clase del tipo abstract, esta clase puede poseer métodos implementados o puede poseer métodos abstracts.
En el caso de tener métodos abstract, estos métodos no tendrán una implementación en nuestra clase abstract, si no que deberán de ser implementados en nuestras clases hijas (clases que hereden de nuestra clase abstract)
De igual modo nuestras clases abstract solo pueden ser heredadas, pero nunca instanciadas.

abstract class Base {
    abstract getThing(): string;
    getOtherThing() { return 'hello'; }
}

let x = new Base(); // Error, 'Base' is abstract

// Error, must either be 'abstract' or implement concrete 'getThing'
class Derived1 extends Base { }

class Derived2 extends Base {
    getThing() { return 'hello'; }
    foo() {
        super.getThing();// Error: cannot invoke abstract members through 'super'
    }
}

var x = new Derived2(); // OK
var y: Base = new Derived2(); // Also OK
y.getThing(); // OK
y.getOtherThing(); // OK

Generic type aliases

Posibilidad de utilizar generics en nuestros alias

interface Tuple<A, B> {
 a: A;
 b: B;
}

type Pair<T> = Tuple<T, T>;

var par: Pair<string>;

par.a = "Test";
par.b = 1; //Error

Stricter object literal assignment checks

Ahora TypeScript valida la declaraciones de objetos literales.

var x: { foo: number };
x = { foo: 1, baz: 2 };  // Error, excess property `baz`

var y: { foo: number, bar?: number };
y = { foo: 1, baz: 2 };  // Error, excess or misspelled property `baz`

Podemos usar index signature, para permitir algunas variantes.

var x: { foo: number, [x: string]: any };
x = { foo: 1, baz: 2 };  // Ok, `baz` matched by index signature

ES6 generators

Solo vamos a poder hacer uso de esta nueva caracteristica si tenemso activado nuestro targeting en ES6

tsconfig.json

{
    "compilerOptions": {
        "module": "commonjs",
        "target": "es6",
        "noImplicitAny": false,
        "sourceMap": false
    }
}

Podemos indicar el tipo de retorno

function *g(name:string): Iterable<string> {
    for (var i = 0; i < 100; i++) {
        yield ""; // string is assignable to string
    }    
}

Podemos dejar que infiera el tipo de retorno

function *g() {
    for (var i = 0; i < 100; i++) {
        yield ""; // infer string
    }
}