Playground - Válida el formulario

🛡️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 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}`;
}```

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}`
}

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}`;
}

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}`
}

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}`)

}> 

Favor evitar ver mas abajo si no quieres hacerte spoilers !

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

  // Verificar campos requeridos
  const missingFields = requiredFields.filter(field => !formData[field]);
  if (missingFields.length > 0) {
    throw new Error(`Faltan los siguientes campos requeridos: ${missingFields.join(", ")}`);
  }

  // Verificar email duplicado
  const existingEmail = registeredUsers.find(user => user.email === formData.email);
  if (existingEmail) {
    throw new Error(`El email '${formData.email}' ya está en uso.`);
  }

  // Registro exitoso
  const newUser = {
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email,
  };
  registeredUsers.push(newUser);

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

🛡️Escudo anti-spoilers🛡️
Se puede mejorar bastante usando los métodos que veremos en las proximas lecciones como join e includes
.
.
.
.
.
.
.
.
.
.
.
.
.
.

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

  const fieldNames = ['name', 'lastname', 'email', 'password'];
  const errorFields = 'Faltan los siguientes campos: ';

  checkData(formData, fieldNames);

  if (isEmailNew(formData.email, registeredUsers)) {
    throw new Error("Email duplicado");
  };

  return addNewUser(formData, registeredUsers);

  function addNewUser(userData, registeredUsers) {
    console.log('start addNewUser');
    const userToAdd = {
      name: userData.name,
      lastname: userData.lastname,
      email: userData.email
    };
    console.log('userToAdd:', userToAdd);
    registeredUsers.push(userToAdd);
    console.log('registeredUsers:', registeredUsers)
    console.log('end addNewUser');
    return `Tu registro fue exitoso ${userData.name} ${userData.lastname}`
  }

  function isEmailNew(newEmail, registeredUsers) {
    console.log('start isEmailNew');
    return registeredUsers.find((user) => user.email === newEmail);
  }


  function checkData(formData, fieldNames) {
    console.log('start checkData');
    let currentFields = '';
    console.log(formData);
    for (const field of fieldNames) {
      if (!formData[field]) {
        currentFields += field + ', ';
      }
    }
    console.log('error fields: ', currentFields);
    if (currentFields) {
      currentFields = currentFields.slice(0, (currentFields.length - 1));
      throw new Error(errorFields + currentFields);
    }
    console.log('end checkData');

  }

}

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  let camposRequeridos = ["name", "lastname", "email", "password"];
  let errorMsg = "Faltan los siguientes campos: ";
  let FaltanCampos = false;

  camposRequeridos.forEach(campo => {
    if (!formData.hasOwnProperty(campo)) {
      FaltanCampos = true;
      errorMsg += campo + ", ";
    }
  });

  if (FaltanCampos) {
    throw new Error(errorMsg);
  }

  let usuarioRegistrado = registeredUsers.filter(user => user.email === formData.email);

  if (usuarioRegistrado.length > 0) {
    throw new Error("Email duplicado");
  }

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

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

}

My solution:
🟢
🟢
🟢
🟢
🟢
🟢
🟢
🟢
🟢

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  const fieldsForm = ['name', 'lastname', 'email', 'password'];
  const currentFieldsForm = Object.keys(formData);
  const missingFields = fieldsForm.filter(field => {
    return !(currentFieldsForm.includes(field))
  })

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

  const { email } = formData;
  const isEmailDuplicated = registeredUsers.some(user => user.email === email);
  if (isEmailDuplicated) {
    throw new Error(`El email esta duplicado`);
  }

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

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

}

Solución 😄

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

Callback hell usando async-await

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

  required.forEach((field) => {
    if (!formData.hasOwnProperty(field)) {
      missingFields.push(field);
    }
  });

  if (missingFields.length != 0) {
    throw new Error(
      "Faltan los siguientes campos requeridos: " + missingFields.join(", ")
    );
  }

  const isDuplicated = registeredUsers.some(
    (ele) => ele.email == formData.email
  );

  if (isDuplicated) {
    throw new Error("Email duplicado: " + formData.email);
  }
  delete formData.password;
  registeredUsers.push(formData);
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
}

Mi solución

function validateForm(formData, registeredUsers) {
  const requiereInputs = ['name', 'lastname', 'email', 'password']
  const missingInputs = []
  let haveAllInputs = true;
  requiereInputs.forEach(input => {
    if (formData.hasOwnProperty(input) === false) {
      haveAllInputs = false;
      missingInputs.push(input);
    }
  })
  if (haveAllInputs === false) {
    let errorMessage = `Faltan los siguientes campos: ${missingInputs.join(', ')}`;
    throw new Error(errorMessage);
  } 
 const isEmailRegistered = registeredUsers.some(user => user.email == formData.email);
 if(isEmailRegistered === true) {
  throw new Error(`El email ${formData.email} ya se encuentra registrado`);
 } else {
  delete formData.password;
  registeredUsers.push(formData);
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
 }
}

Mi solución:
👀
👀
👀
👀
👀
👀
👀

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

  const checked =
    Object.entries(formData).every((e) => e.length === 2) &&
    Object.keys(formData).length === 4;

  if (!checked) {
    const require = fields
      .map((field) => (Object.keys(formData).includes(field) ? "" : field))
      .filter((n) => n)
      .join(", ");
    throw new Error(`Faltan los siguientes campos requeridos: ${require}`);
  }

  if (registeredUsers.some((u) => u.email === formData.email)) {
    throw new Error(`Email ya existe: ${formData.email}`);
  }
    
  registeredUsers.push({
    name: formData.name,
    lastname: formData.lastname,
    email: formData.email
  })
  
  return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
}

Vamooooooooooossss que si se puedeeeeeee
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  const personaldates = ['name', 'lastname', 'email', 'password']
  if (personaldates.every(property => formData.hasOwnProperty(property))) {
    return true
  } else if (registeredUsers.find(user => user.email === formData.email)) {
    throw new Error (`El correo ${formData.email} ya esta registado`)
  }
  else {
    const missingFields = personaldates.filter(property => !formData.hasOwnProperty(property))
    throw new Error(`Faltan los siguientes campos: ${missingFields.join(', ')}`)
  }
  }

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  let errorMessage = "";
  if (formData.name === null) {
    errorMessage = errorMessage.concat("name, ");
  }
  if (formData.lastname === null) {
    errorMessage = errorMessage.concat("lastaname, ");
  }
  if (formData.email === null) {
    errorMessage = errorMessage.concat("email, ");
  }
  if (formData.password === null) {
    errorMessage = errorMessage.concat("password, ");
  }
  if (errorMessage) {
    errorMessage = errorMessage.substring(0, (errorMessage.length - 2));
    throw new Error("Faltan los siguientes campos: " + errorMessage);
  } else if (registeredUsers.find(user => user.email == formData.email)) {
    throw new Error(`Email duplicado: ${formData.email}`);
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email,
    });
    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
  }
}

Aquí les dejo mi solución, no utilice el método keys que vi en varias soluciones. Probablemente pude haber usado un for como vi en otras soluciones, pero no se me ocurrió en el momento.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
  let missingFields = "";

  if (!formData.name) missingFields += "name, ";
  if (!formData.lastname) missingFields += "lastname, ";
  if (!formData.email) missingFields += "email, ";
  if (!formData.password) missingFields += "password, ";

  if (missingFields.length > 1) {
    missingFields = missingFields.substring(0, missingFields.length - 2);
    throw new Error("Faltan los siguientes campos requeridos: " +
                     missingFields);
  }

  if (registeredUsers.find((user) => user.email === formData.email)) {
    throw new Error("El email ya se encuentra registrado");
  }

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

  let unExistentAtributes = "";
  const atributes = 
  ['name', 'lastname', 'email', 'password'];

  atributes.map(
    atribute => { 
        formData.hasOwnProperty(atribute) ? 
        unExistentAtributes : 
        unExistentAtributes += atribute; 
    }
  );

  if (unExistentAtributes !== "") {
    throw new Error(
      `Faltan los siguientes campos: 
      ${unExistentAtributes}`
    );
  };

  const existEmailInRegisteredUsers = 
    registeredUsers.findIndex(
        user => user.email === formData.email
    );

  if (registeredUsers.length !== 0 && 
      existEmailInRegisteredUsers !== -1) {
    throw new Error(
      `El email : ${unExistentAtributes} 
       esta duplicado`
    );
  } else {
    registeredUsers.push(
      { "name": formData.name, 
        "lastname": formData.lastname, 
        "email": formData.email }
    );

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

}

Mi solución donde se verifica tanto que no este vació como que exista cada dato:

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

  if (!name)
    missing.push("name")
  if (!lastname)
    missing.push("lastname")
  if (!email)
    missing.push("email")
  if (!password)
    missing.push("password")

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

  if (registeredUsers.find((user) => user.email === email) !== undefined) 
    throw new Error(`El email '${email}' ya está en uso`);

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

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

.
.
.
.
.
.

export function validateForm(formData, registeredUsers) {
    const requiredData = ['name', 'lastname', 'email', 'password'];
    if (!requiredData.every((data) => formData[data])) {
        throw new Error(`Faltan los siguientes campos: 
        ${requiredData.filter((data) => !formData[data]).join(', ')}`);
    } else if (registeredUsers.some(user => user.email === formData.email)) {
        throw new Error (`El usuario con el email asociado ${formData.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 solución:

const REQUIRED_FIELDS = ['name', 'lastname', 'email', 'password'];

export function validateForm(formData, registeredUsers) {
  const missingFields = REQUIRED_FIELDS.filter((fieldName) => !formData.hasOwnProperty(fieldName) || !formData[fieldName]);

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

  const alreadyRegisteredEmail = registeredUsers.some((registeredUser) => formData.email === registeredUser.email);

  if (alreadyRegisteredEmail) {
    throw new Error(formData.email);
  }

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

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

export function validateForm(formData, registeredUsers) {
  const necessaryData = [formData].every(function (e) {
    return e.hasOwnProperty('name') && e.hasOwnProperty('lastname') && e.hasOwnProperty('email') && e.hasOwnProperty('password');
  });
  if (necessaryData) {
    const result = registeredUsers.find(user => { return user.email === formData.email })
    if (result) {
      throw new Error("Este email ya existe.");
    } else {
      const newUser = {
        name: formData.name,
        lastname: formData.lastname,
        email: formData.email
      }
      registeredUsers.push(newUser)
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`
    }
  } else {
    throw new Error("Faltan los siguientes campos: name, email, etc...");
  }
}

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

export function validateForm(formData, registeredUsers) {
  //let contieneData = [formData];
  let haveName = formData.hasOwnProperty('name');
  let haveLastname = formData.hasOwnProperty('lastname');
  let haveEmail = formData.hasOwnProperty('email');
  let havePas = formData.hasOwnProperty('password');
  let todos = haveEmail && haveName && haveLastname && havePas /*&& !(formData.name == "" || formData.email == "" || formData.lastname || "" && formData.password == "")*/;
  if (!todos) {
    let mensaje = "Faltan los siguientes campos:";
    let control = 0;
    if (!haveName || formData.name=="") {
      mensaje += " name";
      control++;
    }
    if (!haveEmail || formData.email == "") {
      if (control > 0) {
        mensaje += ","
      }
      mensaje += " email";
      control++;
    }
    if (!haveLastname || formData.lastname == "") {
      if (control > 0) {
        mensaje += ","
      }
      mensaje += " lastname";
      control++;
    }
    if (!havePas || formData.password == "") {
      if (control > 0) {
        mensaje += ","
      }
      mensaje += " password";
    }
    throw new Error(mensaje);
  } else {
    let objetoRepe;
    objetoRepe = registeredUsers.find(element => element.email == formData.email);
    if (objetoRepe != undefined) {
      throw new Error(`El email ${formData.email} ya existe`)
    } else {
      let newObject = {
        name: formData.name,
        lastname: formData.lastname,
        email: formData.email
      };
      registeredUsers.push(newObject);
      return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
    }
  }
}

Solución
*
*
*
*
*
*
*
*
*

export function validateForm(formData, registeredUsers) {

  // Verificar campos requeridos
  const requireFields = ["name", "lastname", "email", "password"];
  const missingFields = requireFields.filter(field => !formData[field]);
  if (missingFields.length > 0) {
    throw new Error(`Faltan los siguientes campos: ${missingFields.join(', ')}`);
  }

  // Verificar si el email ya está en uso
  const emailExists = registeredUsers.some(user => user.email === formData.email);
  if (emailExists) {
    throw new Error('El email ingresado ya está en uso');
  }

  // Agregar usuario a la lista de usuarios
  const newUser = { ...formData };
  delete newUser.password;
  registeredUsers.push(newUser);

  // Retornar mensaje de éxito
  return `El registro fue exitoso. Bienvenido/a ${formData.name} ${formData.lastname}!`;
} 

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

Mi solución al reto:

export function validateForm(formData, registeredUsers) {
    let missingFields = [];
    const requiredData = ["name", "lastname", "email", "password"]
    let registeredEmails = registeredUsers.map((user) => user.email);
  
    missingFields = requiredData.filter(x => !Object.keys(formData).includes(x))
  
    // agregar a usuarios registrados
    if (missingFields.length > 0) throw new Error("Faltan los siguientes campos requeridos: " + missingFields.join(' '))
  
    if (registeredUsers.find((user) => user.email === formData.email)) {
      throw new Error(`El usuario ya se encuentra registrado ${formData.email}`)
    }
  
    registeredUsers.push({ name: formData.name, lastname: formData.lastname, email: formData.email },)
    registeredEmails.push(formData.email);
  
    return `Tu registro fue exitoso ${formData.name} ${formData.lastname}`;
  }

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

  if (formData.name && formData.lastname && formData.email && formData.password) {
    console.log(`Tu registro fue exitoso ${formData.name} ${formData.lastname}`)
  } else {

    const campos = new Array()

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

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

  // Verificar si el correo ya existe
  const result = registeredUsers.find(user => user.email == formData.email)
  if (result) {
    console.log("El correo está duplicado")
  } else {
    registeredUsers.push({
      name: formData.name,
      lastname: formData.lastname,
      email: formData.email
    })
  }

  console.log(registeredUsers)
}

const formData = {
  name: "Juan",
  lastname: "Perez",
  email: "[email protected]",
  password: "123456"
}

const registeredUsers = [
  { name: "Pedro", lastname: "Gomez", email: "[email protected]" },
  { name: "Maria", lastname: "Garcia", email: "[email protected]" },
]

validateForm(formData, registeredUsers)

Mi solución
🐱
🐱
🐱
🐱
🐱
🐱
🐱
🐱
🐱
🐱
🐱

export function validateForm(formData, registeredUsers) {
  // formData: El usuario que se registra
  // registeredUsers: Todos los usuarios registrados actualmente

  //TAREAS
  //-1. Verificar que todos los campos requeridos del formulario esten completos, throw new Error("Faltan los siguientes campos: name, email, etc...");
  //-2. verificar si el email ya existe (Especificar el email duplicado en el error)
  //3. Registrar al usuario (Tu registro fue exitoso "name lastname")

  const necesaryData = ['name', 'lastname', 'email', 'password'];

  const missingData = necesaryData.filter(prop => !Object.keys(formData).includes(prop));
  console.log(missingData);

  if (missingData != 0) {
    throw new Error(`Faltan los siguientes campos: ${missingData.join(', ')}`)
  }

  const { name, lastname, email, password } = formData


  const registeredEmails = registeredUsers.map(user => user.email);
  const isEmailRegistered = registeredEmails.includes(formData.email);
  console.log(isEmailRegistered);
  if (isEmailRegistered) {
    throw new Error(`Email ya existe: ${formData.email}`)
  }

  const newUser = {
    name: name,
    lastname: lastname,
    email: email,
  }

  registeredUsers.push(newUser);
  return (`Tu registro fu exitoso ${formData.name} ${formData.lastname}`)
}

me resulto un poco larga la solución:

export function validateForm(formData, registeredUsers) {
    // Tú código aquí 👈
    let vacios=[]
    for (const [key, value] of Object.entries(formData)) {
        if (value=='') vacios.push(key)
      }
    let a = Object.keys(formData)
    let b = ["name", "lastname", "email", "password"];
    let faltan = b.filter((x) => !a.includes(x))
    const duplicado = registeredUsers.find((valor) => valor.email == formData.email)
    if (vacios.length==0){ 
    if (duplicado)
      throw new Error(`Email duplicado:${duplicado.email}`)
    delete formData.password
    registeredUsers.push(formData)
    return `El registro fue exitoso ${formData.name} ${formData.lastname}`
    }
    else 
    if (faltan.length)
      throw new Error(`Faltan los siguientes campos:${faltan}`)
      else 
      throw new Error(`Faltan llenar los siguientes campos:${vacios}`)
}

export const validateForm = (formData, registeredUsers) => { 
  let data = {
    name: null,
    lastname: null,
    email: null,
    password: null,
    ...formData
  }

  if (Object.values(data).find(value => value === null) !== null) {
    if (registeredUsers.find(user => user.email === data.email)) {
      throw new Error(`El email ${user.email} ya existe`);
    } else { 
      delete data.password;
      registeredUsers.push(data);
      return `Tu registro fue exitoso ${data.name} ${data.lastname}`;
    }
  } else { 
    throw new Error('Faltan los siguientes campos: name, email, etc...');
  }
}

🛡️ Escudo Anti-Spoilers 🛡️
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function validateForm(formData, registeredUsers) {
  // Tú código aquí 👈
  if (
    !formData.hasOwnProperty("name") ||
    !formData.hasOwnProperty("lastname") ||
    !formData.hasOwnProperty("email") ||
    !formData.hasOwnProperty("password")
  ) {
    throw new Error("Faltan los siguientes campos: name, email, etc...");
  }

  const { name, lastname, email } = formData;

  if (registeredUsers.some((register) => register.email === email))
    throw new Error("Email duplicado");

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

Hola comparto la solución al problema.

👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍
👍

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

  const isExist = (user) => user.email === formData.email;

  if (registeredUsers.find(isExist)) {
    throw new Error("El usuario ya existe");
  }

  delete formData.password;
  registeredUsers.push(formData);

  let { name, lastname } = formData;
  return `Tu registro fue exitoso ${name} ${lastname}`;
}

Hola people les comparto mi solución un poco loca:

  // Tú código aquí 👈
  let existeEmail = registeredUsers.find(e => {
    return e.email === `${formData.email}`
  })
  let subFormData = [];
  subFormData.push(formData);
  //console.log(subFormData)


  let name = subFormData.every(e => {
    return e.hasOwnProperty("name");
  })
  let email = subFormData.every(e => {
    return e.hasOwnProperty("email");
  })
  let lastname = subFormData.every(e => {
    return e.hasOwnProperty("lastname");
  })
  let password = subFormData.every(e => {
    return e.hasOwnProperty("password");
  })


  let arraySiExiste = [];
  arraySiExiste.push(name, email, lastname, password);
  let todoOk = arraySiExiste.every(e => {
    return e === true;
  })

  delete subFormData[0]["password"];
  //console.log(subFormData)
  if (todoOk == true) {
    if (existeEmail == undefined) {
      registeredUsers.push(subFormData[0]);
      return `Tu usuario fue creado correctamente ${formData.name} ${formData.lastname}`;
    } else {
      return "Ya existe ese correo en base de datos!";
    }

  } else {
    throw new Error("Faltan los siguientes campos: name, email, etc...");
  }


} ```

Mi aporte:

SPOILER

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function validateForm(formData, registeredUsers) {
const { name, lastname, email, password } = formData;
let auxErr = false;
let err = "Faltan los siguientes campos: "
if (name && lastname && email && password) {
const isDuplicated = registeredUsers.find(element => element.email === email)
if (isDuplicated) {
throw new Error(email);
}
else {
const resp = {name: name, lastname: lastname, email: email}
registeredUsers.push(resp)
return "Registro fue exitoso " + name + " " + lastname;
}
}
if (!name) {
auxErr = true;
err += "name "
}
if (!lastname) {
auxErr = true;
err += “lastname”
}
if (!email) {
auxErr = true;
err += "email "
}
if (!password) {
auxErr = true;
err = “password”
}
if (auxErr) {
throw new Error(auxErr)
}
}

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

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}`;
};>