Promesas y Métodos Privados en JavaScript: ECMAScript 12

Clase 32 de 35 • Curso de ECMAScript: Historia y Versiones de JavaScript

Resumen

Las siguientes características de ES12 o ES2021 que aprenderás son: métodos privados en clases y Promise.any.

Métodos privados de clases

Los métodos privados consiste en limitar el acceso a propiedades y métodos agregando el caracter numeral ( #). Por defecto, las propiedades y métodos de una clase en JavaScript son públicas, es decir, se puede acceder a ellos fuera de la clase.

class Clase {
  #private(valor){
    console.log(valor)
  }
  
  public(valor){
    console.log(valor)
  }
}

const clase = new Clase()
clase.public("Hola")  // 'Hola'
clase.private("Hola") // TypeError: clase.private is not a function

Promise.any

Promise.any() es otra forma de manejar varias promesas, que retornará la primera promesa que sea resuelta y rebotará si todas las promesas son rechazadas.

const promesa1 = Promise.reject("Ups promesa 1 falló")
const promesa2 = Promise.reject("Ups promesa 2 falló")
const promesa3 = Promise.resolve("Promesa 3")


Promise.any([promesa1, promesa2, promesa3])
    .then(respuesta => console.log(respuesta)) // Promise 3
    .catch(error => console.log(error))

Contribución creada por Andrés Guano (Platzi Contributor).

Yuli Alexandra Pulido Castañeda

student•

Hola Chic@s :)

ES12:

Promise-any

const promise1 = new Promise((resolve, reject) => reject("reject"));
const promise2 = new Promise((resolve, reject) => resolve("resolve"));
const promise3 = new Promise((resolve, reject) => resolve("resolve2"));

Promise.any([promise1, promise2, promise3])
.then(response => console.log(response));

Métodos privados

// declaracion de una clase
class User {};
// genera una instancia
//const newUser = new User ();

class user {
 // metodos
greeting() {
    return "hello";
}
};

const gndx = new user();
console.log(gndx.greeting());
const bebeloper = new user();
console.log(bebeloper.greeting());

// constructor

class user { 
    constructor() {
        console.log("Nuevo usuario");
    }
    greeting() {
        return "hello";
    }
}

const david = new user();

// this

class user {
    constructor(name) {
        this.name = name;
    }
    // metodos
    speak() {
        return "Hello";
    }
    greeting() {
        return `${this.speak()} ${this.name}`;
    }
}
const ana = new user("Ana");
console.log(ana.greeting());

// setters getters

class user {
    //constructor
    constructor(name, age) {
        this.name = name;
        this.age = age
    }
    // metodos
    #speak() {
        return "Hello";
    }
    greeting() {
        return `${this.speak()} ${this.name}`;
    }

    get #uAge() {
        return this.age;
    }
    set #uAge(n) {
        this.age = n;
    }
}

const bebeloper1 = new user ("david", 15);
console.log(bebeloper1.uAge);
console.log(bebeloper1.uAge = 20);

Josue Cerron Tuesta

student•

Gracias!

Bernardo Di Leo

student•

Promise.any va a capturar la respuesta de la primera que sea de forma satisfactoria. Si es reject la ignora y devuelve el primer resolve.

Metodos privados: Agregando # los métodos se vuelven privados y solo pueden ser accedidos dentro de la misma clase.

Kyb3r Cipher

student•

Buen resumen

Kath Bonilla

student•

Me arrojaba este error, se soluciona actualizando Node.js, el método Promise.any fue compatible con node.js 15.0.0, por lo que puede actualizarla

TypeError: Promise.any is not a function                                                                                   
    at PromiseAnyService.validateAll_Type1 (E:\typescript-2020-1\promise-usages-1\lib\basics1\promise-any.service.js:18:17)
    at Object.<anonymous> (E:\typescript-2020-1\promise-usages-1\lib\test.js:35:7)                                         
    at Module._compile (internal/modules/cjs/loader.js:1137:30)                                                            
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1157:10)                                              
    at Module.load (internal/modules/cjs/loader.js:985:32)                                                                 
    at Function.Module._load (internal/modules/cjs/loader.js:878:14)                                                       
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)                                    
    at internal/main/run_main_module.js:17:47                                                                              
 ERROR  Command failed with exit code 1.  ****

Gustavo Gonzalez Montero

student•

Para agregar un poco más sobre este problema. A pesar de tener instalada una versión actualizada de Node, en VS code se puede seguir presentando el problema. Yo tengo Node 16.17.0 LTS y me daba el mismo error si lo ejecutaba desde la terminal de vscode. Probé desde la terminal iTerm2 en mi Mac y el problema no aparece. Luego noté que el mismo VS Code me estaba avisando de una actualización de versión y que necesitaba reiniciar. Le di actualizar y una vez que reinició el problema desapareció. Moraleja: No te fíes de la terminal de VS Code siempre 😜

Raul Santos

student•

Tenias toda la razon, igual me salia el erro pero gracias a ti ya lo pude solucionar, gracias!

Gustavo Gonzalez Montero

student•

Hola profe @gndx, me podría dar una explicación de porque son importantes los métodos privados en las clases y porque razón ahora la lógica con los métodos get y set privados devuelven "undefined" y un valor numérico, en ves de devolver en ambos casos "undefined"?

Diego Fernando Mera Largo

student•

si mal no recuerdo, uno vuelve privados los metodos que tienen una importancia grande y por ende no queremos que alguien pueda acceder a dicho metodo y a lo mejor modificarlo 🤔

Gustavo Gonzalez Montero

student•

Estuve revisando y parece que el "=" el lenguaje lo interpreta como el nullish "??" 🤷🏼‍♂️

Reinaldo Mendoza

student•

Los privados en JS se sugerían con el _ al inicio de las variables, con el # ahora si son realmente privados, aunque, ahi tienes TypeScript 😉

Alvaro Eduardo Garzón Pira

student•

Como que hizo falta un ejemplo de como llamar este método privado o como llamar al getter / setter, solo se volvió privado pero en ningún momento se hacía el ejemplo de llamarlo desde dentro de la misma clase ¿O no? 🤨🤨🤨

Alvaro Eduardo Garzón Pira

student•

¡Pues se te tiene un ejemplo! Como lo dijo Oscar, un método privado solo puede llamarse desde dentro de la misma clase, ejemplo, desde otro método 😉, échale un vistazo al siguiente código:

class User {
  constructor(name = 'Alvaro', lastName = 'Garzón', age = 25) {
    console.log('New user: ', name, lastName);
    this.name = name;
    this.lastName = lastName;
    this.age = age;
  }
  greeting() {
    const privateSpeak = this.#speak('Hello!');
    console.log(privateSpeak);
    return `My name is ${this.name} ${this.lastName} and I'm ${this.age} years old`;
  }
  #speak(message) {
    return `Hey! ${message}`;
  }
  get #uAge() {
    return this.age;
  }
  set #uAge(n) {
    this.age = n;
  }
}

const user = new User('Alvaro', 'Garzón', 25);
const greet = user.greeting();
console.log(greet);

Como te das cuenta, el método privado #speak se llama desde el método publico greeting, en la parte this.#speak, te reto a que dejes en los comentarios como se llamaría un getter privado 😃 y espero haberte ayudado aunque sea un poco.

David Esteban Giraldo Duque

student•

El uso de # puede ser importante cuando se trabaja con POO para lograr encapsulamiento. Aquí dejó cómo se vería el ejemplo de la clase utiliazándolo:

class User {
  #name
  #age
  // Constructor
  constructor(name, age) {
    this.#name = name
    this.#age = age
  }
  // Métodos
  #speak() {
    return "Hello"
  }
  greeting() {
    return `${this.#speak()} ${this.#name}`
  }
  get age() {
    return this.#age
  }
  set age(n) {
    this.#age = n
  }
}

Ernesto Edgar Zarate Gutierrez

student•

Que tal David. En que documentación encontraste que se debe inicializar así las variables en la clase? sin let, var o const?

David Esteban Giraldo Duque

student•

Mira, en esta documentación lo puedes encontrar. Allí se menciona que los campos de las clases son similares a las propiedades de los objetos, no son variables, así que no se usan var, let o const para declararlos. Además, menciona los # para declararlos privados.

Gustavo Gonzalez Montero

student•

El Promise.any no me está funcionando:

Promise.any([promise1, promise2, promise3])
        ^

TypeError: Promise.any is not a function

Este es mi código:

const promise1 = new Promise((resolve, reject) => reject('Reject'));
const promise2 = new Promise((resolve, reject) => resolve('Resolve'));
const promise3 = new Promise((resolve, reject) => resolve('Resolve 2'));

Promise.any([promise1, promise2, promise3])
  .then(response => console.log(response));

Y esta es mi versión instalada de node:

❯ node
Welcome to Node.js v16.17.0.
Type ".help" for more information.
>

Cuál es el problema?

Gustavo Gonzalez Montero

student•

Hola ya resolví el problema:

A pesar de tener instalada una versión actualizada de Node, en VS code se puede seguir presentando el problema. Yo tengo Node 16.17.0 LTS y me daba el mismo error si lo ejecutaba desde la terminal de vscode. Probé desde la terminal iTerm2 en mi Mac y el problema no aparece. Luego noté que el mismo VS Code me estaba avisando de una actualización de versión y que necesitaba reiniciar. Le di actualizar y una vez que reinició el problema desapareció. Moraleja: No te fíes de la terminal de VS Code siempre 😜

Felix Torres Javier Antonio

student•

por lo que ví, a la mejor y te faltaba guardar el archivo, tal vez lo dejaste a medias y no lo guardaste y luego intentaste ejecutarlo.

SALUDOS!!!

Jorge Méndez Ortega

student•

porque en algunos videos si agregan la transcripción y en otros no que onda con eso?

Luis Alfredo Suarez

student•

ES12: promise-any y métodos privados

Aquí tienes una explicación sobre las características "Promise.any" y los "métodos privados", introducidos en ECMAScript 12 (ES2021):

Promise.any:

La función Promise.any es una adición a las funcionalidades relacionadas con las promesas en JavaScript. Permite que una lista de promesas se resuelva tan pronto como una de las promesas se cumpla. Si todas las promesas son rechazadas, entonces se devuelve un error.
Ejemplo de uso de Promise.any:

const promises = [
  fetch('https://api.example.com/data-1'),
  fetch('https://api.example.com/data-2'),
  fetch('https://api.example.com/data-3')
];

Promise.any(promises)
  .then(result => {
    console.log('Se cumplió al menos una promesa:', result);
  })
  .catch(error => {
    console.error('Todas las promesas fueron rechazadas:', error);
  });

En este ejemplo, Promise.any se resuelve tan pronto como una de las promesas dentro del arreglo se cumple. Si todas las promesas son rechazadas, se captura el error.

Métodos Privados:

Los "métodos privados" son métodos de una clase en JavaScript que solo pueden ser accedidos y llamados desde dentro de la misma clase. Esto ayuda a encapsular la lógica interna de la clase y evita que sean utilizados directamente desde fuera de la misma.
Sintaxis de un método privado:

class MiClase {
  #metodoPrivado() {
    // Este es un método privado
  }

  metodoPublico() {
    // Este es un método público que puede acceder al método privado
    this.#metodoPrivado();
  }
}

En este ejemplo, #metodoPrivado es un método privado dentro de la clase MiClase. Solo puede ser llamado desde otros métodos dentro de la misma clase, como metodoPublico.
Es importante tener en cuenta que los métodos privados utilizan la notación # antes del nombre del método para indicar su privacidad.
Recuerda que las características mencionadas están disponibles en ECMAScript 12 (ES2021) en adelante, por lo que debes asegurarte de que el entorno en el que estás ejecutando tu código sea compatible con ellas.

Espero sea de utilidad. 👨‍💻

Andrés Soret Chacin

student•

Uno de los principios más importantes de la programación orientada a objetos: delimitar la interfaz interna de la externa.

Esa es una práctica “imprescindible” en el desarrollo de algo más complejo que una aplicación “hola mundo”.

Para entender esto, alejémonos del desarrollo y volvamos nuestros ojos al mundo real…

Por lo general, los dispositivos que estamos usando son bastante complejos. Pero delimitar la interfaz interna de la externa permite usarlas sin problemas.

Un ejemplo de la vida real

Por ejemplo, una máquina de café. Simple desde el exterior: un botón, una pantalla, algunos agujeros… Y, seguramente, el resultado: ¡excelente café! :)

!https://es.javascript.info/article/private-protected-properties-methods/coffee.jpg

Pero adentro… (una imagen del manual de reparación)

!https://es.javascript.info/article/private-protected-properties-methods/coffee-inside.jpg

Muchos detalles. Pero podemos usarlo sin saber nada.

Las cafeteras son bastante confiables, ¿no es así? Podemos usarlos por años, y solo si algo sale mal, tráigalo para repararlo.

El secreto de la fiabilidad y la simplicidad de una máquina de café: todos los detalles están bien ajustados y ocultos en su interior.

Si retiramos la cubierta protectora de la cafetera, su uso será mucho más complejo (¿dónde presionar?) Y peligroso (puedes electrocutarte).

Como veremos, en la programación los objetos son como máquinas de café.

Pero para ocultar detalles internos, no utilizaremos una cubierta protectora, sino una sintaxis especial del lenguaje y las convenciones.

Interfaz interna y externa

En la programación orientada a objetos, las propiedades y los métodos se dividen en dos grupos:

Interfaz interna – métodos y propiedades, accesibles desde otros métodos de la clase, pero no desde el exterior.
Interfaz externa – métodos y propiedades, accesibles también desde fuera de la clase.

Si continuamos la analogía con la máquina de café, lo que está oculto en su interior: un tubo de caldera, un elemento calefactor, etc., es su interfaz interna.

Se utiliza una interfaz interna para que el objeto funcione, sus detalles se utilizan entre sí. Por ejemplo, un tubo de caldera está unido al elemento calefactor.

Pero desde afuera, una máquina de café está cerrada por la cubierta protectora, para que nadie pueda alcanzarlos. Los detalles están ocultos e inaccesibles. Podemos usar sus funciones a través de la interfaz externa.

Entonces, todo lo que necesitamos para usar un objeto es conocer su interfaz externa. Es posible que no seamos completamente conscientes de cómo funciona dentro, y eso es genial.

Esa fue una introducción general.

En JavaScript, hay dos tipos de campos de objeto (propiedades y métodos):

Público: accesible desde cualquier lugar. Comprenden la interfaz externa. Hasta ahora solo estábamos usando propiedades y métodos públicos.
Privado: accesible solo desde dentro de la clase. Estos son para la interfaz interna.

En muchos otros lenguajes también existen campos “protegidos”: accesibles solo desde dentro de la clase y aquellos que lo extienden (como privado, pero más acceso desde clases heredadas). También son útiles para la interfaz interna. En cierto sentido, están más extendidos que los privados, porque generalmente queremos que las clases heredadas tengan acceso a ellas.

Los campos protegidos no se implementan en JavaScript a nivel de lenguaje, pero en la práctica son muy convenientes, por lo que se emulan.

Ahora haremos una máquina de café en JavaScript con todos estos tipos de propiedades. Una máquina de café tiene muchos detalles, no los modelaremos todos, seremos simples (aunque podríamos).

Proteger “waterAmount”

Hagamos primero una clase de cafetera simple:

class CoffeeMachine {
	waterAmount = 0; // la cantidad de agua adentro

	constructor(power) {
		this.power = power;
		alert( `Se creó una máquina de café, poder: ${power}` );
	}
}

// se crea la máquina de café
let coffeeMachine = new CoffeeMachine(100);

// agregar agua
coffeeMachine.waterAmount = 200;

En este momento las propiedades waterAmount ypower son públicas. Podemos obtenerlos/configurarlos fácilmente desde el exterior a cualquier valor.

Cambiemos la propiedad waterAmount a protegida para tener más control sobre ella. Por ejemplo, no queremos que nadie lo ponga por debajo de cero.

Las propiedades protegidas generalmente tienen el prefijo de subrayado _.

Eso no se aplica a nivel de lenguaje, pero existe una convención bien conocida entre los programadores de que no se debe acceder a tales propiedades y métodos desde el exterior.

Entonces nuestra propiedad se llamará _waterAmount:

class CoffeeMachine {
	_waterAmount = 0;

	set waterAmount(value) {
		if (value < 0) {
			value = 0;
		}
		this._waterAmount = value;
	}

	get waterAmount() {
		return this._waterAmount;
	}

	constructor(power) {
		this._power = power;
	}
}

// se crea la máquina de café
let coffeeMachine = new CoffeeMachine(100);

// agregar agua
coffeeMachine.waterAmount = -10; // _waterAmount se vuelve 0, no -10

Ahora el acceso está bajo control, por lo que establecer una cantidad de agua por debajo de cero se volvió imposible.

“Power” de solo lectura

Para la propiedad power, hagámoslo de solo lectura. A veces sucede que una propiedad debe establecerse solo en el momento de la creación y nunca modificarse.

Ese es exactamente el caso de una máquina de café: la potencia nunca cambia.

Para hacerlo, solo necesitamos hacer getter, pero no setter:

class CoffeeMachine {
	// ...

	constructor(power) {
		this._power = power;
	}

	get power() {
		return this._power;
	}
}

// se crea la máquina de café
let coffeeMachine = new CoffeeMachine(100);

alert(`La potencia es: ${coffeeMachine.power}W`); // Potencia es: 100W

coffeeMachine.power = 25; // Error (sin setter)

“waterLimit” Privada

Hay una propuesta de JavaScript terminada, casi en el estándar, que proporciona soporte a nivel de lenguaje para propiedades y métodos privados.

Los privados deberían comenzar con #. Solo son accesibles desde dentro de la clase.

Por ejemplo, aquí hay una propiedad privada #waterLimit y el método privado de control de agua #fixWaterAmount:

class CoffeeMachine {
	*#waterLimit = 200;

	#fixWaterAmount(value) {
		if (value < 0) return 0;
		if (value > this.#waterLimit) return this.#waterLimit;
	}*

	setWaterAmount(value) {
		this.#waterLimit = this.#fixWaterAmount(value);
	}
}

let coffeeMachine = new CoffeeMachine();

*// no puede acceder a privados desde fuera de la clase
coffeeMachine.#fixWaterAmount(123); // Error
coffeeMachine.#waterLimit = 1000; // Error*

A nivel de lenguaje, # es una señal especial de que el campo es privado. No podemos acceder desde fuera o desde clases heredadas.

Los campos privados no entran en conflicto con los públicos. Podemos tener campos privados #waterAmount y públicos waterAmount al mismo tiempo.

Por ejemplo, hagamos que waterAmount sea un accesorio para #waterAmount:

class CoffeeMachine {
	#waterAmount = 0;

	get waterAmount() {
		return this.#waterAmount;
	}

	set waterAmount(value) {
		if (value < 0) value = 0;
		this.#waterAmount = value;
	}
}

let machine = new CoffeeMachine();

machine.waterAmount = 100;
alert(machine.#waterAmount); // Error

A diferencia de los protegidos, los campos privados son aplicados por el propio lenguaje. Eso es bueno.

Pero si heredamos de CoffeeMachine, entonces no tendremos acceso directo a #waterAmount. Tendremos que confiar en el getter/setter de waterAmount:

class MegaCoffeeMachine extends CoffeeMachine {
	method() {
		*alert( this.#waterAmount ); // Error: solo se puede acceder desde CoffeeMachine*
	}
}

En muchos escenarios, esta limitación es demasiado severa. Si ampliamos una CoffeeMachine, es posible que tengamos razones legítimas para acceder a sus componentes internos. Es por eso que los campos protegidos se usan con más frecuencia, aunque no sean compatibles con la sintaxis del lenguaje.

Edu Socias

student•

Muy buena tu explicación, gracias.

Cesar Torres

student•

También es posible usar atributos privados en las clases de la misma forma en que se definen los metodos privados 😃.

class Person {
  #name; // Private attribute

  constructor(name) {
    this.#name = name; // Initialize the private attribute in the constructor
  }

  getName() {
    return this.#name;
  }

  changeName(newName) {
    this.#name = newName;
  }
}

Jesus Eduardo Castillo Saavedra

student•

Promise.any() es una forma de manejar varias promesas en JavaScript que retorna la primera promesa que se resuelve y rechaza si todas las promesas son rechazadas[1][5]. Por otro lado, los métodos privados son métodos que solo son accesibles dentro de la clase en la que se definen y no pueden ser accedidos desde fuera de la clase[6]. En JavaScript, los campos privados se pueden implementar utilizando la sintaxis # antes del nombre del campo[6].

En resumen, Promise.any() es una forma de manejar varias promesas en JavaScript que retorna la primera promesa que se resuelve y los métodos privados son métodos que solo son accesibles dentro de la clase en la que se definen y no pueden ser accedidos desde fuera de la clase. En JavaScript, los campos privados se pueden implementar utilizando la sintaxis # antes del nombre del campo.

Edwin Calderón

student•

¿Alguien ha probado si hay una manera correcta de ejecutar una función privada desde un objeto? pensé que iba a funcionar con un this.* pero aún así no permite su ejecución.

German Prates

student•

Para que puedas ejecutar correctamente el metodo privado, hay que sumar # el nombre del metodo que se llama, ejemplo:

class User {
    name;
    yearOfBirth;
    constructor(name, yearOfBirth) {
        this.name = name;
        this.yearOfBirth = yearOfBirth;
    }
    //private methods
    #greeting() {
        return `Hello! I\'m ${this.name}!`;
    }
    ...
    presentMe() {
        return `${this.#greeting()}, I'm ${this.age()}`;
    }
    ...
}

Alejandro Mor

student•

Estoy realizando un console.log al usuario creado y ahora, en vez de ser las dos iniciales del constructor, pasaron a ser tres. ¿Alguna idea de por qué pasa esto?

user { name: 'Cly', age: 25, uAge: 30 }

class user {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    #speak() {
        return `Hello`;
    }

    greeting() {
        return `${this.#speak()} ${this.name}`;
    }

    get #uAge() {
        return this.age;
    }

    set #uAge(age) {
        this.age = age;
    }
}

const testUser = new user('Cly', 25);
console.log(testUser.speak); // Undefined, porque '#speak' es un método privado.
console.log(testUser.uAge); // undefined??????  
console.log(testUser.uAge = 30); // 30
console.log(testUser.uAge); // 30
console.log(testUser);

Tomás Argüello

student•

para que sirve response??

Juan Manuel Padilla

student•

Run Code me da TypeError: Promise.any is not a function ¿Alguien sabe por qué?

Francisco Ponce

student•

Posiblemente, sea la version de node que estás utilizando, **Promise.any **se encuentra disponible desde la versión 15.0.0. en Node

Intenta verificando la version de node con el comando:

node -v

Si es menor a la 15, te toca actualizar a una mayor y debería ser posible ejecutar Promise.any

Juan Manuel Padilla

student•

Gracias por tu respuesta. La versión de Node está actualizada. v19.6.1

Beder Danilo Casa Condori

student•

En JavaScript, un caso real de uso del método privado (denotado con #) es en una clase que maneja la seguridad de datos sensibles. Por ejemplo, en una clase User, puedes tener un método privado #validatePassword que verifica si la contraseña ingresada cumple con ciertos criterios. Este método no puede ser accedido desde fuera de la clase, lo que garantiza que la lógica de validación se mantenga encapsulada y protegida de accesos no autorizados. Esto es esencial para mantener la integridad de los datos en aplicaciones que manejan información sensible.

Beder Danilo Casa Condori

student•

Para crear una promesa compleja utilizando Promise.any(), puedes combinar varias promesas en un array. Promise.any() retorna la primera promesa que se resuelve exitosamente, ignorando las que son rechazadas. Aquí tienes un ejemplo:

const promise1 = new Promise((resolve, reject) => setTimeout(reject, 100, 'Error 1'));
const promise2 = new Promise((resolve) => setTimeout(resolve, 200, 'Éxito 2'));
const promise3 = new Promise((resolve) => setTimeout(resolve, 300, 'Éxito 3'));

Promise.any([promise1, promise2, promise3])
  .then(result => console.log(result)) // "Éxito 2"
  .catch(error => console.error(error));

En este caso, promise2 se resuelve primero y su valor "Éxito 2" es el que se obtiene. Esta característica es útil para manejar múltiples llamadas asíncronas donde solo te interesa la primera en resolver.

JOSE MARIA SUAREZ GIESE

student•

Como dato Curioso, cuando hice el ejercicio por mi cuenta, coloqué las variables de esta manera:

const promesa2 = new Promise((reject,resolve) => resolve("Resolve 1"))
```Y el resultado me arrojaba puro Reject, hasta que viendo la clase noté que el orden de las variables es (Resolve, reject).&#x20;
En este caso, el orden de los factores altera el producto.

Promesas y Métodos Privados en JavaScript: ECMAScript 12

Introducción

Historia y evolución de ECMAScript y JavaScript

Actualización y Propuestas en ECMAScript y JavaScript

Configuracion

Configuración de Herramientas para Desarrollo en JavaScript Avanzado

¿Qué se implementó en ES6?

Características de ECMAScript 6 para JavaScript Moderno

Template Literals y Multilínea en ECMAScript 6

Asignación de Parámetros por Defecto en ECMAScript 6

Desestructuración de Arrays y Objetos en JavaScript ECMAScript 6

Uso del Operador de Propagación y Parámetros Rest en JavaScript

Playground: Combina objetos JSON con el Spread Operator

Asignación y manejo de objetos en ECMAScript 6

Promesas en JavaScript: Manejo del Asincronismo con ECMAScript 6

Clases y Herencia en JavaScript: Sintaxis y Aplicaciones

Uso de Módulos en JavaScript ES6

Playground: Obtén una lista de películas

Generators en JavaScript: Cómo implementar y usar iteradores personalizados

Playground: Generador de identificadores para michis

Método ADD en ECMAScript 6: Agregando Elementos a un Set

¿Qué se implementó en ES7?

Actualizaciones de ECMAScript 7: Operadores Exponencial e Includes

¿Qué se implementó en ES8?

Métodos Object.Entries y Object.Values en ECMAScript 8

Manipulación de Strings y Arrays en ECMAScript 8

Async y Await en JavaScript: Controlando el Asincronismo

¿Qué se implementó en ES9?

Novedades de ECMAScript 9: Regex y Spread Operator en JavaScript

Manejo de Finally y Async en ECMAScript 9

¿Qué se implementó en ES10?

Novedades de ECMAScript 10: Métodos flat y trim en JavaScript

Manejo de Errores y Transformaciones de Arrays en JavaScript

¿Qué se implementó en ES11?

Uso de Optional Chaining en JavaScript ES11

Manejo de BigInt y operadores nullish en JavaScript

Promesas en ECMAScript 11: Uso de Promise.allSettled

Uso de Global Disk y Match All en JavaScript

Uso de Dynamic Import en JavaScript para Mejora de Rendimiento Web

¿Qué se implementó en ES12?

Características de ECMAScript 12: Separadores Numéricos y Replace All