09. Typescript

Typescript

TypeScript es un lenguaje de programación de código abierto, desarrollado y mantenido por Microsoft. Es un superconjunto(superset) de JavaScript, que esencialmente añade tipos estáticos y objetos basados en clases. Se transpila a JS (fácilmente usando parcel-bundler).

Tipos básicos

• boolean: Valor verdadero o falso.

let muted: boolean = true;

• number: Números.

let numerador: number = 42;

• string: Cadenas de texto.

let saludo: string = `Me llamo ${nombre}`;

• string[]: Arreglo del tipo cadena de texto.

let people: string[] = [];

• Array: Arreglo multi-tipo, acepta cadenas de texto o números.

let peopleAndNumbers: Array<string | number> = [];

• enum: Es un tipo especial llamado enumeración.

enum Color {
  Rojo = "Rojo",
  Verde = "Verde",
  Azul = "Amarillo",
}
let colorFavorito: Color = Color.Azul;

• any: Cualquier tipo.

let comodin: any  = "Joker";
comodin = { type: "WildCard" }

• object: Del tipo objeto.

let someObject: object = { type: "WildCard" };

Funciones

function add(a: number, b: number): number {
  return a + b;
}
const sum = add(4, 25)

function createAdder(a: number): (number) => number {
  return function (b: number) {
    return a + b;
  }
}

Interfaces

interface Rectangulo {
  height: number,
  width: number
}

let rect: Rectangulo = {
  height: 4,
  width: 3
}

Clases

JavaScript tradicional utiliza funciones y herencia basada en prototipos

class Greeter {
    greeting: string;

    constructor(message: string) {
        this.greeting = message;
    }

    greet() {
        return"Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

Herencia

class Animal {
    move(distanceInMeters: number = 0) {
        console.log(`Animal moved ${distanceInMeters}m.`);
    }
}

class Dog extends Animal {
    bark() {
        console.log('Woof! Woof!');
    }
}

const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();

Modificadores de Acceso

Public (default)

class Animal {
    public name: string;
    public constructor(theName: string) { this.name = theName; }
    public move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

Private

No se puede acceder desde afuera de su clase.

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name; // Error: 'name' is private;

Protected

Similar a private, añadiendo que las clases derivadas también pueden accederlo.

class Person {
    protected name: string;
    constructor(name: string) { this.name = name; }
}

class Employee extends Person {
    private department: string;

    constructor(name: string, department: string) {
        super(name);
        this.department = department;
    }

    public getElevatorPitch() {
        return`Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // error