¡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 & Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

Día 22

69

Builder & Protype pattern en JavaScript

70

Playground - Mejora el código usando builder pattern

71

Adapter & Decorator pattern en JavaScript

72

Playground - Personaliza productos de una tienda

Día 23

73

Facade & proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajería

75

Chain of responsability & Observer pattern en JavaScript

76

Playground - Implementación de Observador en Newsletter

Día 24

Live Class

77

30 días de JS con Juan DC

78

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:

1D
3H
15M
41S

Playground - Válida el formulario

41/78

Aportes 56

Preguntas 1

Ordenar por:

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

o inicia sesión.

🛡️Escudo anti-spoilers🛡️

Mi solucion es la siguiente:

export function validateForm(formData, registeredUsers) {
  //Datos requeridos
  const requiredData = ["name", "lastname", "email", "password"]
  //Encontrar que datos faltan
  const missingData = requiredData.filter(x => !Object.keys(formData).includes(x))

  //Mensaje de error si faltan datos
  if (!!missingData.length)
    throw new Error(`Faltan los siguientes campos: ${missingData.join(", ")}`);

  //Extraer los valores necesarios de formData
  const { name, lastname, email } = formData

  //Comprobar si ya esta registrado ese email
  if (registeredUsers.some(x => x.email == email))
    throw new Error(`Email ya existe: ${email}`);

  //Agregar el registro
  registeredUsers.push({ name, lastname, email })

  //Retorno
  return (`Tu registro fue exitoso ${name} ${lastname}`)

}

Comparto mi solución por qué utilice un método que no conocía antes de este ejercicio
.
Object.hasOwnProperty(prop)
.
Me parece que saber que existe y tenerlo a la mano es lo que quiere ECMAScript. Usemos todas las funciones y herramientas que el propio lenguaje ya nos entrega para trabajar.
.
.
.
.

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

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const required = ['name', 'lastname', 'email', 'password']
  for (let i = 0; i < required.length; i++){
    if (!formData.hasOwnProperty(required[i])) {
      throw new Error(`Falta el siguiente campo: ${required[i]}`)
    }
  }
  if (registeredUsers.find((user) => user.email === formData.email)) {
    throw new Error("El email esta duplicado")
  }
  registeredUsers.push({
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  })
  return `Tu registro fue éxito ${formData.name} ${formData.lastname}`
}


Comparto mi solución usando funciones para separar las tareas de la función principal.

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  validateFormFields(formData);
  validateEmailExists(formData.email, registeredUsers);
  return registerUser(formData, registeredUsers);
}

En validateFormFields se van descartando los campos que se encuentren en formData de un arreglo con los campos que debe tener (missingFields). Antes de descartar también se valida que los campos tengan contenido.
Los campos que queden son los que le faltan a formData y se lanzan con el error.

function validateFormFields(formData) {
  const missingFields = ['name', 'lastname', 'email', 'password'];

  for (const key in formData) {
    if (formData[key]) {
      const index = missingFields.findIndex(field => field == key);
      missingFields.splice(index, 1);
    }
  }

  if (missingFields.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${missingFields.join(', ')}`);
  }
}

En validateEmailExists se busca el email de formData en el arreglo registeredUsers. Si lo encuentra se muestra con el error.

function validateEmailExists(email, registeredUsers) {
  const user = registeredUsers.find(user => user.email == email);
  if (user) throw new Error(`Email duplicado: ${email}`);
}

Por último, registerUser usa la desestructuracion de objetos para extraer el nuevo usuario sin la contraseña y agregarlo a registeredUsers.

function registerUser(formData, registeredUsers) {
  const { password, ...newUser } = formData;
  registeredUsers.push(newUser)
  return `Tu registro fue exitoso ${newUser.name} ${newUser.lastname}`;
}```

Adjunto mi 🦆
.
.
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  const requiredFields = ['name', 'lastname', 'email', 'password'];
  const formFields = Object.keys(formData);
  let missingFields = requiredFields.filter((x) => !formFields.includes(x));
  if (missingFields.length) {
    throw new Error(`Faltan los siguientes campos: ${missingFields}`);
  }

  const { name, lastname, email } = formData;

  const duplicatedEmail = registeredUsers.some((user) => user.email === email);
  if (duplicatedEmail) {
    throw new Error('Error email duplicado');
  }

  registeredUsers.push({ name, lastname, email });
  return `Tu registro fue exitoso ${name} ${lastname}`;
}

Hola comunidad,
Aqui va mi solucion luego de poder realizar el reto en el live.

.
.
.
.
.
.

  const requiredFields = ['name', 'lastname', 'email', 'password'];
  const formFields = [];
  const formDataEntries = Object.entries(formData);
  formDataEntries.forEach(([key, value]) => {
    if (value) {
      formFields.push(key);
    }
  });

  console.log('formFields', formFields);

  let missingFields = requiredFields.filter((x) => !formFields.includes(x));
  if (missingFields.length) {
    throw new Error(`Faltan los siguientes campos: ${missingFields}`);
  }

  const { name, lastname, email } = formData;

  const duplicatedEmail = registeredUsers.some((user) => user.email === email);
  if (duplicatedEmail) {
    throw new Error('Error email duplicado');
  }

  registeredUsers.push({ name, lastname, email });
  return `Tu registro fue exitoso ${name} ${lastname}`;

💢 💢 💢 ANTISPOILER 💢 💢 💢

.
.
.
.
.
.
.
.
.
Mi solución:

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  console.table(registeredUsers);
  let emptyProperties = "";
  if (formData.name == "") {
    emptyProperties += "name, ";
  }
  if (formData.lastname == "") {
    emptyProperties += "lastname, ";
  }
  if (formData.email == "") {
    emptyProperties += "email, ";
  }
  if (formData.password == ""){ 
    emptyProperties += "password, ";
  }
  if (emptyProperties == "") {
    const user = registeredUsers.find(user => user.email === formData.email);
    if (user === undefined) {
      delete formData.password;
      registeredUsers.push(formData);
      return `Tu registro fue existoso ${formData.name} ${formData.lastname}`;
    }
    else {
      throw new Error(`El email ${user.email} ya fue registrado`);
    }
  }
  else {
    return `Faltan los siguientes campos requeridos: ${emptyProperties.substring(0, emptyProperties.length - 2)}`;
  }
}

me gusto este reto 😁

export function validateForm(formData, registeredUsers) {
  const isAllFilled = Object.keys(formData).map(item => formData[item] != '' ? true : false)
  const voidFields = Object.keys(formData).filter(item => !formData[item])
  const sameEmail = registeredUsers.map(item => item.email).some(item => item === formData.email)

  if (isAllFilled.every(item => item === true)) {
    if (sameEmail) {
      throw new Error('El email suministrado ya esta en uso')
    }
    delete formData.password
    registeredUsers.push(formData)
    return `Registro exitoso de ${formData.name} ${formData.lastname}`
  }
  else {
   throw new Error(`Faltan los siguientes campos: ${voidFields}`)
  }
}

Mi solución
.
.
.
.
.
.
.
.
.
.

<export function validateForm(formData, registeredUsers) {
  //validamos todas las propiedades de formData
  let propiedades = ["name", "lastname", "email", "password"];
  for (const propiedad in formData) {
    if (formData[propiedad]) {
      const index = propiedades.findIndex(prop => prop === propiedad);
      if (index >= 0) {
        propiedades.splice(index, 1)
      }
    }
  }

  if (propiedades.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${propiedades.join(", ")}`);
  }

  //validamos si existe el email
  let exists = registeredUsers.find(user => user.email == formData.email);
  if (exists) {
    throw new Error(`Email duplicado: ${formData.email}`);
  }

  //registramos el nuevo usuario
  const { name, lastname, email } = formData
  registeredUsers.push({ name, lastname, email })

  return (`Tu registro fue exitoso ${name} ${lastname}`)

}> 
export function validateForm(formData, registeredUsers) {

  let fieldChecker = []
  let seachRegistered = registeredUsers.find(e => e.email === formData.email)

  formData.name ? '' : fieldChecker.push('name')
  formData.lastname ? '' : fieldChecker.push('last name')
  formData.email ? '' : fieldChecker.push('email')

  if (fieldChecker.length) {

    let missingFields = fieldChecker.join(', ')

    throw new Error(`The following fields are missing: ${missingFields}.`)

  }


  let addUser = () => {

    let userNoPw = { ...formData }

    delete userNoPw.password

    registeredUsers.push(userNoPw)

  }

  if (seachRegistered) {

    throw new Error(`The email ${formData.email} is already registered.`)

  } else if (fieldChecker != 0) {

    throw new Error(`The following fields are missing: ${missingFields}.`)

  } else {

    addUser()

    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`

  }

}

Esta la solucion que pude codear, espero su feedback y sus opiniones
🛡️Escudo anti-spoilers🛡️
.
.
.

.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  const validatefield = ["name", "lastname", "email", "password"]
  const missignfField = []
  validatefield.map(field => !formData.hasOwnProperty(field) && missignfField.push(field))
  if (missignfField.length > 0) {
    let missigngFieldMessage = 'Faltan los siguientes campos: '
    missigngFieldMessage += missignfField.map(field => field).join(", ")
    throw new Error(missigngFieldMessage)
  }
  const emailExist = registeredUsers.some(registeredUser =>
    registeredUser.email === formData.email)
  if (emailExist) {    
    throw new Error('El usuario ya se encuentra registrado')
  } else {
    delete formData.password
    registeredUsers.push(formData)
    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
  }
}

.
My solution:
.

.

export function validateForm(formData, registeredUsers) {
  const errors = Object.entries(formData)
    .filter(([key, value]) => !value)
    .map(([key]) => key)
  if (errors.length > 0) {
    throw Error(
      `Faltan los siguientes campos requeridos: ${errors.join(',')}`
    )
  }
  if (registeredUsers
    .some(({ email }) =>
      email === formData.email)
  ) {
    throw Error(
      `Email duplicado: ${formData.email}`
    )
  }

  delete formData.password
  
  registeredUsers.push(formData)

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`

}

challenge exceeded

Solucion

function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const expectedDataProps = ['name', 'lastname', 'email', 'password']

  const propNames = Object.keys(formData)

  // Check props

  if (propNames.length < 3) {
    const missingProps = expectedDataProps.filter(prop => !propNames.includes(prop))
    throw new Error(`Missing fields: ${missingProps.join(", ")}`)
  }

  // Check registered users
  for (obj in registeredUsers) {
    if (formData.email === obj.email) throw new Error("This user already exists!")
  }

  // Add user logic
  console.log(`User succesfully added ${formData.name}`)
}

.
.
.
.
.

.
.
.

.
.
.

export function validateForm(formData, registeredUsers) {
  const fieldsToValidate = ["name", "lastname", "email", "password"];
  const missingFields = [];

  fieldsToValidate.forEach(field => {
    if (!formData[field]) {
      missingFields.push(field);
    }
  }
  )


  if (missingFields.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${missingFields.join(',')} `)
  }


  if (registeredUsers.find(user => user.email === formData.email)) {
    throw new Error(`${formData.email}`);
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email,
    })
  }

  return `Tu registro fue exitos ${formData.name} ${formData.lastname} `


}

mi humilde solucion, quisiera opiniones, gracias.

export function validateForm(formData, registeredUsers) {
  let datosFaltantes = '';
  let keys = ['name', 'lastname', 'email', 'password'];
  for (let index = 0; index < keys.length; index++) {
    let hi = keys[index];
    if (!formData[hi]) {
      datosFaltantes = datosFaltantes + formData[hi] + " ";
    }
  }
  if (datosFaltantes !== "") {
    throw new Error(`Faltan los siguientes campos: ${datosFaltantes}`);
  } else if (registeredUsers.some(x => x.email == formData.email)) {
    throw new Error(`El Email ya existe`);
  } else {
    registeredUsers.push({ name: formData.name, lastname: formData.lastname, email: formData.email });
    return (`Tu registro fue exitoso ${formData.name} ${formData.lastname}`);
  }
  
}

Mi respuesta

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

export function validateForm(formData, registeredUsers) {
  let response = "Faltan los siguientes campos requeridos: "
  let missingFields = []
  const checkInfo = {
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  }

  if (!checkInfo.name) {
    missingFields.push("name")
  }
  if (!checkInfo.lastname) {
    missingFields.push("lastName")
  }
  if (!checkInfo.email) {
    missingFields.push("email")
  }



  let duplicatedEmail = registeredUsers.find(registeredData => registeredData.email === formData.email)

  if (duplicatedEmail) {
    throw new Error("Email duplicado") 
  } else {
    if (missingFields.length > 0) {
      for (let i = 0; i < missingFields.length; i++) {
        response = response + missingFields[i] + " "
      }
      throw new Error(response)
    } else {
      registeredUsers.push(checkInfo)
      response = `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
    }
  }

  return response
}

Cuidado Spoiler

Mi solución

const REQUIRED_FIELDS = ["name", "lastname", "email", "password"]

const isValidForm = (inputs) =>
  REQUIRED_FIELDS.every(field => !!inputs[field])

const getMissingFields = (inputs) =>
  REQUIRED_FIELDS.filter(field => !!inputs[field] === false)

export function validateForm(formData, registeredUsers) {
  if (!isValidForm(formData)) {
    const missingFields = getMissingFields(formData).join(", ")
    throw new Error(`Faltan los siguientes campos: ${missingFields}`);
  }

  const emailExists = registeredUsers.find(
    user => user.email === formData.email
  )

  if (emailExists) {
    throw new Error(`${formData.email} duplicado` )
  }

  const { password, ...userData } = formData
  registeredUsers.push(userData)
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
}

Anti-Spoiler Shield
Anti-Spoiler Shield
Anti-Spoiler Shield
Anti-Spoiler Shield

export function validateForm(formData, registeredUsers) {
  // Verify required fields
  const { name, lastname, email, password } = formData;
  if (!name || !lastname || !email || !password) {
    throw new Error("Faltan los siguientes campos: name, email, etc...");
  }

  // Verify duplicate email
  let duplicatedEmail = registeredUsers.find(registeredData => registeredData.email === formData.email)

  if (duplicatedEmail) {
    throw new Error(`Email duplicado ${duplicatedEmail}`);
  }

  // Insert new user
  let newUser = {
    name,
    lastname,
    email
  }

  registeredUsers.push(newUser)

  return `Tu registro fue exitoso ${name} ${lastname}`
}

Las vueltas que he dado por no ver como error guardar el password al registrar ususario xD
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {

  const obligatorios = ["name", "lastname", "email", "password"];
  const checkData = [{
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  }]
  const checkPass = formData.password;

  if (checkData.every((item) => {
    return (item.name && item.lastname && item.email && checkPass);
  })) {

    if (registeredUsers.some(item => item.email == checkData[0].email)) {
      throw new Error("Email Duplicado: " + checkData.email);
    } else {
      registeredUsers.push(checkData[0]);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
    }
  } else {
    let faltan = obligatorios.filter(item => checkData[0].item == "").join(",");
    throw new Error("Faltan los siguientes campos: " + faltan);
  }

}

Mi solución

Hola, paso por aquí para compartir.

export function validateForm(formData, registeredUsers) {
  let error = "Faltan los siguientes campos: ";
  const missingData = [];

  const validateFormData = (data) => {
    !(data.hasOwnProperty('name') && data.name != '')
      && missingData.push("name");
    !(data.hasOwnProperty('lastname') && data.name != '')
      && missingData.push("lastname");
    !(data.hasOwnProperty('email') && data.name != '')
      && missingData.push("email");
    !(data.hasOwnProperty('password') && data.name != '')
      && missingData.push("password");

    if (missingData.length) {
      error += missingData.join(", ");
      throw new Error(error);
    }
  }

  validateFormData(formData);

  const emailExist = registeredUsers.find(user => user.email === formData.email
  )

  if (emailExist) {
    throw new Error(emailExist.email);
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email
    });
    return `Tu registro fue exitoso ${formData.name} ${formData.lastname} `;
  }

}

Hola. Comparto mi solución al ejercicio con comentarios
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {

  // cadena y arreglo de apoyo
  let ERROR_MSG = "Faltan los siguientes campos requeridos: ";
  let missingArray = [];
  // recorrer el objeto del input. Si la key no existe, hacer push de esa key al arreglo de missing
  for (let key in formData)
    if (!formData[key]) missingArray.push(key);
  // si el arreglo de missing contiene elementos -> unir la info y arrojar el error
  if (missingArray.length > 0) 
    throw new Error(ERROR_MSG + missingArray.join(", "));
  // recorre el arreglo de users y si algún mail coincide, lanza el error
  if (registeredUsers.some(u => u.email == formData.email))
    throw new Error(`El email ${formData.email} ya está en uso`);
  // limpiar y cargar el nuevo usuario
  delete formData.password;
  registeredUsers.push(formData)
  // mensaje de éxito
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
}

Seguimos avanzando Platzi! 😃

function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const form = {
    name: "",
    lastname: "",
    email: "",
    password: ""
  }
  let noprop = [];

  for (let obj in form) {
    if (!formData.hasOwnProperty(obj)) {
      noprop.push(obj);
    }
  }

  if (noprop.length === 0) {
    let mail = registeredUsers.find(data => data.email === formData.email);

    if (!mail) {
      delete formData.password;
      registeredUsers.push(formData);
      return `Tu registro fue exitoso ${formData.name}`;
    } else {
      return `Email ${formData.email} duplicado.`
    }

  } else {
    throw new Error(`Faltan los siguientes campos: ${[...noprop]}`);
  }

}

Mi aporte:


export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  let invalidForm = "Faltan los siguientes campos requeridos:";
  let isValid = true;
  let message;
  if (!formData.hasOwnProperty('name')) {
    invalidForm = `${invalidForm} name,`;
    isValid = false;
  } if (!formData.hasOwnProperty('password')) {
    invalidForm = `${invalidForm} password,`;
    isValid = false;
  }
  if (!formData.hasOwnProperty('email')) {
    invalidForm = `${invalidForm} email,`;
    isValid = false;
  }
  if (!formData.hasOwnProperty('lastname')) {
    invalidForm = `${invalidForm} lastname`;
    isValid = false;
  }
  if (isValid) {
    const findUser = registeredUsers.find((el) => {
      return el.email === formData['email']
    });
    if (findUser === undefined) {
      message = "Tu registro fue exitoso " + formData['name'] + " " + formData['lastname'];
      registeredUsers.push({
        name: formData.name,
        lastname: formData.lastname,
        email: formData.email
      });
    } else {
      throw new Error("El email esta duplicado");
    }
  } else {
    throw new Error(invalidForm);
  }

  return message;
}

Algo diferente

export function validateForm(formData, registeredUsers) {

  function missingData(data) {
    let missingValues = []
    for (let item in data) {
      let value = Object.values(data[item])
      if (value.length === 0) {
        missingValues.push(item)
      }
    }
    throw new Error(`Faltan los siguientes campos: ${missingValues.join(', ')}`)
  }
      
  let { name, lastname, email, password } = formData

  if (name && lastname && email && password) {
    registeredUsers.forEach(user => {
      if (user.email === email) throw new Error('Email duplicado.')
    })
  } else {
    missingData(formData)
  }
  registeredUsers.push({ name, lastname, email })
  return `Tu registro fue exitoso ${name} ${lastname}`
}

Esta es mi solución al sandbox, cuidado con los spoilers
.
.
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  let errorMessage = "Faltan los siguientes campos:";
  let hasName = formData.name != "" && formData.name;
  if (!hasName) {
    errorMessage = `${errorMessage} name,`;
  }
  let hasLastname = formData.lastname != "" && formData.lastname;
  if (!hasLastname) {
    errorMessage = `${errorMessage} lastname,`;
  }
  let hasEmail = formData.email != "" && formData.email;
  if (!hasEmail) {
    errorMessage = `${errorMessage} email,`;
  }
  let hasPassword = formData.password != "" && formData.password;
  if (!hasPassword) {
    errorMessage = `${errorMessage} password`;
  }

  if (hasName && hasLastname && hasEmail && hasPassword) {
    if (!registeredUsers.find(user => user.email == formData.email)) {
      let { password, ...copia } = formData;
      registeredUsers.push(copia);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
    }
    else {
      throw new Error("Email ya registrado")
    }
  }
  else {
    throw new Error(errorMessage);
  }
}

Mi solución:

export function validateForm(formData, registeredUsers) {
  const properties = ["name", "lastname", "email", "password"]
  let missingProperties = []

  for (let property of properties) {
    if (!formData.hasOwnProperty(property)) {
      missingProperties.push(property)
    }
  }

  if (missingProperties.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${missingProperties.join(", ")}`)
  }

  if (registeredUsers.find((user) => user.email === formData.email)) {
    throw new Error(`El siguiente email ya se encuentra registrado: ${formData.email}`)
  }

  const { password, ...newUser } = formData
  registeredUsers.push(newUser)

  return `Tu registro fue exitoso ${newUser.name} ${newUser.lastname}`
}

Este ejercicio me subio el animo, espero que a uds tambien, mi versión de la solución:

function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈

  let fieldsEmpty = "";

  if (
    formData.hasOwnProperty("name") &&
    formData.hasOwnProperty("lastname") &&
    formData.hasOwnProperty("email") &&
    formData.hasOwnProperty("password")
  ) {
    //DATOS COMPLETOS

    let trueExist = registeredUsers.find(
      (value) => value.email === formData.email
    );
    if (trueExist) {
      throw new Error(`${formData.email}`);
    } else {
      //Se puede añadir el registro

      let addUser = 
        {
          name: formData.name,
          lastname: formData.lastname,
          email: formData.email,
        };
      
      registeredUsers.push(addUser);
      return (`Tu registro fue exitoso ${formData.name} ${formData.lastname}`)
    }

  } else {
    //  Buscar cuales campos faltan
    if (formData.hasOwnProperty("name") === false) {
      fieldsEmpty = "name";
    }
    if (formData.hasOwnProperty("lastname") === false) {
      if (fieldsEmpty) {
        fieldsEmpty = `${fieldsEmpty}, lastname`;
      } else {
        fieldsEmpty = "lastname";
      }
    }
    if (formData.hasOwnProperty("email") === false) {
      if (fieldsEmpty) {
        fieldsEmpty = `${fieldsEmpty}, email`;
      } else {
        fieldsEmpty = "email";
      }
    }
    if (formData.hasOwnProperty("password") === false) {
      if (fieldsEmpty) {
        fieldsEmpty = `${fieldsEmpty}, password`;
      } else {
        fieldsEmpty = "password";
      }
    }

    throw new Error(`Faltan los siguientes campos: ${fieldsEmpty}`);
  }
} 

Mi solución 🤔

export function validateForm(formData, registeredUsers) {
	const requiredFields = ['name', 'lastname', 'email', 'password'];
	const missingFields = requiredFields.filter(
		(requiredField) => !formData.hasOwnProperty(requiredField)
	);

	if (missingFields.length) {
		const stringMissingFields = missingFields.join(',');

		throw new Error(`Faltan los siguientes campos: ${stringMissingFields}`);
	}

	const { name, lastname, email } = formData;

	const isRegistered = registeredUsers.find((user) => user.email === email);

	if (isRegistered) throw new Error(`El correo ${email} ya fue registrado`);

	registeredUsers.push({ name, lastname, email });

	return `Tu registro fue exitoso ${name} ${lastname}`;
}

Mi humilde solución:

export function validateForm(formData, registeredUsers) {
  const check = [];
  var result = 0;
  if (formData.hasOwnProperty("name") && formData.hasOwnProperty("lastname") && formData.hasOwnProperty("email") && formData.hasOwnProperty("password")) {
    result = registeredUsers.find(element => element.email === formData.email);
    if (result) {
      throw new Error("Error email duplicado");
    }
    else {
      registeredUsers.push({ name: formData.name, lastname: formData.lastname, email: formData.email });
    }

  } else {
    formData.hasOwnProperty("name") ? undefined : check.push("name");
    formData.hasOwnProperty("lastname") ? undefined : check.push("lastname");
    formData.hasOwnProperty("email") ? undefined : check.push("email");
    formData.hasOwnProperty("password") ? undefined : check.push("password");
    throw new Error("Faltan los siguientes campos requeridos: " + check);
  }
  return ("Tu registro fue exitoso " + formData.name + " " + formData.lastname);
} 

Adjunto mi solución

export function validateForm(formData, registeredUsers) {
  const errorString = []
  const validateEmail = registeredUsers.findIndex(element => element.email === formData.email);

  if (!formData.hasOwnProperty('name')) {
    errorString.push('name')
  }
  if (!formData.hasOwnProperty('lastname')) {
    errorString.push('lastname')
  }
  if (!formData.hasOwnProperty('email')) {
    errorString.push('email')
  }
  if (!formData.hasOwnProperty('password')) {
    errorString.push('password')
  }

  if (errorString.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${errorString.join(", ")}`);
  }
  else if (validateEmail !== -1) {
    const error = `Email ${formData.email} ya se encuentra en la lista de usuarios registrados ${JSON.stringify(registeredUsers)}`
    throw new Error(error)
  }
  else {

    registeredUsers.push(
      {
        name: formData.name,
        lastname: formData.lastname,
        email: formData.email
      }
    )

    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
  }

}
    • ++

++
+
+
+
++
+
++
+
+
+
+

export function validateForm(formData, registeredUsers) {
  if (formData.name && formData.lastname && formData.email && formData.password) {
    if(registeredUsers.find(email => email === formData.email)){
      throw new Error(`El email ${formData.email} esta duplicado`);
    }
    else{
      delete formData.password;
      registeredUsers.push(formData);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
    }
  }
  else {
    let fiels=["name", "lastname", "email", "password"];
    let message ="Faltan los siguientes campos: ";
    for(let i of fiels){
      if(!formData[i]){
        message+= `${i}, `;
        console.log(message);
      }
    }
    console.log(message);
    throw new Error(message);
  }
}

MI SOLUCION
▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾▾

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const props = ["name", "lastname", "email", "password"]

  const missingProps = []

  for (let prop of props) 
    if (!formData[prop]) missingProps.push(prop)
    
  if (missingProps.length > 0) throw new Error(`Faltan los siguientes campos: ${missingProps.join(", ")}`)

  const { password, ...data } = formData

  if (registeredUsers.some(user => user.email === formData.email))
    throw new Error("El email ya existe")

  registeredUsers.push(data)

  return `Tu registro fue exitoso ${data.name} ${data.lastname}`
}

Comparto mi solución compañeros:
.
.
.
.
.
.
.

.
.

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 

  const validate = validateFormUser(formData)


  if (validate.length > 0) {
    let stringError = "Faltan los siguientes campos: "
    for (let field of validate) {
      stringError += ` ${field}`
    }
    throw new Error(stringError)
  }
  
  const user = {
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  }

  if (isDuplicate(user, registeredUsers) ) {
    throw new Error(`Problemas con ${user.email}`)
  }

  registeredUsers.push(user)

  return `Tu registro fue exitoso ${user.name} ${user.lastname}`
  
}

function validateFormUser(form) {
  const fields = ['name', 'email', 'password', 'lastname'];
  const emptyFields = [];
  for (let item of fields) {
    if (!form[item]) {
      emptyFields.push(item);
    }
  }
  return emptyFields;
}


function isDuplicate(user, userArray) {
  const data = userArray.find(item => {
    return item.email === user.email;
  })

  if (!data) return false;
  return true;
}

Aquí mi solución:

<export function validateForm(formData, registeredUsers) {
  let camposFaltantes = "";
  //verificación de los campos faltantes
  if (!formData.hasOwnProperty('name'))
    camposFaltantes += "name";
  if (!formData.hasOwnProperty('lastname'))
    camposFaltantes == "" ? camposFaltantes += "lastname" : camposFaltantes += ", lastname";
  if (!formData.hasOwnProperty('email'))
    camposFaltantes == "" ? camposFaltantes += "email" : camposFaltantes += ", email";
  if (!formData.hasOwnProperty('password'))
    camposFaltantes == "" ? camposFaltantes += "password" : camposFaltantes += ", password";
  if (camposFaltantes.length)
    throw new Error("Faltan los siguientes campos: " + camposFaltantes);
  else {
    if (registeredUsers.find(data => data.email == formData.email)) {
      throw new Error("email duplicado");
    }
    else {
      const item = {
        name: formData.name,
        lastname: formData.lastname,
        email: formData.email
      }
      registeredUsers.push(item);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
    }
  }
}
> 

Intenté hacerlo de una manera diferente, en este caso, usando el concepto de generadores para que me dijera si alguno de los campos falta. Realmente me puso mucho a pensar jajaja.

function validateForm(formData, registeredUsers) {
    // Lista con campos faltantes
    const fills = [];
  
    // Generador que obtiene los campos que faltan
    function* missing(form) {
      if (!form.name) {
        yield 'name';
      }
      if (!form.lastname) {
        yield 'lastname';
      }
      if (!form.email) {
        yield 'email';
      }
      if (!form.password) {
        yield 'password';
      }
    }
  
    // Pasamos los campos faltantes del generador a fills
    const generator = missing(formData);
    for (const missingField of generator) {
        fills.push(missingField);
    }


    try {
        // Si faltan campos generamos el error
        if(fills.length !== 0){
            let message = "Faltan los siguientes campos requeridos: ";
            (() => {
                let missings = fills.map(value => value);
                for (const elem of missings){
                    message += `${elem}, `
                }
                message = message.slice(0, -2);
            })();

            throw new Error(message);
        }else{
            //Si no faltan campos, validamos que el email no se encuentre en los usuarios registrados
            let emailForm = formData.email;
            const emailExists = registeredUsers.find(person => person.email === emailForm);
            if (emailExists){
                console.error("Email duplicado");
            }else{
                // Si no se encuentra el email duplicado añadimos el usuario a lista de usuarios registrados (sin password)
                const {name, lastname, email,} = formData;
                registeredUsers.push({name, lastname, email});
                return `Tu registro fue exitoso ${name} ${lastname}`;
            }
        }
    } catch (error) {
        return(error.message);
    }
}

Al correrlo aquí me salen los siguientes errores que no entiendo completamente:

  • Should throw an error if the user exists (debería tambien impedir que el name se repita? o…)
  • Should throw an error if fields are needed (creo que sí estoy generando este error)
    En cuanto a esto alguien me podría explicar por qué es?

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

export function validateForm(formData, registeredUsers) {
  const requiredFields = ["name", "lastname", "email", "password"];
  const missingFields = requiredFields.filter(campo => !formData[campo]);
  if (missingFields.length) {
    throw new Error(`Faltan los siguientes campos: ${missingFields}`);
  }
  if (registeredUsers.find(user => user.email === formData.email)) {
    throw new Error("Error email duplicado");
  }
  registeredUsers.push({ 
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
   });
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
}

Comparto mi solucion.

Para verificar los campos faltantes primero creo un array con los campos requeridos y otro array vacio con los campos faltante; luego recorro el array de campos requeridos verificando si el formulario tiene esa propiedad, de no tenerla la agrega al array de campos faltantes.

El error es lanzado cuando el array de campos faltantes no esta vacio

const requiredFields = ["name", "lastname", "email", "password"];
  let missedFields = []

  for (const field of requiredFields) {
    if (!formData.hasOwnProperty(field))
      missedFields.push(field);
  }

  if (missedFields.length > 0) {
    const error = "Faltan los siguientes campos: " + missedFields.join(", ");
    throw new Error(error);
  }

Para verificar si el usuario existe uso el metodo de array find que me retornara un numero si encuentra el correo o undefined si no lo encuentra.

const emailExists = registeredUsers.find(user => user.email === formData.email);

  if (emailExists !== undefined) {
    throw new Error(`Email ${formData.email} already exists`);
  }

Finalmente si todo sale bien registro el nuevo usuario sin la contraseña y retorno el mensaje de exito.

registeredUsers.push({
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  });

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`

El codigo completo

export function validateForm(formData, registeredUsers) {
  const requiredFields = ["name", "lastname", "email", "password"];
  let missedFields = []

  for (const field of requiredFields) {
    if (!formData.hasOwnProperty(field))
      missedFields.push(field);
  }

  if (missedFields.length > 0) {
    const error = "Faltan los siguientes campos: " + missedFields.join(", ");
    throw new Error(error);
  }

  //---
  const emailExists = registeredUsers.find(user => user.email === formData.email);

  if (emailExists !== undefined) {
    throw new Error(`Email ${formData.email} already exists`);
  }

  //---
  registeredUsers.push({
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  });

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
}

Solución… 😄
.
Para resolver el reto, hemos creado 2 arrays, uno con el nombre de las propiedades requeridas ‘required’ y otro vacío ‘missing’ donde vamos a guardar las propiedades que faltan de los datos recibidos por el formulario.
.
Mediante ciclo for-of recorremos ‘required’ y verificamos si el campo existe en las propiedades de ‘formData’. Si existe lo agregamos a ‘missing’.
.
Luego, verificamos si ‘missing’ tiene longitud, lo que significa que se tuvieran campos vacíos. Lanzamos el error correspondiente separados por “, " mediante la función splice(”, ").
.
En ‘duplicated’ aplicamos buscamos entre los usuarios registrados si existe un correo repetido mediante find().
.
Si duplicated existe entonces lanzamos el error correspondiente, sino añadimos el usuario al registro de usuarios y retornamos el mensaje exitoso.
.

export function validateForm(formData, registeredUsers) {
  let required = ["name", "lastname", "email", "password"];
  let missing = [];

  for (const field of required) { 
    if (!formData[field]) {
      missing.push(field);
     }
  }

  if (missing.length) { 
    throw new Error(`Faltan los siguientes campos: ${missing.join(", ")}`);
  }

  let duplicated = registeredUsers.find((user) => user.email === formData.email);

  if (duplicated) {
    throw new Error("Email duplicado");
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email
    });
    return "Tu registro fue exitoso Juan Perez";
  }

}

Les dejo mi solución, solo use some e includes para metodos de recorrido de arrays.

export function validateForm(formData, registeredUsers) {
  const missingValues = []
  function registeringUser({ name = '', lastname = '', email = '', password = '' }) {
    let obj = { name, lastname, email, password };
    if (Object.values(obj).includes('')) {
      for (let key in obj) {
        if (obj[key] == '') { missingValues.push(key.toString()) }
      }
      throw new Error(`Faltan los siguientes campos:${missingValues.join(", ")}`);
    } else if (registeredUsers.some((ele)=>ele.email===obj.email)) {
      throw new Error(`El email '${obj.email}' ya existe.`);
    } else {
      registeredUsers.push({ name:obj.name, lastname:obj.lastname, email:obj.email });
      return `Hola ${obj.name.charAt(0).toUpperCase() + obj.name.slice(1).toLowerCase()} ${obj.lastname.charAt(0).toUpperCase() + obj.lastname.slice(1).toLowerCase()}, tu registro fué exitoso.`;
    }
  }
  return registeringUser(formData)

}

Buenas!! abajo mi solución, tenía un error a la hora de agregar los datos al array de usuarios registrados, hasta que me di cuenta que no pedía agregar el password XD .
PD: lean bien la Guía

function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈

  let missingData = [];

  if (!formData.name) {
    missingData.push('name')
  };
  if (!formData.lastname) {
    missingData.push('lastname')
  };
  if (!formData.email) {
    missingData.push('email')
  };
  if (!formData.password) {
    missingData.push('password')
  };

  if (!missingData[0]) {

    let emailVerified = registeredUsers.find(user => user.email == formData.email)

    if (!emailVerified) {
      registeredUsers.push({
        'name': formData.name,
        'lastname': formData.lastname,
        'email': formData.email
      })
      return console.log(`Tu registro fue exitoso ${formData.name} ${formData.lastname}`)
    } else {

      throw new Error(`Email ${formData.email} duplicado`);
    }

  } else {

    throw new Error(`Faltan los siguientes campos: ${missingData}`);
  }

}

¡Hola 😃!

Solución,
Se detalla hasta abajo.⬇









export function validateForm(formData, registeredUsers) {
  const campos = ["name", "lastname", "email", "password"];
  const camposError = campos.filter((item) => !formData[item]).join(", ");
  if (camposError.length)
    throw new Error(`Faltan los siguientes campos: ${camposError}`);
  else
    if (registeredUsers.find((user) => formData.email === user.email))
      throw new Error(`Email ${formData.email} duplicado`);
    else {
      registeredUsers.push({ "name": formData.name, "lastname": formData.lastname, "email": formData.email });
    }

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
}

*SPOILER ALERT
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

Por aca les dejo mi solución, espero les ayude.

export function validateForm(formData, registeredUsers) {
  const requiredFields = ['name', 'lastname', 'email', 'password']

  const pendingFields = requiredFields.filter(item => {
    return !formData[item]
  })

  // Validating Pending Fields
  if (pendingFields.length) {
    throw new Error(`Faltan los siguientes campos requeridos: ${pendingFields.join(', ')}`)
  }

  // Validating Duplicated email
  const userExist = registeredUsers.some(user => user.email === formData.email)
  if (userExist) {
    throw new Error(`El correo ${formData.email} ya se encuentra registrado`)
  }

  delete formData.password
  registeredUsers.push(formData)

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
}

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

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const properties = ['name', 'lastname', 'email', 'password'];
  let propertiNoFound = [];
  let duplicateEmail = [];

  properties.forEach(prop => {
    if (!formData[prop]) {
      propertiNoFound.push(prop)
    }
  });

  duplicateEmail = registeredUsers.find(user => user.email === formData.email);

  if (propertiNoFound.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${propertiNoFound.join(', ')}`)
  } else if (duplicateEmail) {
    throw new Error(`El correo ${duplicateEmail.email} ya se encuentra registrado`);
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email
    });
    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
  }
}

Mi solución
🛡 Escudo anti-spoilers
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  let has_error = false;
  let missing_fields = [];

  ["name", "lastname", "email", "password"].forEach(field => {
    if (!formData[field]) {
      has_error = true;
      missing_fields.push(field);
    }
  });
  if (has_error) {
    throw new Error("Faltan los siguientes campos: " + missing_fields.join(','));
  }
  let flag = registeredUsers.find(e => e.email == formData.email);
  if (!flag) {
    delete formData.password;
    registeredUsers.push(formData);
    return "Tu registro fue exitoso " + formData.name + ' ' + formData.lastname;
  }
}

Mi solución:

No estoy seguro que sea la solución más elegante, pero funciona jaja:

function validateForm(formData, registeredUsers) {
  const datosNecesarios = ["name", "lastname", "email", "password"];
  const datosObjeto = [];
  const datosFaltantes = [];
  let correoRepetido;

  for (let dato in formData) {
    datosObjeto.push(String(dato));
  }

  for (let i = 0; i < datosNecesarios.length; i++) {
    if (datosObjeto[i] !== datosNecesarios[i])datosFaltantes.push(datosNecesarios[i]);
  }

  if (datosFaltantes.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${datosFaltantes.join(",")}`
    );
  } else {
    for (let i = 0; i < registeredUsers.length; i++) {
      if (formData["email"] == registeredUsers[i].email)correoRepetido = formData.email;
      
    }
  }
  if (correoRepetido !== undefined) {
    throw new Error(`EL correo ${formData.email} ya se encuentra registrado`);
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email,
    });
    return `Tu registro fue exitoso ${formData.name}`;
  }
}

Bueno reto cumplido gg

🛡 Escudo anti-spoilers
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  let validateKeys = {
    name: false,
    lastname: false,
    email: false,
    password: false
  }
  for (let item in formData) {
    validateKeys[item] = true
  }
  let missingValues = Object.entries(validateKeys).filter((item) => item[1] === false).map(item => item[0])

  if (missingValues.length !== 0) throw new Error(`Faltan los siguientes campos: ${missingValues.join(', ')}`)
  if (registeredUsers.findIndex((user) => user.email === formData.email) !== -1) throw new Error(`El usuario ya fue registrado con ese email`)

  const { name, lastname, email } = formData
  registeredUsers.push({ name, lastname, email })

  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
}

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

function validateForm(formData, registeredUsers) {
    // Tú código aquí 👈
    const {
	name, 
	lastname, 
	email, 
	password 
    } = formData
    if (name && lastname && email && password) {
        const existsEmail = registeredUsers.find(element => element.email === formData.email);
        if(existsEmail) {
            throw new Error(`Ya existe el correo ${existsEmail.email}`)
        };

        registeredUsers.push({name: formData.name, lastname: formData.lastname, email: formData.email});
        return "Tu registro fue exitoso Juan Perez";
    }else{
        const camposFaltantes = []
        if(name === '') { camposFaltantes.push('name') }
        if(lastname === '') { camposFaltantes.push('lastname') }
        if(email === '') { camposFaltantes.push('email') }
        if(password === '') { camposFaltantes.push('password') }
        throw new Error(`Faltan los siguientes campos: ${camposFaltantes.join(', ')}`)
    }
    
}

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

export function validateForm(formData, registeredUsers) {
  let fields = ["name", "lastname", "email", "password"];
  let emailRegistered = registeredUsers.map(user => user.email);

  if (fields.some(field => !formData[field])) {
      throw new Error(`Faltan los siguientes campos: ${fields.filter(field => !formData[field])}`);
    };

  if (emailRegistered.includes(formData.email)) {
    throw new Error(`El email ${formData.email} ya a sido registrado.`);
  }

  let { password, ...newUser } = formData;
  registeredUsers.push(newUser);
  return `Tu registro fue exitoso ${newUser.name} ${newUser.lastname}.`;
}

**> Copy and Paste “Spoiler”
**

export function validateForm(formData, registeredUsers) {

  let response = "";
  let emptyField = false;


  for (let property in formData) {
    if (formData[property] === "") {
      emptyField = true;
      response += "${property}, ";
    }
  }

  if (!emptyField) {
    let flag = registeredUsers.findIndex(user => user.email === formData.email);

    if (flag != -1) {
      
      throw new Error(`El email ${formData.email} esta duplicado`);
    }
    else {
     
      delete formData.password;
      registeredUsers.push(formData);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
    }
  }
  else {
    throw new Error(`Faltan los siguientes campos: ${response}`);
  }
}

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

export function validateForm(formData, registeredUsers) {
  const { name, lastname, email, password } = formData
  if (name && lastname && email && password) {
    registeredUsers.some(user => {
      if (user.email === email) 
        throw new Error('El email está duplicado')
    })
    registeredUsers.push({ name, lastname, email })
    return `Tu registro fue exitoso ${name} ${lastname}`
  } else {
    const missingFields = []
    for (let fields in formData) {
      if (!formData[fields])
        missingFields.push(fields)
    }
    throw new Error(`Te faltan los siguientes campos: ${missingFields.join(', ')}`)
  }
}

=======================================

🛡 Escudo anti-spoilers

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Este es uno de mis primeros aportes en Platzi, intente hacer que mi código sea lo mas legible y optimo posible. Cualquier recomendación es bien recibida 😀

export const validateForm = function (formData, registeredUsers) {
  // Definimos todos los campos a validar
  const fields = ["name", "lastname", "email", "password"];

  // Validamos todos los campos, retornando en forma de string los campos invalidos
  const invalidFields = fields.filter((field) => !formData[field]).join(", ");

  // Si existe algun campo invalido, entonces lanzara un error sobre los campos faltantes
  if (invalidFields.length)
    throw new Error(`Faltan los siguientes campos: ${invalidFields}`);

  // Si existe algun email existente, entonces lanzara un error de email duplicado
  if (registeredUsers.find((user) => formData.email === user.email))
    throw new Error(`${formData.email} esta tomado`);

  // En caso que los datos sean validos, se agregara al arreglo
  const { name, lastname, email } = formData;
  registeredUsers.push({ name, lastname, email });

  // Para terminar, retornaremos un mensaje de confirmacion al usuario
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
};

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

export function validateForm(formData, registeredUsers) {
  //Defino todos los campos.
  /*No me conviene usar Object.values(formData) porque en el ejemplo 2 se envía la siguiente información:

  const formData = {
  name: "Juan",
  password: "123456",
};

  Con Object.values(formData) verificaría únicamente si name y password tienen contenido
  */
  let campos = ['name', 'lastname', 'email', 'password']

  //Si cualquiera de estos campos está vacío se activa esta función
  if (campos.some(campo => !formData[campo])) {
    //Filtro y escribo los campos con un array comprehension
    throw new Error("Faltan los siguientes campos:" + [campos.filter(campo => !formData[campo])]);
  }
  //Si todos los campos estaban llenos revisa que el correo no esté duplicado, si está duplicado lanza el error
  else if (registeredUsers.some(usuario => usuario['email'] == formData.email)) {
    throw new Error("El correo electrónico está duplicado");
  } 

  delete formData['password']
  registeredUsers.push(formData)
  return "Tu registro fue exitoso " + formData.name + " " + formData.lastname
}

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

.
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  let { name, lastname, email, password } = formData
  let error = false
  let message = 'Faltan los siguientes campos requeridos:'

  if (!name) {
    error = true
    message += " name,"
  }

  if (!lastname) {
    error = true
    message += " lastname,"
  }

  if (!email) {
    error = true
    message += " email,"
  }

  if (!password) {
    error = true
    message += " password,"
  }


  if (error) {
    message = message.slice(0, -1);
    throw new Error(message);
  }

  const existUser = registeredUsers.find(
    (user) => user.email === formData.email
  );

  if (existUser) {
    throw new Error(`usuario ${email} ya existe`);
  }

  registeredUsers.push({ name, lastname, email })

  return `Tu registro fue exitoso ${name} ${lastname}`

}

esta bien pasa las pruebas, pero no se siento que podria usar el every o hasta el some, por el momento lo dejare asi. a lo mejor transformando el objecto a un array etc. creo que lo voy a hacer de nuevo

Spoiler:
.
.
.
.
.
.
.
.
.
.
.

< function validateForm(formData, registeredUsers) {
    if(Object.values(formData).some(ele => !ele)){
        throw new Error(
            `Faltan los siguientes campos: ${Object.values(formData).filter(ele => !ele)}`
        );
    };

    registeredUsers.map((ele) => {
        if(ele.email === formData.email){
            throw new Error(`El email ya está registrado`);
        };
    });

    let obj = formData;
    delete obj.password;

    registeredUsers.push(obj);

    return `Tu registro fue exitoso ${obj.name} ${obj.lastname}`;
};> 
undefined