隆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

Live Class

66

30 d铆as de JS con Juan DC

67

30 d铆as de JS con Nicobytes

No tienes acceso a esta clase

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

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

3D
20H
40M
13S

Playground - Promesas

35/67

Aportes 60

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

馃洝锔廍scudo 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 馃挭

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

  });
}

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 鈥測鈥 antes del 煤ltimo elemento.

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

  }); ```

馃洝锔廍scudo 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)
  })
}

/釔狅健隇堬健釔焅

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email === '' || subject === '' || body === '') {
      reject(new Error('Rellena todos los campos para enviar el correo'))
    } else {
      window.setTimeout(() => {
        resolve({
          'email': email,
          'subject': subject,
          'body': body
        })
      }, 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 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 鈥渇ilter鈥 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.

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: 鈥渆mail鈥, 鈥渟ubject鈥 y 鈥渂ody鈥, con los valores que se hayan asignado a las variables correspondientes. Por ejemplo, si email es 鈥[email protected]鈥, subject es 鈥淎sunto del correo鈥 y body es 鈥淐uerpo 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