🥇 ES6 (ECMAScript 2015).

🍿 ES6 o ECMAScript 2015.

La ultima versión de Node incluye soporte amplio de ES6. Se puede entonces empezar a escribir en código en esta versión, lo que simplifica mucho de la sintaxis de Javascript y expande las características del lenguaje, sin embargo esto es opcional.

Sin embargo al estar utilizando la sintaxis de ES6 del lado del navegador, no todas las opciones pueden estar disponibles. Para solucionar este problema existen soluciones como babeljs.io, que convierte el código ES6 en código compatible con versiones anteriores que puedan ser interpretadas por otros navegadores.

🍿 Clases en ES6.

En ES6 lo primero que requerimos es indicarle que queremos utilizar ES6, para ello podemos empezar por decirle hasta la parte superior del código que deseamos que el scope de nuestro código sea estricto.

'use strict';

Ahora podemos crear nuestra clase Robot.

class Robot {
    constructor(nombre){
        this.nombre = nombre;
    }
}

La sintaxis como vemos es muy similar a la de otros lenguajes.

🍿 Scope.

Una característica de ES6, es la palabra let que nos permite definir el scope de una variable sin tener que hacer uso de var, asi que descontinuamos var en favor de let.

let genialo = new Robot('Genialo');

🍿 Métodos.

En ES6 no es necesario utilizar prototype para agregar métodos a una clase, se pueden agregar diréctamente sobre ella sin siquiera usar la palabra function.

class Robot {
    constructor(nombre){
        this.nombre = nombre;
    }
    saludar(){
        // ... saludar
    }
}

let genialo = new Robot('Genialo');
genialo.saludar();

🍿 String templates.

En Es6 no requerimos concatenar variables, podemos utilizar la nueva sintaxis de templates para imprimir cadenas largas sin tanto problema utilizando la sintáxis de tilder invertidas ````.

class Robot{
    constructor(nombre){
        this.nombre = nombre;
    }

    saludar(){
        console.log(`Hola, mi nombre es ${this.nombre}.`);
    }

    frente(){
        console.log(`${this.nombre} da dos pasos al frente.`);
    }

    atras(){
        console.log(`${this.nombre} da dos pasos atras.`);
    }

}

let genialo = new Robot('Genialo');
genialo.saludar();
genialo.frente();
genialo.atras();

🍿 Super.

Al heredar directamente de clases no es necesario que invoquemos el método call, pero si requerimos que el constructor de la super clase se ejecute, podemos hacer uso de super().

class Robot{
    constructor(nombre){
        super();
        this.nombre = nombre;
    }
    // ...
}

🍿 ES6 Clases y Eventos.

No es necesario utilizar util, ya que al usar clases el propósito de esta queda cubierto por la herencia que proveen las clases como tales.

Podemos definir entonces los emit (emisores) y los eventos para genialo.

// Habilitar el modo estricto
'use strict';

let events = require('events');

class Robot extends events {

    constructor(nombre){
        super();
        this.nombre = nombre;
    }

    saludar(){
        console.log(`Hola, mi nombre es ${this.nombre}.`);
        this.emit('saludar');
    }

    frente(){
        console.log(`${this.nombre} camina al frente.`);
        this.emit('frente');
    }

    atras(){
        console.log(`${this.nombre} camina hacia atras.`);
        this.emit('atras');
    }

}

let genialo = new Robot('Genialo');

genialo.on('frente',function(){
    console.log(this.nombre + ' da dos pasos al frente');
});

genialo.on('atras',function(){
    console.log(this.nombre + ' da dos pasos atras');
});

genialo.saludar();
genialo.frente();
genialo.atras();

🍿 Clases como módulos.

Por ultimo, es posible utilizar nuestra clase como módulo y mandarla llamar como tal.

module.exports = class Robot extends events {
    // ....
Herencia. Síncrono vs asíncrono.
comments powered by Disqus