No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Regálate acceso ilimitado a todos los cursos por 1 año a precio especial de Navidad 🎄

Antes: $199

Currency
$149/año
regístrate

termina en:

16D
13H
48M
35S

ES12: promise-any y métodos privados

35/38
Recursos

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).

Aportes 7

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Hola [email protected] 😃

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);

Si le das click a la Tecla . en un repo en github.com lo abre en github.dev que es como Visual Studio, el editor que usa el profe

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.

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.  ****

Que buenos metodos

 //Metodo privado------------------------------------------
    //Solo se puede acceder a este metodo desde dentro de la clase
    #metodoPrivado()
    {
        console.log("Hola, soy un metodo privado");
    }

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 😉