¡Te damos la bienvenida a este reto!

1

¡Bienvenido al mundo de JavaScript!

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

Día 2

6

Operadores

7

Hoisting y coerción

8

Playground - Calcula la propina

9

Alcance de las variables

Día 3

10

Condicionales

11

Playground - Calcula años bisiestos

12

Switch

13

Playground - Obten información de mascotas según su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

Día 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

20

Playground - encuentra el palindromo más grande

Día 6

21

Reasignación y redeclaración

22

Modo estricto

Día 7

23

Debugging y manejo de errores

24

Programación funcional

Quiz: Día 7

Día 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio método map

Día 9

29

ECMAScript

30

TC39

Quiz: Día 9

Día 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

Día 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

Día 12

39

Arrays a profundidad

40

Métodos de arrays: Every, Find y findIndex

41

Playground - Válida el formulario

Día 13

42

Métodos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

Métodos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicación del valor buscado

Día 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

Métodos de arrays: sort

49

Playground - Ordena los productos

Día 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

Día 16

51

Programación orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

Día 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

Día 18

57

Abstracción en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

Día 19

61

Herencia en JavaScript

62

Playground - Jerarquía de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

Día 20 - Checkpoint

65

Playground - Agenda de vuelos

Día 21

66

Patrones de diseño

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

Día 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el código usando builder pattern

Día 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajería

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementación de Observador en Newsletter

Día 24 - Checkpoint

77

Playground - Crea un task manager con patrones de diseño

Día 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementación de un array

80

Hash tables en JavaScript

81

Playground - Implementación de una HashTable para Contactos

Día 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

Día 27

86

Singly Linked List en JavaScript

87

Playground - Agrega métodos a la singly linked list

88

Playground - Implementación de una singly linked list

Día 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

Día 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

Día 30

93

¡Lo lograste!

Live Class

94

30 días de JS con Juan DC

95

30 días de JS con Nicobytes

96

30 días de JS con GNDX

97

30 días de JS con LeoCode

98

30 días de JS con Teffcode

99

Sesión: Cierre de los 30 días de JavaScript

No tienes acceso a esta clase

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

Playground - Promesas

35/99

Aportes 85

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

🛡️Escudo anti-spoilers🛡️

/
Las promesas son uno de esos temas que te recomienda ver más de una vez porque te van a volar la cabeza más a futuro. Te dejo el curso de asincronismo en JavaScript para que lo puedas entender mejor y te prometo que estos ejercicios se volverán más sencillos… o no 😉
/
Después del gif tendrás la solución explicada a este ejercicio 👇

Explicación 📖

Ahora sí, aquí tienes la explicación

export function sendEmail(email, subject, body) {
  // De entrada empezamos retornando una promesa
  // La cual nos provee de resolve y reject dependiendo si hay éxito en esta
  return new Promise((resolve, reject) => {
    // Primero validamos que todos los aspectos del email estén disponibles
    if (email && subject && body) {
      // De ser así, creamos un timeout para "enviar" el email
      // Recuerden hacer uso de window para que las pruebas pasen
      window.setTimeout(() => {
        // Dentro del timeout definimos un objeto con
        // todos los datos recibidos
        const emailInfo = {
          email,
          subject,
          body,
        };

        // Y lo pasamos a la resolución exitosa de la promesa
        // Para que esto sea "enviado" después de 2 segundos
        resolve(emailInfo);
      }, 2000);
    } else {
      // En caso de faltar algún dato, lanzamos un error indicándolo
      reject(new Error("Hacen falta datos para poder enviar el correo"));
    }
  });
}

Creo que al menos esta promesa es fácil de entender sin la explicación, de igual manera, te invito a que compartas tu solución y nos dejes cualquier duda que tengas respecto a esta solución o problema 💪

Aquí mi solución.
En el mensaje de error también se muestra qué campos faltan.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  const emailBlock = { email, subject, body };

  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => resolve(emailBlock), 2000);
    }
    else {
      const missing = Object.keys(emailBlock).filter(item => emailBlock[item] == false);
      if (missing.length == 1) {
        reject(new Error(`Falta el campo ${missing[0]} para enviar el mensaje`));
      }
      else{
        reject(new Error(`Faltan los campos ${new Intl.ListFormat('es').format(missing)} para enviar el mensaje`));
      }
    }
  });
}

De este video aprendí que Intl.ListFormat().format() devuelve una cadena con los elementos del arreglo según el lenguaje. Para el español agrega (por defecto) la conjunción “y” antes del último elemento.

estuvo bueno el playground!
*
*
*
*
*
*
*
*
*

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Faltan campos por rellenar"))
    } else {
      window.setTimeout(() => {
        const result = { email, subject, body };
        resolve(result);
      }, 2000);
    }
  });
 }

Mi solucion con algunos** cositas extras**:

Operador ternario

filter(Boolean)

“[email, subject, body].filter(Boolean).length == 3” es una comprobación que verifica si se han rellenado los campos necesarios. La función “filter” elimina cualquier valor falso de la lista de campos (como si alguno de los campos fuera null, undefined, o una cadena vacía) y si hay tres elementos, significa que se han rellenado los campos necesarios.

Tambien use el operador ternario para hacer el codigo en menos lineas.

En cada reto aprendo un montón.

<
import { doTask1, doTask2, doTask3 } from './tasks';
export function runCode() {
    return new Promise((resolve, reject) => {
        if (!email || !subject || !body) {
          reject(new Error("Hacen falta campos para enviar el email"));
        } else if (!/\S+@\S+\.\S+/.test(email)) {
          reject(new Error("El correo electrónico proporcionado no es válido"));
        }
        setTimeout(() => {
          resolve({ email, subject, body });
        }, 2000);
      });     
 }
> 

Resolviendo promesas… 😃

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  const mail = {
    email,
    subject,
    body
  }

  return new Promise((resolve, reject) => {
    for (let prop in mail) {

      if (mail[prop].trim() == "") {
        window.setTimeout(() => {
          reject(new Error("Error: Hacen falta campos para enviar el email"))
        }, 2000);
      }
    }
    window.setTimeout(() => {
      resolve(mail);
    }, 2000);

  });
}
Mi solución ```js export function sendEmail(email, subject, body) { return new Promise((resolve, reject) => { if (!email || !subject || !body) reject(new Error("Error: Hacen falta campos para enviar el email")); window.setTimeout(() => { resolve({ email, subject, body }); }, 2000); }); } ```

Este es un escudo anti spoiler
.
.
.
.
.
.
.
.
.
.
.
.
.

Toma tu tiempo en crear buenas validaciones, ahí esta la clave en este código.

Mi aporte:

Prometeme que no te rendirás

Pero si no cumples tu promesa, te dejo mi solución

function sendEmail(email, subject, body) {
    return new Promise((resolve, reject) => {
        if (email !== "" && subject !== "" && body !== "") {
            window.setTimeout(() => {
                resolve({
                    email: email,
                    subject: subject,
                    body: body
                })
            }, 2000);
        }
        else {
            if (email === "" || subject === "" || body === "") {
                reject(new Error("Error: Hacen falta campos para enviar el email"));
            }
        }
    })
}

Only running in console:

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    const arrayResponse = {email, subject, body};
    if (!email || !subject || !body) {
      setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"));
      }, 2000);
    } else {
      setTimeout(() => {
        resolve(arrayResponse);
      }, 2000);
    }
  });
}

Input after 2 seconds:

//Promise Resolved
sendEmail("[email protected]", "Nuevo reto", "Únete a los 30 días de JS")
  .then((result) => console.log(result))
  .catch((error) => console.log(error));
//Promise Rejected
sendEmail("[email protected]", "", "Únete a los 30 días de JS")
  .then((result) => console.log(result))
  .catch((error) => console.log(error));

Output after 2 seconds:

{
  email: '[email protected]',
  subject: 'Nuevo reto',
  body: 'Únete a los 30 días de JS'
}
Error: Hacen falta campos para enviar el email


Aporte de mi solucion!
.
.
.
.
.
.
.
.
.
.
.

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Promesas

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email != "" && subject != "" && body != "") {
      setTimeout(() => {
        resolve({
          email,
          subject,
          body,
        });
      }, 2000);
    } else {
      setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"));
      }, 2000);
    }
  });
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email == "" || subject == "" || body == "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
    }
    else {
      window.setTimeout(() => resolve({
        email: email,
        subject: subject,
        body: body,
      }), 2000)
    }
  }

  )
}

mi solución:
🪄
🪄
🪄
🪄
🪄
🪄
🪄

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (email && subject && body) {
        resolve({
          email,
          subject,
          body,
        })
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }
    },2000)
  })
}

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => { 
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({email, subject, body})
      }, 2000);
    } else {
      reject(new Error("Datos incompletos para enviar correo"));
      return;
    }
  });
}

Mi solución pequeñita 💚

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
      return;
    }

    window.setTimeout(() => {
      resolve({email, subject, body})
    }, 2000)
  })
}
export function sendEmail(email, subject, body) {
  const message = "Hacen falta campos para enviar el email";
  const MILLISECONDS = 2000;
  const falsyValues = [null, ""];

  let mail = { email, subject, body }
  
  const rejectCondition = falsyValues.includes(email) || 
				       					  falsyValues.includes(subject) || 
													falsyValues.includes(body);

  return new Promise ( 
(resolve, reject) => rejectCondition ? 
						 reject(new Error(message)) :
						 window.setTimeout(() => resolve(mail), MILLISECONDS)
  )

}


.
.
.
.
.
.

export function sendEmail(email, subject, body) {
    const promise = new Promise((resolve, reject) => {
      if (email && subject && body) {
        window.setTimeout(() => {
          const fullEmail = { email, subject, body };
          resolve(fullEmail);
        }, 2000)
      } else {
        window.setTimeout(() => {
          reject(new Error('Error: Hacen falta campos para enviar el email'));
        }, 2000)
      }
    });
    return promise;
}

Hola, aquí dejo mi solución 😃
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈

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

    if (email == "" || subject == "" || body == "") {
      const message = "Faltan campos para enviar el correo";
      reject(new Error(message));
    } else { 
      window.setTimeout(() => { 

        let correo = {
          email: email,
          subject: subject,
          body: body
        }

        resolve(correo);
      }, 2000);
    }

  }

  );
}
export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error('Fatan datos para enviar el correo'));
    }
  });
}

Mi solución

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    const isNotAEmail = email == '' || subject == '' || body == ''
    if (isNotAEmail) {
      reject(new Error('Hacen falta campos para enviar el mensaje'))
    } else {
      setTimeout(() => {
        const message = {
          email: email,
          subject: subject,
          body: body
        }
        resolve(message)
      }, 2000)
    }
  })
}
export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email: email, subject: subject, body: body });
      }, 2000)
    } else {
      reject(new Error("There are missing fields"))
    }
  })
}

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailData = {
          email,
          subject,
          body,
        };
        resolve(emailData);
      }, 2000);
    } else {
      reject(new Error("Hace falta datos requeridos para enviar el correo"));
    }
  });
}

👾 Mi solución

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "")
      reject(new Error("Error: Hacen falta campos para enviar el email"));

    window.setTimeout(() => {
      resolve({
        email,
        subject,
        body,
      });
    }, 2000);
  });
}

Mi aporte (Spoiler)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function sendEmail(email, subject, body) {
// Tu código aquí 👈
return new Promise((resolve, reject) => {
if (email != “” && subject != “” && body != “”) {
const resp = {email: email, subject: subject, body: body};
window.setTimeout(() => {
resolve(resp)
}, 2000);
}
else {
reject(new Error(“Error: Hacen falta campos para enviar el email”));
}
})
}

Hola comparto mi solución, dejo estos robots antispoiler.

🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === undefined || email.length === 0) {
        reject(new Error("Error email is missing"));
      }

      if (subject === undefined || subject.length === 0) {
        reject(new Error("Error subject is missing"));
      }

      if (body === undefined || body.length === 0) {
        reject(new Error("Error body is missing"));
      }

      resolve({ email, subject, body });
    }, 2000);
  });
}
export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        
        const data = { email, subject, body }
        resolve(data)
      }, 2000);
    }
  })
}

¡Hola 😃!
Mi solución,
Se detalla hasta abajo.⬇










export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email.trim().length != 0 && subject.trim().length != 0 && body.trim().length != 0) {
      window.setTimeout(() =>
      {
        resolve(
          {
          email,subject,body,
          }
        );
      }, 2000);
    } else
    {
     reject(new Error("Falta datos para poder enviar el correo"));
    }
  });
}

Lo hice casi igual, solo que la validacion la hice opuesta, primero valide si hay errores y luego si esta todo bien es que avanza

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error('Hacen falta campos para enviar el email'))
    } else {
      window.setTimeout(() => {
        const result = {
          email: email,
          subject: subject,
          body: body
        }
        resolve(result)
          .then(res => console.log(res))
          .catch(error => console.log(error))
      },2000)
    }
  })
}

Mi solucion

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!email || !subject || !body) {
        reject(new Error("Hacen falta campos para enviar el email"));
      } else {
        resolve({
          email,
          subject,
          body
        })
      }
      
    }, 2000)
  })
}

Mi solución

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === "" | subject === "" | body === "") {
        reject(new Error("Error: Hacen falta 		 
        campos para enviar el email"));
      } else {
        resolve({ email: email, subject: subject, 
        body: body });
      }
    }, 2000);
  });
}

mi solución es:

// Tu código aquí 👈
    const result = {
        email:email,
        subject:subject,
        body:body,
    }
    console.log(email.length + subject.length + body.length)
    return new Promise((resolve, reject) => {
        if (email=="" ||  subject=="" ||  body=="" ){
            reject(new Error("Error: Hacen falta campos para enviar el email"));
        }else{
            window.setTimeout(() => {
                resolve(result);
            }, 2000);
        }
    });

Hola mi gente, llegue a este resultado.

    email: `${email}`,
    subject: `${subject}`,
    body: `${body}`
  };
  
  return new Promise((resolve, reject) => {

    for (const key in result) {
      if (Object.hasOwnProperty.call(result, key)) {
        if (result[key] == "") {
          reject(new Error("Erro faltaron Datos"));
        }

      }
     
    }
    window.setTimeout(() => {
      resolve((result));
    },2000);

  }); ```

🛡️Escudo anti-spoilers🛡️


export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body){
        reject(new Error('Error, faltan campos para enviar el correo'))
    }else{
        window.setTimeout(() => resolve({email,subject,body}), 2000)
    }
  })
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        const result = {
          email,
          subject,
          body,
        }
        resolve(result);
      }, 2000);
    }
  });
}

Comparto mi solución al reto:
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === '' || subject === '' || body === '') {
        reject(new Error('Error: Hacen falta campos para enviar el email'))
      }
      else {
        resolve({
          email: email,
          subject: subject,
          body: body,
        })
      }
    }, 2000);
  })
}

export const sendEmail = (email, subject, body) => {
  return new Promise((result, reject) => {
    window.setTimeout(() => {
      email = email == undefined || email == null ? '' : email.trim();
      subject = subject == undefined || subject == null ? '' : subject.trim();
      body = body == undefined || body == null ? '' : body.trim();

      if (email == '' || subject == '' || body == '') {
        reject(new Error('Error: Hacen falta campos para enviar el email'))
      } else {
        result({ email, subject, body });
      }
    }, 2000);
  })
}

Aporto mi solución…
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.


export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      const error = new Error("Hacen falta campos para enviar el email");
      reject(error);
    } else {
      window.setTimeout(() => {
        const emailData = { email, subject, body };
        resolve(emailData);
      }, 2000);
    }
  });
}

Hola. Comparto mi solución comentada
.
.
.
.
.
.
.
.
.
.
.

function sendEmail(email, subject, body) {
    // creación y retorno de la promesa
    return new Promise((resolve, reject) => {
        // validación de exitencia de los elementos
        if (!email || !subject || !body)
            // creación del error y ejecución de reject
            reject(new Error("Hacen falta campos"))
        // declaración del temporizador y ejecución del resolve
        window.setTimeout(() => {
            resolve({ email, subject, body })
        },2000)
    })
}

dejo mi solución por aquí.

.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {

  const promise = new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
    } else {
      window.setTimeout(() => {
        resolve({ email: email, subject: subject, body: body });
      }, 2000);
    }
  });
  return promise
}

Solución

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
  	
    window.setTimeout(() => {
    	
      if (email == "" || subject == "" || body == "") {
    		reject(new Error("Hacen falta campos para enviar el email"))
    	}
      // Resolving

    	resolve({email, subject, body})
    },2000)
  })
}

Buenas, dejo mi aporte por aquí…
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!(email && subject && body)) reject(new Error("Error: Hacen falta campos para enviar el email"));
    window.setTimeout(() => {
      resolve({ email: email, subject: subject, body: body });
    }, 2000);
  });
}
function sendEmail(email, subject, body) {

  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
      return;
    }

    window.setTimeout(() => {
      const mail = { email, subject, body };
      resolve(mail);
    }, 2000);
  });
}

Yo llegué a la siguiente solución:

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => resolve({ email, subject, body }), 2000);
    }
  })
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
    reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({
          "email": email,
          "subject": subject,
          "body": body
        })
      }, 2000)
    }
  })
}
export function sendEmail(email, subject, body) {
  
     return new Promise((resolve, reject) => {
      if (email === "" || subject === "" || body === "") {
        reject(new Error("Hacen falta campos para enviar el email"));
      } else {
        window.setTimeout(() => {
          resolve({
            body,
            email,
            subject
          });
        }, 2000);

      }
    });


}

Aquí va mi solución que la verdad no es nada diferente a la presentada por Leo, pero lo bueno que me está sirviendo esto para ver, codear y aprender mejor JavaScript con estos retos!!

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailInfo = {
          email,
          subject,
          body,
        };
        resolve(emailInfo);
      }, 2000);
    } else {
      reject(new Error("Faltan datos para poder enviar el correo"));
    }
  });
}

Listo, otro mas superado

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error('Hacen falta campos para enviar el email'));
    }
  })
}
function sendEmail(email, subject, body) {

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

      if (email !== "" && subject !== "" && body != "") 
      {
        setTimeout(() => {
          resolve({ email, subject, body });
        }, 2000)
      } else {
        reject('errorrrr')
      }
    });

}

sendEmail(
    "[email protected]",
    "Nuevo reto",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))

  sendEmail(
    "[email protected]",
    "",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))
  .catch(error => console.log(error))

the truth sol:

export function sendEmail(email, subject, body) {
  const message = "Hacen falta campos para enviar";
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email != "" && subject != "" && body != "") {
        resolve({
          email,
          subject,
          body
        })
      } else {
        reject(new Error(message));
      }
    }, 2000)
  })
}
function sendEmail(email, subject, body) {
    // Tu código aquí 👈
    return new Promise((resolve, reject) => {
        if (!email || !subject || !body) {
            reject(new Error("Error: Hacen falta campos para enviar el email-"));
        } else {
            setTimeout(() => {
               // console.log({email,subject,body});
             resolve({email,subject,body})
            }, 2000);
        }
    })
}
sendEmail(
    "[email protected]",
    "",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))
  .catch(error => console.log(error))

Esta es mi resolución al reto:
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email = "", subject = "", body = "") {
  let missingEmail = email === ""
  let missingSubject = subject === ""
  let missingBody = body === ""

  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!missingEmail && !missingSubject && !missingBody) {
        resolve({ email, subject, body });
      }
      else {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Aquí está mi solución…
.
.
.
.
.
.
.
.
.
.
.
.
.

Mi humilde solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    email.length === 0 || subject.length === 0 || body.length === 0 ?
      reject(new Error("Error: Hacen falta campos para enviar el email"))
      : window.setTimeout(() => {
        let correo = { email: email, subject: subject, body: body };
        resolve(correo);
      }, 2000);
  });
}

Mi aporte:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      let res = {
        email: email,
        subject,
        body
      }
      window.setTimeout(() => {
        resolve(res);
      }, 2000)

    } else {
      window.setTimeout(() => {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }, 2000)
}
  })
}

Mi aporte, comparando con el de otros/as compas, creo que yo inicié el if al contrario pero ajá, el orden de los factores nos dio el mismo resultado :B

.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        const correo = {
          "email": email,
          "subject": subject,
          "body": body,
        };
        resolve(correo);
      }, 2000);
    }
    })
}

mi unico y especial code

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    let toSend = {}
    const args = [...arguments]
    const isAllOk = args.map(arg => Boolean(arg != '')).some(item => item === false)

    if (isAllOk != true) {
      toSend = { email: email, subject: subject, body: body }
      window.setTimeout(() => resolve(toSend), 2000)

    } else {
      window.setTimeout(() => reject(new Error('Hacen falta campos para enviar el email')), 2000)
    }
  })
}

.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise(
    (resolve, reject) => {
      if (email && subject && body) {
        window.setTimeout(() => {
          resolve(
            {
              email: email,
              subject: subject,
              body: body
            }
          );
        }, 2000);

      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      }

    }
  )
}

Mi código del ejercicio.
.
.
.
.
.

.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailParameter = {
          "email": email,
          "subject": subject,
          "body": body
        }
        resolve(emailParameter)
      }, 2000);
    }
    else
      reject(new Error("Error: Hacen falta campos para enviar el email"))
  });
}
 
export function sendEmail(email, subject, body) {
  const promise = new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email && subject && body)
        resolve({ email: email, subject: subject, body: body });
      else
        reject(new Error("faltan campos para enviar el correo"));
    }, 2000);
    
  });
  return promise;
}

Comparto mi solucion

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({
          email,
          subject,
          body
        });
      }, 2000);
    }
  });
}
export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { 
      if (email && subject && body) {
        const emailInfo = {email, subject, body};
        resolve(emailInfo);
      }
      else {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Comparto mi solución:
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"))
    }
    else {
      window.setTimeout(() => {
        resolve({email, subject, body})
      }, 2000)
    }
  })
}

Comparto mi solución. Lo que lo hace diferente respecto a la de LeoCode. Es qué especifíque el campo que hace falta mandando un error personalizado por cada argumentos que recibimos.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email !== "") {
      if (subject !== "") {
        if (body !== "") {
          window.setTimeout(() => {
            resolve({ email: email, subject: subject, body: body})
          }, 2000)
        } else {
          reject(new Error("Hace falta el cuerpo del correo"))
        }
      } else {
        reject(new Error("Hace falta el asunto del correo"))
      }
    } else {
      reject(new Error("Hace falta el correo"))
    }
  })
    
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise(function (resolve, reject) {
    if (email && subject && body) {
      window.setTimeout(() => {

        const emailInfo = {
          email:email, subject:subject, body:body
        };

        resolve(emailInfo);
      },2000);
    }
    else { 
      window.setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"))
      }, 2000);
    }
  });
}

Mi solucion:

Solución… 😄
.
Algo interesante, es que se puede devolver el objeto de la siguiente manera:
.

{email, subject, body} 

.
En lugar de:
.

{
  email: email,
  subject: subject,
  body: body
}

.
En JavaScript, si la variable y la propiedad de un objeto tienen el mismo nombre, puede utilizar la sintaxis de asignación de objetos abreviada para asignar el valor a la propiedad del objeto.
.
El resultado sería un objeto con tres propiedades: “email”, “subject” y “body”, con los valores que se hayan asignado a las variables correspondientes. Por ejemplo, si email es “[email protected]”, subject es “Asunto del correo” y body es “Cuerpo del correo”, entonces el objeto se vería así:
.

{
  email: "[email protected]",
  subject: "Asunto del correo",
  body: "Cuerpo del correo"
}

.
Código:
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => { 
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else { 
      window.setTimeout(() => { 
        resolve({email, subject, body});
      }, 2000);
    }
  });
}

.

Buenas, comparto mi solución
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({
          email,
          subject,
          body
        })
      }, 2000);
    }
    else {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    }

  })
}

Les presento mi solución, para hacer las validaciones de los parámetros vacíos y el codigo sea reutilizable por si en un futuro a la función se envían mas parámetros que conformaran el objeto que los englobara usé Object.values y el metodo some().
.
.
.

function sendEmail(email, subject, body) {
  let emailObj = { email, subject, body }
  return new Promise((resolve, reject) => {
    if (Object.values(emailObj).some(ele => ele == "")) {
      reject(new Error("Hacen falta campos para enviar el email"))
    } else {
      window.setTimeout(() => {
        resolve(emailObj)
      },2000)
    }
  })
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Comparto mi solución:

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  let respuesta = {
    email,
    subject,
    body
  }

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

    if (!respuesta.email || !respuesta.subject || !respuesta.body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));

    } else {

      setTimeout(() => {

        resolve(respuesta)
      }, 2000)
    }


  })
};

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
solo dire que me falta practicarlo mucho mas para dominarlo, lo bueno es que tienen retos de asincronismo y eso me motiva

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === "" || subject === "" || body === "") {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
      else {
        resolve({ email, subject, body });
      }
    }, 2000);
  });
  
}

Aquí mi solución mis panas frescos, es chiquita pero poderosa:

.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise(
    (resolve, reject) => {
      window.setTimeout(() => {
        (email && subject && body) ? resolve({ email, subject, body }) :
          reject(new Error('Hacen falta campos para enviar el email'))
      }, 2000)
    }
  )
}

Solución

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Faltan campos para enviar el correo"));
    } else {
      window.setTimeout(function () {
        resolve({ email, subject, body });
      }, 2000);
    }    
  })
}

MI solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email&&subject&&body !== "") {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error("Hacen falta campos para enviar el email"));
    }
  });
}

Aun no había llegado al curso de promesas, y la verdad tenía algo de temor al respecto; sin embargo, creo que como todo, es simplemente de práctica y dedicación:

Mi solución.
Al principio solo verifico que los datos no estén vacíos, sino mandar el error en el reject.
Sino uso el setTimeout para devolver los datos con resolve en una clase y que se retornen pasados dos segundos.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email == "" || subject == "" || body == ""){
      reject(new Error("Hacen falta campos para enviar el email"));
    }
    window.setTimeout(() => {
      resolve({email, subject,body});
    }, 2000)
  })
}

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    }
  });
}

Adjunto mi solución:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email.trim() && subject.trim() && body.trim()) {
        resolve({
          email,
          subject,
          body
        })
      } else {
        reject(new Error('Hacen falta campos para enviar el email'))
      }
    }, 2000)
  })
}

Mi solucion:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      let params = [email, subject, body];
      if (params.some(el => el == "" || el == undefined)) {
        return reject(new Error("Hacen falta campos para enviar el email"));
      }

      return resolve({ email, subject, body });
    }, 2000);
  })
}

Aporte
.
.
.
.
.
.
.
.
.
.

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email !== '' && subject !== '' && body !== '') {
        resolve({ email: email, subject: subject, body: body });
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Este tema se me complica un poco, pero ahí vamos mejorando
.
.
.
.
.
.
.
.
.
.

    export function sendEmail(email, subject, body) {
      return new Promise((resolve, reject) => { 
        if (!email || !subject || !body) {
          reject(new Error("faltan campos para enviar el correo"))
        }
        else { 
          window.setTimeout(() => { 
            resolve({
              "email": email,
              "subject": subject,
              "body": body
            })       
          }, 2000);
        }
      })
    }

Aporto mi solución
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    //Generamos un timeout que se va a ejecutar en 2000ms (2s)
    window.setTimeout(() => {
      //Si el email o asunto o cuerpo está vacío lo rechaza
      if (email == "" || subject == "" || body == "") {
        reject(new Error("Faltan campos para enviar el correo"))
      }
      //Si todos los campos tienen algo, envía el correo
      else {
        resolve({
          'email': email,
          'subject': subject,
          'body': body
        })
      }
    }, 2000)
  })
}

export function sendEmail(email, subject, body) {

  return new Promise((resolved, rejected) => {

    window.setTimeout(() => {
      if (arguments.length === 3 && email != "" && subject != "" && body != "") {

        resolved({
          email: email,
          subject: subject,
          body: body,
        })

      }
      else {
        rejected(new Error("Error: Hacen falta campos para enviar el email"))
      }
    }, 2000)
  })
}

.
. ------------------------------------
. ESCUDO ANTI SPOILER
. 😃
. -------------------------------------
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.

export function sendEmail(email, subject, body) {
  const TWO_SECONDS = 2000
  return new Promise((resolve, reject) =>
    window.setTimeout(() => {
      if (email && subject && body) {
        resolve({ email, subject, body })
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }
    }, TWO_SECONDS)
  )
}

Spoilers:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!email || !subject || !body) {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      } else {
        resolve({
          email: email,
          subject: subject,
          body: body
        })
      }
    }, 2000)
  })
}
undefined