No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Promesas

9/31
Recursos

Aportes 119

Preguntas 20

Ordenar por:

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

nominado a profesor del a帽o junto con leonidas!!

solo a ti te creo las promesas

Las promesas son una sintaxis mas elegante y legible de realizar callbacks, creando as铆 un c贸digo mucho m谩s escalable y entendible para todas las personas.
Una promesa al final no deja de ser un callback, solo que, con la novedad de tener estados, las promesas cuentan con 3 estados, resuelta, en progreso y en fallo.
Para utilizar una promesa solo debemos de instanciar una nueva, una promesa en si es una funci贸n que recibe dos par谩metros, resolve y reject, que son los dos estados de una promesa.
Utilizamos resolve para retornar el valor deseado cuando una funci贸n se ejecute y utilizamos reject para cuando una funci贸n retorna un valor no deseado.
New Promise( (resolve, reject) => {
鈥ode
If(code === true){
resolve(correctValue);
}else {
Reject(wrongValue);
}
});
Para poder obtener los valores que retorna una funci贸n debemos utilizar su propiedad .then, esta propiedad es una funci贸n que recibe un callback el cual tendr谩 como par谩metro el valor retornado con resolve o reject.
Siempre que usemos una promesa adem谩s de realizar la propiedad .then debemos invocar la propiedad .catch, la cual es un callback que recibe como par谩metro el error ocurrido en caso de haber sucedi贸 uno.

myPromise(鈥楶arameter鈥)
.then( data => console.log(data) )
.catch( err => console.log(err) );

RESUMEN:


Las promesas vienen de los callbacks, pero las promesas lo que hacen es dar un estado.
Las promesas son una 鈥渃lase鈥 global que podemos llamar de donde sea, nuestras funciones devuelvan promesas
Promise(), la diferenia entre promises y callbacks es la capacidad de anidar promesas. Formando una cadena de promesas.
Es muy 煤til para visualizar c贸digo as铆ncrono de manera s铆ncrona.



function hola(nombre) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            console.log('Hola, '+ nombre);
            resolve(nombre);
        }, 1500);
    });
    
}

function hablar(nombre) {
    return new Promise( (resolve, reject) => {
        setTimeout(function() {
            console.log('Bla bla bla bla...');
            //resolve(nombre);
            reject('Hay un error');
        }, 1000);
    });
}

function adios(nombre) {
    return new Promise( (resolve, reject) => {
        setTimeout(function() {
            console.log('Adios', nombre);
            resolve();
        }, 1000);
    });
}

// ---

console.log('Iniciando el proceso..');
hola('Alejandro')
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(adios)
    .then((nombre) => {
        console.log('Terminado el proceso');
    })
    .catch(error => { // Hace parte de a sintaxis de las promesas puedo captar los reject
        console.error('Ha habido un error:');
        console.error(error);
    })

鈥淩ecuerda, esto es nodejs, es com Mad Max, todo puede fallar鈥. 馃捇

Bueno antes de que comience el video quiero recomendar este canal d茅 YouTube, me parece de los mejores junto con el buen Sasha

https://www.youtube.com/watch?v=5XyzLfPBpZs

Cada vez que veo las Promesas flipo en colores. Son s煤per simples y tienen un potencial enorme. Despu茅s de alg煤n tiempo de verlas y practicarlas logro entenderlas cuando las veo aplicadas. Pero a煤n me cuesta horrores entender cu谩ndo usarlas y hacerlo bien. A seguir practicando 馃槃

Les comparto el c贸digo de la clase.

Promesas, forma de trabajar con asincronia, las promesas pueden tene run estado, resultas, no resuletas, fallar.
Son una clase global.
Las promesas se pueden ir anidados.
Siempre que se use un THEN, debe ser acompa帽ado de un manejador de errores CATCH.
Ejemplo del mismo c贸digo con promesas pero se obtiene el mismo resultado en consola.

//funciones
//se crea una promesa que indica el estado del proceso.
//en vez de devolver callback se usara promesa
function hola(nombre){
    return new Promise(function(resolve,reject){
        setTimeout(function(){
            console.log('hola, '+nombre);
            resolve(nombre);
        },1000);
    });
}
function hablar(nombre) {
    return new Promise((resolve,reject)=>{
        setTimeout(function () {
            console.log('bla bla bla bla...');
            resolve(nombre);
        },1000);
    });
}
function adios(nombre) {
    return new Promise((resolve,reject)=>{
        setTimeout(function () {
            console.log('adios',nombre);
            resolve(nombre);
        },1000);
    });
}

//lo que se ejecutara....
console.log('Iniciando el Proceso...')
hola('Alexis')
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(adios)

    .then((nombre)=>{
        console.log('Terminando Proceso');
    })

//cualquier hilo de ejcucion lo llevar谩 al catch para ejecutar su funcion
//console
    .catch(error =>{
        console.error('ha habido un error');
        console.error(error);
    })```

hice el ejercicio con funciones recursivas, funciona pero no se que tan optimo sea por si le quieren echar un ojo

const nombre = process.env.NOMBRE || 'Extra帽o'
const TIME = 1000
const repeticiones = 4

const hola = (Nombre)=> {
      return new Promise((resolve, reject)=>{
            setTimeout( () => {
                  console.log('hola, ' + Nombre)
                  resolve(nombre)
            },TIME)
      })
      
}
const hablar = (nombre) => {
      return new Promise((resolve, reject) => {
            setTimeout(() => {
                  console.log('Bla bla bla bla ....')
                  resolve(nombre)
            },TIME)
      })
}
const adios = (nomb) => {
      return new Promise( (resolve,reject) =>{
            setTimeout( () => {
                  console.log('Adios ' + nomb + '....')
                  resolve(nomb)
            },TIME)
      })
}
const conversacion = (nombre, repeticion) =>{
      return new Promise((resolve, reject) => {
            if(repeticion>0){
                  setTimeout( () =>{
                        conversacion(nombre, --repeticion)
                              .then(hablar(nombre))
                              .catch(error => {
                                    console.error('ah habido un error')
                                    console.error(error)
                              })
                  }, TIME)
            }else{
                  setTimeout(()=>{
                        adios(nombre)
                        .then(() => {
                              console.log("terminado el proceso")
                        })
                        .catch(error => {
                              console.error('ah habido un error')
                              console.error(error)
                        })
                  },TIME)
            }
      })
}

console.log("inciando el proceso...")
hola(nombre)
      .then(conversacion(nombre,repeticiones))
      .catch(error => {
            console.error('ah habido un error')
            console.error(error)
      })

Cabe mencionar que para acceder al nombre en adios
el param se debe mandar a traves de todos las promesas

hola('Adranuz')
  .then(hablar)
  .then(hablar) 
  .then(hablar)
  .then(hablar)
  .then(adios)
  .then((nombre)=> {
    console.log('Proceso terminado')
  })
  .catch (error=> {
    console.log('Ocurrio un error')
    console.error(error)
  }) 

Siempre promesas 鉂わ笍

Primera ves tocando el backends despues de un buen tiempo con el fronted, aqu铆 voy !

Fullstack MERN CO脩OO !!!

5 cursos y no entendia del todo las promesas, llega este profe y a la primera :v

Todos los cursos de 茅ste excelente profesor, necesitamos m谩s!!

function hello(name) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("hello", name);
      // resolve();
      reject("Error");
    }, 1500);
  });
}

function speaks(name) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("bla bla bla...");
      resolve(name);
    }, 1000);
  });
}

function bye(name) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("bye", name);
      resolve();
    }, 1000);
  });
}

/** Execute */
console.log("Init process...");
hello("George")
  .then(speaks)
  .then(speaks)
  .then(speaks)
  .then(speaks)
  .then(bye)
  .then(() => console.log("End process"))
  .catch((error) => console.log("Error", error));

I love Async/await, ahhh y tambien las promesas 馃槢

Manejar callbacks puede ser un infierno, para evitarlo se crearon las promesas, que son como callbacks pero cambiaron un concepto. Agregaron el estado, pueden estar resueltas, no resueltas, pendientes o fallar.

Lo que haremos es que nuestras funciones en vez de ejecutar cosas mejor devuelvan la promesa y quien las llame esten pendientes del estado y lo que pasa.

return new Promise((resolve, reject) => {});

Lo que va a tener es un callback, ya que al final siempre es una funcion asincrona. Esta funcion recibe dos parametros, resolve y reject. Nos van a permitir resolver la promesa o si detectamos un error lo que se va a detener. Ya no ejecutaremos un callback, en vez de eso mandaremos RESOLVE. Nuestra funcion de hola quedaria:

const hola = (nombre) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Hola ${nombre}`);
      resolve(nombre);
    }, 1500);
  });
};

Ahora para ejecutar nuestro metodo podriamos usar:

console.log("Iniciando el proceso");
hola("Carlos")
	.then((nombre) => {
  console.log("terminado el proceso");
});

Donde veremos que al solucionarle mandaremos por then el parametro qie mandamos desde el inicio y este se ejecutara. La diferencia es que podemos ir anidando promesas, opor ejemplo, el metodo adios vamos a retornar una promesa:

const adios = (nombre) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(`Adios, ${nombre}`);
      resolve();
    }, 1000);
  });
};

Ahora para que esta se pueda llamar usamos:

hola("Carlos")
  .then(adios)
  .then((nombre) => {
    console.log("terminado el proceso");
  });

Ahora podremos trabajar con nuestras funciones de forma mucho mas sencilla. ya que si solo queremos pasar el valor y no utilizarlo podemos usar:

console.log("Iniciando el proceso");
hola("Carlos")
  .then(hablar)
  .then(adios)
  .then((nombre) => {
    console.log("terminado el proceso");
  });

Y ya cada que queramos hablar solo tenemos que duplicar el hablar y asi podremos ver de forma mas legible todo.

Pero que pasa si tenemos un error? Pues para eso tenemos el REJECT donde por si falla podemos decirle que mande los parametros al error:

const hablar = (nombre) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log("Bla Bla bla");
      //   resolve(nombre);
      reject("Hay Un error");
    }, 1000);
  });
};

Y ahora pondremos un catch que estara para asegurarse de que nuestro programa no falle y si falla recibir el error

console.log("Iniciando el proceso");
hola("Carlos")
  .then(hablar)
  .then(adios)
  .then((nombre) => {
    console.log("terminado el proceso");
  })
  .catch((error) => {
    console.error(error);
  });

Siempre que hagamos un THEN o hagamos una promesa tenemosq ue tener un catch para evitar que se propague y este se detenga y se envie a produccion. Todo puede fallar pero siempre con tus THEN y usar CATCH PARA SOBREVIVIR

De todas las explicaciones en el camino del JS Challenge, acerca de este tema, me quedo con esta 馃槂

Promesas: Tenemos que pensar las promesas como valores que aun no conocemos. Es la promesa de que ahi va a haber un valor cuando una acci贸n asincrona suceda y se devuelva.

El then de una promesa puede recibir dos parametros: onSuccess y onError, pero tengan en cuenta para el examen que como solo se explico que se pasaba uno, entonces la respuesta sera UNO.

Promesas

Si nos encontramos con un callback hell debemos refactorizarlo y esto implica cambiar su sintaxis, en este caso con promesas resolveremos el problema.

function despertar(nombre) {
  return new Promise((resolve, reject) => {
    if(true) {
          setTimeout(() => {
      console.log(`${nombre} desperto`);
      resolve(nombre);
    }, 1000);
    } else {
      reject(new Error(`${nombre} no desperto`))
    }
  });
};

const vivio = (nombre) => {
  return new Promise((resolve, reject) => {
    if(true) {
      setTimeout(() => {
        console.log('Hicimos toda clase de cosas');
        resolve(nombre)
      }, 1000)      
    } else {
      reject( new Error(`${nombre} no hizo nada =(`))
    }
  })
};

function dormir(nombre) {
  return new Promise((resolve, reject) => {
    if(true) {
      resolve(nombre);
    } else {
      reject(new Error(`${nombre} no se ha dormido`));
    }
  })
};

despertar("Manuel")
  .then(vivio)
  .then(vivio)
  .then(dormir)
  .then(() => {
  console.log("Termino");
})
  .catch(error => {
    console.error(`Algo fallo ${error}`)
  });

Lo que hicimos en el c贸digo anterior es crear una funci贸n que retorna una promesa la cual recibe dos parametro que son resolve y reject, resolve es igual a promesa resuelta y reject la promesa fall贸.

luego hacemos el llamado de la funci贸n inicial que es despertar("Manuel") y dentro ponemos el argumento. A continuaci贸n con los .then() llamamos las otras promesas necesarias y por ultimo capturamos los posibles errores con el fin de no propagarlo.

Llevo meses aprendiendo cosas nuevas con Js,soy un novato y es la primera vez que algu茅n explica claramente este tema de las promesas y asincronismo.

You are the best 鉂わ笍

HE aqui mi codigo!

function hola(n) {
    return new Promise( (resolve, reject) => {
        setTimeout( () => {
            log('Hola '+n)
            resolve(n);
        },1000) 
    })

}
function hablar(n) {
    return new Promise( (resolve, reject) => {
        setTimeout(() => {
            log('BLA bla BLA');  
            resolve(n);  
        }, 1000);
    })
}

function adios(n) { 
    return new Promise( (resolve, reject) => {
        setTimeout(() => {
            log('Hemos terminado de ejecutar el proceso mi compa ' + n);  
            resolve(n);  
        }, 1000);

    })
}

function log(str) {
    console.log(str);
}
log('Inciando proceso');
hola('carlos')
    .then(hablar)
    .then(adios)
    .then((n) => log(n +'! Proceso terminado'))
    .catch( e => {
        log('Compa ocurrio un error!!!');
        console.log(e);
    } )```

Yo lo entend铆 haciendo un ejemplo un poco m谩s sencillo. Obviamente ya podr铆amos escalarlo a algo mucho m谩s grande, pero esto me funciono a m铆.

function thisIsAPromise(age, topAge){
	return new Promise((resolve, reject) => {
		if (age <= topAge){
			resolve('User is allowed.')
		} else {
			reject('User is denied.')
		}
	})
}
// Ejemplo permitido
thisIsAPromise(5, 15).then((mensaje) => {
	console.log(mensaje);
}).catch(function(mensaje){
	console.log(mensaje);
})
thisIsAPromise(20, 15).then((mensaje) => {
	console.log(mensaje);
}).catch(function(mensaje){
	console.log(mensaje);
})

Casi como MAD MAX, que accurate XDD

鈥淩ecuerda que estamos en Node y esto es como Mad Max, todo puede petar en cualquier momento y romperse el proceso entero, si utilizas promesas, nunca olvides colocar CATCH鈥

Es genial este profesor! Ja鈥

Aparte de los m茅todos .then y .catch existe .finally que ejecutara hasta el final lo que se le pase por par谩metro, sin importar si se resuelve o si falla la promesa.
Ejemplo:

  • Sin finally:
hola(鈥楢bner鈥)
  .then(hablar)
  .then(hablar)
  .then(adios)
  .then((nombre)=>{
    console.log(鈥楶roceso terminado鈥);
  })
  .catch(error =>{
    console.error(鈥榟a habido un error鈥);
    console.error(error);
  })

  • Con finally:
hola(鈥楢bner鈥)
  .then(hablar)
  .then(hablar)
  .then(adios)
  .catch(error =>{
    console.error(鈥榟a habido un error鈥);
    console.error(error);
  })
  .finally(()=>{
    console.log(鈥楶roceso terminado鈥);
  })
  • Resultado resuelto:
Iniciando el proceso鈥
Hola, Abner
Bla Bla Bla Bla Bla Bla 鈥
Adios, Abner
Proceso terminado
  • Resultado fallado:
Iniciando el proceso鈥
Hola, Abner
Bla Bla Bla 鈥
Ha habido un error: Hay un error
Proceso terminado

驴Existe alguna diferencia en usar function() {} a usar () => {} una arrow function?

Hola, Creo que he encontrado un error debe ser por el tipeado de Javascript, cuando realizaba el mismo c贸digo me resultaba NaN, borre la secci贸n y volv铆 a escribir ese fragmento y funciono

隆Grande Carlos! Qu茅 analog铆a tan original, jamas pens茅 que alguien comparara Node con Mad Max. 馃く

Venga, esas promesas las vi en el curso de fundamentos de javascript, vamos a practicarlas de nuevo 馃槃

La pregunta 8 esta equivocada.
En la informacon de MDN dice claramente que then reciben 2 parametros: success y error. Sim embargo sale como respuesta incorrecta.

Pregunta de examen:
驴Cu谩ntos par谩metros puede recibir el then de una promesa?

Ya habia visto una clase de Promesas durante el JS Challenge pero me quedo con esta explicaci贸n ahora comprendo mejor como poderlas utilizar

Casi un mes sin estudiar, pero volvemos con todo!!

La ventaja que tienen las promesas respecto a los callbacks cl谩sicos es que podemos saber el estado de ejecuci贸n de una promesa

Como nos dijo sasha.
Una聽Promesa聽se encuentra en uno de los siguientes estados:

function hola(nombre, micallback) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (true) {
        console.log(`hola ${nombre}`);
        resolve(nombre);
      } else {
        reject("Error al saludar");
      }
    }, 1000);
  });
}

function hablar(nombre) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (true) {
        console.log("bla bla bla bla");
        resolve(nombre);
      } else {
        reject("Error encontrado al hablar");
      }
    }, 500);
  });
}

function adios(nombre, otrocallback) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (true) {
        console.log(`Adios ${nombre}`);
        resolve();
      } else {
        reject("error al despedirse");
      }
    }, 2000);
  });
}

function conversacion(nombre, veces, callback) {
  if (veces > 0) {
    hablar(() => {
      conversacion(nombre, --veces, callback);
    });
  } else {
    adios(nombre, callback);
  }
}

//-----------------

//callback hell

console.log("iniciando el proceso..");
hola("Camilo")
  .then(hablar)
  .then(hablar)
  .then(hablar)
  .then(hablar)
  .then(adios)
  .then((nombre) => {
    console.log("terminado el proceso");
  })
  .catch((error) => {
    console.error("ha habiado un error");
    console.error(error);
  });

function hola(nombre) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            console.log("Hola, " + nombre);
            resolve(nombre);
        }, 1500);
    });
    
}

function adios(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout( function() {
            console.log("Adios",  nombre);
            resolve();
        }, 1000);
    });
    
}

function hablar(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            console.log("Bla bla bla...");
            //resolve(nombre);
            reject('Hay un error');
        }, 1000)
    });
    
}

function conversacion(nombre, veces, callback) {
    if (veces > 0) {
        hablar(function() {
            conversacion(nombre, --veces, callback);
        });
    }
    else {
        adios(nombre, callback);
    }
}

// --
console.log('Iniciando el proceso..');
        
hola('Carlos')
    .then(hablar)
    .then(adios)
    .then((nombre) => {
        console.log('Terminado el proceso');
    })
    .catch(error => {
        console.log('Ha habido un error:');
        console.log(error);
    })```

Las promesas se pueden concatenar, y en la concatenacion se puede definir un catch para atrapar cualquier ocurrido en la cadena de promesas.

function hola(nombre){
    return new Promise(function(resolve, reject){
        setTimeout(()=>{ 
            console.log(`Hola ${nombre}`);
            resolve(nombre);
    }, 1000);
    });
}

function adios(nombre){
    return new Promise(function(resolve, reject){
        setTimeout(()=>{ 
            console.log(`Adios ${nombre}`);
            resolve(nombre);
    }, 1000);
    });
}

function hablar(nombre){
    return new Promise(function(resolve, reject){
        setTimeout(()=>{ 
            console.log(`Bla bla bla`);
            reject('Fallo')
            //resolve(nombre);
    }, 1000);
    });
}

hola("JL")
.then(hablar)
.then(hablar)
.then(hablar)
.then(adios)
.then(()=>{
    console.log("Proceso terminado");
}).catch((error)=>{
    console.error("Error: ", error);
});

Promesas es una manera nueva de hacer un c贸digo s铆ncrono. Una promesa se crea de la siguiente manera:

function compararParametros (param1, param2) {
	return new Promise ((resolver, reject) => {
		if(param1 === param2) {
			console.log("Hola Soy una promesa y m铆s parametros son exactamente iguales")
			resolve(true)
		} else {
			console.log("Hola Soy una promesa y m铆s parametros son  diferentes")
			reject(false)
		}
	})
}

En vez de hacer tantos .then() puedes user un Promiseall() asi:

const saludar = (nombre) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log("Hola ".concat(nombre))
            resolve(nombre)
            reject('uupssss')
        }, 1000)
    })
}


const hablar = (veces) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log("Bla bla bla bla ...\n".repeat(veces))
            resolve(veces) // debemos pasarle el valor del parametro nombre para no perderlo entre las ejecuciones seguidas del .then()
        }, 1000)
    })
}

const adios = (nombre) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log("Adios ".concat(nombre))
            resolve(nombre)
        }, 1000)
    })
}


console.log('Iniciando proceso! \n')
Promise.all([saludar('Daniela'), hablar(3), adios('Daniela')]).then((values) => {
    console.log(values);
});

Qu茅 clase tan genial! De todos los cursos de Platzi en los que he visto as铆ncronismo, es el 煤nico con el que al final puedo decir que lo entend铆.

Creo que el que lo explique con funciones sencillas y no con WebRequest o llamadas a APIs, me facilita mucho la comprensi贸n de este tema.

Me quedo claro el tema pero en la funci贸n de adios me aparece undifined el nombre y no se que pueda ser.

function hola(nombre){

    return new Promise(function(resolve, reject){
        setTimeout(function (){
            console.log('Hola ' + nombre)
            resolve();
        },1000);
     


    });
     
    
   
    }

function hablar(nombre){
    return new Promise (function(resolve, reject){
        setTimeout(function(){
            console.log('Como estas');
            resolve();
        },1000);

    })
    

    }

    function adios(nombre){

        return new Promise(function(resolve, reject){
            setTimeout(function (){
                console.log('adios', nombre)
                resolve();
            },1000);
         
    
    
        });
         
        
       
        }

    console.log('Inicio del proceso...');

    hola('Luis')
        .then(hablar)
        .then(adios)
    
        .then((nombre)=>{


            console.log('Terminado el proceso');

        })
        .catch(error =>{
            console.log('tenemos un error');
            console.error(error);
            

        })
        

alguien me explica porque cuando en la funcion q coloco en tiempo de espera en el setimeout en 1000 me devuelve
matiasa
matias
matiasa

pero cuando dejo en la funcion q , 0 en tiempo de espera en el setimeout me devuelve
matias
matiasa

function a(nombre) {
    return new Promise((resolve, rejected) => {
        setTimeout(() => {

            resolve(nombre);
            return console.log(`Hola ${nombre}`);
        }, 1000);
    })
    
}

function q() {
    return new Promise((resolve, rejected) => {
        setTimeout(() => {

            resolve(nombre);
            console.log(`Hola ${nombre}a`);
        }, 0);
    })
}


let nombre = "matias";
  q()
    .then(nombre => a(nombre).then(nombre=>q()))
    .catch(error => console.log(error));
function hola(nombre) {
  return new Promise( function(resolve,reject){
    setTimeout(function () {
      console.log('Hola, ' + nombre);
      resolve(nombre);
    }, 1500);
  });
  
}

function hablar(nombre) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      console.log('Bla bla bla bla...');
      resolve(nombre);
    }, 1000);
  });
}

function adios(nombre) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      console.log('Adios', nombre);
      resolve();
    }, 1000);
  });
}

function conversacion(nombre, veces, callback) {
  if (veces > 0) {
    hablar(function () {
      conversacion(nombre, --veces, callback);
    })
  } else {
    adios(nombre, callback);
  }
}

/**
 * Un ejemplo solo con hola y adios
 */
//console.log('Iniciando proceso...');
//hola('Santiago')
//  .then(adios) // no hace falta pasarle el parametro ya que es el mismo
//  .then(() =>{
//    console.log('Proceso Terminado');
//  }) 
//  .catch(e =>{
//    console.error(e);
//  });

/**
 * Un ejemplo solo con hola , hablar y adios
 */
console.log('Iniciando proceso...');
hola('Santiago')
  .then(hablar)
  .then(hablar)
  .then(hablar)
  .then(adios) // No hace falta pasarle el parametro ya que es el mismo
  .then(() =>{
    console.log('Proceso Terminado');
  }) 
  .catch(e =>{
    console.error('Error: ',e);
  });

Mas intresante las promesas. el manejo de errores es super鈥

function hola(nombre, micallback) { 
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (true) {
                console.log(`hola ${nombre}`);   
                resolve(nombre); 
            } else {
                reject('Error al saludar');
            }
            
        }, 1000);
    });
}

function hablar(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (true) {
                console.log('bla bla bla bla');
                resolve(nombre);
            } else {
                reject('Error encontrado al hablar');
            }
            
        }, 500);
    });
}


function adios(nombre, otrocallback) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (true) {
                console.log(`Adios ${nombre}`)
                resolve();
            } else {
                reject('error al despedirse');
            }
            
        }, 2000);
    });
}

function conversacion(nombre, veces, callback) {
   if (veces >0) {
       hablar(() => { 
           conversacion(nombre, --veces, callback);
       })
   } else {
       adios(nombre, callback);
   }
  
}

//-----------------

//callback hell

console.log('iniciando el proceso..');
hola('Francisco')
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(hablar)
    .then(adios)
    .then((nombre) => { console.log('terminado el proceso') })
    .catch(error => { 
        console.error('ha habiado un error');
        console.error(error);
    })






Disculpen estoy probando usar los resolve() con objetos.Sin embargo, me he topado con un problema. El resolve() no ejecuta en cierta condici贸n, alguien amablemente me podr铆a decir el porque llego 2 horas buscando informaci贸n pero nada.Gracias

<code>
function soyAsincronaHola(veces,nombre){
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            //console.log('Estoy siendo asincrona')
            console.log('Hola, '+ nombre)
            resolve({veces:veces,nombre:nombre})
        },1500)
    })
}

function hablar(data){
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            console.log('Bla bla bla bla ...')
           resolve({veces:data.veces,nombre:data.nombre})  // Si por algun motivo falla 
            //reject('Hay un error')
        },1000)   
    })
}

function conversacion(data){  // data que viene {veces:veces,nombre:nombre}
    //console.log(data.veces)
    //console.log(data.nombre)
    return new Promise((resolve,reject)=>{
        if(data.veces > 0){
            hablar({veces: --data.veces,nombre:data.nombre}).then(conversacion)
        }else{
            console.log(data.veces)
            console.log('entra')
            resolve(data.nombre)  // No ejecuta cuando las veces son mayores a 0 , pero si son menores a 0 si ejecuta 
        }
    })   
}

function soyAsincronaAdios(nombre) {
    return new Promise((resolve, reject)=>{
        setTimeout(()=>{
            console.log('Adios, '+ nombre)
            resolve(nombre)
        },1000)
    })
}

function terminar(nombre){
    console.log(`${nombre} esto termina aqui`)
}

console.log('Iniciando el proceso')
soyAsincronaHola(1,'Bryan')
    //.then(hablar)
    .then(conversacion)
    .then(soyAsincronaAdios) //al final de soyasincrona ya le estoy pasando el parametro que usar脿
    .then(terminar) // al final de soyasincronaAdios ya le estoy pasando el parametro que usar脿
    .catch(error =>{ // SIEMPRE que trabajamos con promesas usar CATCH 
        console.error('Ha habido un error: ')
        console.error(error)
    })
    

Promesas.js

function hola(nombre) {
    return new Promise(function (resolve, reject) {
        setTimeout(function() {
            console.log("Hola, " + nombre);
            resolve(nombre);
        }, 1500);
    });
}
function hablar(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            console.log("bla, bla, bla, bla");
            resolve(nombre);
        }, 1000);
    });
}
function adios(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            console.log("Adios", nombre);
            resolve();
        }, 1000);
    });
}

// --
console.log('Iniciando el proceso...');
hola('Cristobal')
    .then(hablar)
    .then(adios)
    .then((nombre) => {
        console.log('Terminado el proceso');
    });



https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Usar_promesas

Una Promise (promesa en castellano) es un objeto que representa la terminaci贸n o el fracaso de una operaci贸n as铆ncrona. Dado que la mayor铆a de las personas consumen promises ya creadas, esta gu铆a explicar谩 primero c贸mo consumirlas, y luego c贸mo crearlas.

Promesas


Para evitar por completo los callbacks hell, se creo una nueva forma de trabajar con asincron铆a, esta forma son las promesas, el concepto es que las Promise tienen estados.

Pueden ser:

  • Resueltas
  • No resueltas
  • Fallar
function hola(nombre) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log(`Hola, ${nombre}`)
            resolve(nombre)
            reject('No s茅 qu茅 paso')
        }, 1500)
    })
}

Y ejecutar la promesa

hola('Carlos')
    .then(hablar)
    .then(adios)
    .then(nombre => {
        console.log(`Terminado el proceso`)
    })
    // Utilizamos el catch para que cuando haya un error nos lo comunique
    .catch(error => {
        console.error('Ha habido un error')
        // El error que dispara es lo que hayamos colocado dentro de reject()
        console.error(error)
    })

馃槂

function hablar(nombre) {
  return new Promise((resolve, reject) => {
    let random = Math.random()
    setTimeout(function() {
      console.log('Bla bla bla bla bla...')
      if (random >= .25) resolve(nombre)
      else reject('Jerjes: JAJAJAJA!!!')
    }, 100)
  })
}

Definici贸n:

Una promesa es un objeto que representa un valor que puede que est茅 disponible 芦ahora禄, en un 芦futuro禄 o que 芦nunca禄 lo est茅. Lo que significa que solo puede ejecutar una acci贸n al mismo tiempo, por lo que utilizar promesas facilita, en buena medida, el control de flujos de datos as铆ncronos en una aplicaci贸n.

// Declaracion de funciones 
//Funcion hola
function hola(nombre){
  return new Promise(function(resolve, reject){
    setTimeout(function() {
      console.log('Hola ' + nombre);
      //resolve(nombre);
      // En caso de que la funcion falle manda el reject 
      reject('Algo no salio como lo pensaba')
  }, 1000);
  });
}
//Funcion hablar 
function hablar(nombre){
  return new Promise((resolve, reject) => {
    setTimeout(function(){
      console.log('Bla.. Bla.. Bla..');
      resolve(nombre);
    },1000);
  });
}

//Funcion adios 
function adios(nombre){
  return new Promise( (resolve, reject) => {
    setTimeout(function() {
      console.log('Adios ' + nombre);
      resolve();
    }, 1000);
  });
}


//  ---- 
// Inicio de la funcion 
console.log('Iniciando el proceso');
hola('Robb')
  .then(hablar)
  .then(hablar)
  .then(adios)
  .then((nombre) => {
    console.log('Terminado el proceso');
  })
  // Manejo de errores: en caso de que el proceso interno de la funcion 
  // falle el catch se trae la informacion del reject 
  .catch(error =>{
    console.error('Log de Errores: ')
    console.error(error)
    })

este es el ejercicio

function hablar(){
  return new Promise ((resolve,reject)=>{
    setTimeout(function(){
    console.log("hablando blaa bla bla bla");
   resolve()
  },1000)
  });
  
}


function hola(nombre){
  return new Promise ((resolve,reject)=>{
  setTimeout(function(){
      console.log("hola "+nombre);
      resolve(nombre);
    },1000)
  });
}



function adios(nombre){
  return new Promise ((resolve,reject)=>{
  console.log("adios "+ nombre);
});
}


hola("david")
.then(hablar)
.then(hablar)
.then(hablar)
.then(hablar)
.then(adios)
.catch(Error=>{
  console.error("ups");
})

El .then tambi茅n puede recibir el reject (2 callbacks). En el minuto 5:36 de este video, se puede ver con la ayuda de VS code, sin embargo en el examen tuve mal esta pregunta 馃槮

Dejo un ejemplo, aunque considero que es mala pr谩ctica pero solo para saber, s铆 se puede dos callbacks en un .then

function promesa() {
    return new Promise( (resolve,reject)=> {
        let random = Math.random();
        console.log(random); 
        if ( random < 0.5 ) {
            resolve('Todo bien!!');
         } else {
            reject('Errorrrrr!!');
         }    
    });
}

promesa()
    .then(data => console.log(data), err => console.log('error', err))

Siempre que usemos promesas debemos a帽adir un catch. Si no lo usamos, un error se podr铆a propagar por todo el c贸digo. En cambio al implementarlo, el c贸digo se pausa apenas capture el error.

Esta explicaciones de asincronismo est谩n muy bien hechas 馃槃

Conclusi贸n de esta clase:
Resolve y rejects son callbacks que son llamados con .then() y .catch().

Al fin estoy entendiendo los callbacks y promesas, que emoci贸n!

Muchas gracias Carlos, aunque en cursos pasados pens茅 que entendia este tema, me doy cuenta de que tenia muchos baches, ahora veo las cosas mas claras.

no se como no hay mas cursos de este tipo en Platzi, es alto MASTER!

Para hacer uso de la funcion conversacion como promesa implemente esto.

function conversacion(name, veces) {
    return new Promise((resolve, reject) => {
        if (veces > 0) {
            hablar(name)
                .then(() => conversacion(name, veces - 1))
                .then(() => resolve())
        } else {
            despedida(name)
                .then(() => resolve())
                .then(() => console.log("Fin"))
        }
    });
}


// --
console.log("Iniciando...");
saludo('Juan')
    .then(conversacion('Juan', 3))
Qu茅 es una Promise?
Una Promise en JavaScript es un objeto que representa la eventual finalizaci贸n, o fallo de una operaci贸n as铆ncrona, y su valor resultante.


Una promise recibe una "funci贸n ejecutora" que acepta dos argumentos: resolve y reject
驴C贸mo funciona?
La 鈥渇unci贸n ejecutora鈥 de Promise es llamada antes que el constructor de Promise retorne el objeto creado. El objetivo de resolve y reject es, como el nombre indica, resolver y rechazar la promise, respectivamente. Pensa que la idea es poder utilizar Promise en tareas as铆ncronas, y cuando esta tarea se finalice se llame a resolve si todo correcto, o a reject si ha habido alg煤n error.

驴C贸mo quedar铆a el m茅todo conversar usan new Promise?

function conversacion(nombre, veces) {
  return new Promise((resolve, reject) => {
    if (veces > 0) {
      hablar(nombre)
      .then(() => {
        return conversacion(nombre, --veces)
      })
      .then(resolve)
    } else {
      resolve(nombre)
    }
  })
}

Una promesa ( Promise ) es una clase global que permite trabajar la asincron铆a, con la caracter铆stica que posee un estado ( resuelta, pendiente, rechazada ).

function hola(nombre) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {            
            console.log('Hola, '+ nombre);
            resolve(nombre);
        }, 1500);
    });
    
}

function jugar(nombre) {
    return new Promise( (resolve, reject) => {
        setTimeout(function() {
            num = get_number();
            
            if(num >= 5){
                console.log('HAS GANADO [' + num + '] PUNTOS ..!');
                resolve(nombre);
            }else{
                console.log('El m煤mero [' + num + '] es muy bajo. NO ganas puntos ' + nombre);
                reject('N煤mero muy bajo');
            }
        }, 1000);
    });
}

function adios(nombre) {
    return new Promise( (resolve, reject) => {
        setTimeout(function() {
            console.log('Gracias por participar', nombre);
            resolve(nombre);
        }, 1000);
    });
}

function get_number(){
    num = Math.floor(Math.random() * 10 );
    return num;
}


console.log('Iniciando el proceso..');
hola('Julio')
    .then(jugar)
    .then(jugar)
    .then(adios)
    .then((nomb) => {
        console.log(nomb + ', has terminado el juego');
    })
    .catch(error => {
        console.error('Ejecuci贸n finalizada');
        console.error(error);
    })

Al correr el programa puede salir algo como 鈥

[nodemon] starting `node async/promises_copy.js`
Iniciando el proceso..
Hola, Julio
HAS GANADO [9] PUNTOS ..!
El m煤mero [0] es muy bajo. NO ganas puntos Julio
Ejecuci贸n finalizada
N煤mero muy bajo

鈥 o tambi茅n 鈥

[nodemon] starting `node async/promises_copy.js`
Iniciando el proceso..
Hola, Julio
HAS GANADO [5] PUNTOS ..!
HAS GANADO [9] PUNTOS ..!
Gracias por participar Julio
Julio, has terminado el juego

La sentencia 鈥渞eturn鈥 en el .then() de las promesas son clave, gran capitulo!

Mi resumen de las promesas:
Producing code - es un c贸digo que puede llevar alg煤n tiempo
Consuming code - es un c贸digo que debe esperar el resultado
/*=========================================================================*/
Una promesa contiene tanto el Producing code y las llamadas del Consuming code

let myPromise = new Promise( (resolve, reject) => {
    // "Producing Code" (puede tomar tiempo)       
        resolve(); // cuando tiene 茅xito
        reject();  // cuando hay un error
});
    
    // "Consuming Code" (Debe esperar que se termine la promesa)
    myPromise.then(
      function(value) { /* c贸digo si tiene 茅xito */ },
      function(error) { /* c贸digo si hay error */ }
    );

El argumento .then() tiene dos callbacks, uno para 茅xito y otro para fallo. Ambos son opcionales, puedes agregar solo uno de los dos callbacks.

Ejemplo practico

let example1 = new Promise( (resolve, reject) => {

    //Cambia el valor de x para ver un error
    let x = 0;

    if (x == 0) {
        resolve('ok'); // cuando tiene 茅xito
    } else {
        reject('error'); // cuando hay un error
    }        
});
    
    // "Consuming Code" (Debe esperar que se termine la promesa)
    example1.then(
      (value) => {console.log(value)},
      (error) => {console.log(error)}
    );

El .then() de una promesa solo puede recibir 1 par谩metro

Las unicas promeas que me cumplen jajaj

excelente explicaci贸n, en el curso de as铆ncrono de javascript no lo entend铆a, muy buen profesor

Conclusi贸n y Lecci贸n de vida

Usar siempre promesas con un catch.

Carlos Hern谩ndez: 鈥淓sto es como Mad Max, todo puede petar en cualquier momento鈥.

genial esta clase

La diferencia entre los callbacks y promesas, es que las promesas se pueden anidar

Cada vez entiendo menos, va siendo el momento de volver a un curso inferior.

No se si me suceda solo a m铆 pero cuando dice s铆ncrono o as铆ncrono me suena igual, 隆tengo que practicar m谩s espa帽ol!

  • una promesa es un objeto que representa la terminaci贸n o el fracaso de una operaci贸n as铆ncrona.

-Es un objeto devuelto al cual se adjuntan funciones callback, en lugar de pasar callbacks a una funci贸n.

Formas de anidar Promesas

Por que el ultimo .then trae el valor nombre en el parametro si no lo usa? y en las funciones de hablar tambien鈥

Aprend铆 de promesas y que los fundamentos son esenciales para Todo 馃槃

Excelente explicaci贸n.

Para los que quieren saber qu茅 otros cursos imparte este profesor aqu铆 les dejo un link para que lo vean:

https://platzi.com/profes/CodingCarlos/

Por fin empiezo a entender las promesas

Ame esta clase! jaja

Este curso es buenisimo.

el codigo asincrono se puede transforma a usar promesas para que el codigo queda mas limpio o legible

las promesas pueden tener un estado, ya sea: resuelta, pendientes o pueden fallar

he comprendido un poco mas las promise!

Excelente explicaci贸n.

Evitemos que el proceso pete! frase celebre del profe!
Genio!

Por fin estoy aprendiendo bien callback, promesas, async await, exelente profesor recomendado

Reaprendiendo las promesas 馃槃

WTF, ya habia tomado varios cursos donde los pofesores explicaban muy bien estos temas pero este profesor explica de una manera tan perfecta que no me queda ninguna duda.

Wao, increibleeeeee, de acuerdo.

馃憣

si instancio dos funciones hola y cada una tiene un habla y adi贸s se mezclan los contenidos de las dos en vez de salir una y luego la otra no se por que

Ya habia visto promises en otro curso de la carrera de javascript pero aqui se hizo muuuucho mas simple, excelente profesor!

Callbacks entendidos de una mejor manera gracias a las promesas.

Promise, funciones as铆ncronas que se pueden ir anidando

muy buen repaso

OMG!!! era tan sencillo ahora entiendo mejor las promesas :3 gracias humano