Playground: Encuentra el ID

Comparto mi solución:

export function solution(users, id) {
  const user = users.find(user => user.id == id)
  return user?.name || false
}

Yo ahorita

ALERTA DE SPOILERS…Platzilike para que se posicione como primer comentario.

Mi solución:

export function solution(users, id) {
  function encontrarPorID(element) {
    return element.id == id
  }
  const usuario = users.find(encontrarPorID);
  if (usuario) {
    return usuario.name;
  } else { 
    return false;
  }
}

Así de fácil es, pero lo logre después de más de 20 intentos

export function solution(users, id) {

  const encontrarUsuario = users.find(buscarUsuario);

  function buscarUsuario(usuario) {
    return usuario.id == id;
  }

  if (encontrarUsuario) {
    return encontrarUsuario.name;
  } else {
    return false;
  }
}

Esta es mi solución, me pareció más útil usar el find, ya que considero que no deberían haber ids repetidos.

// Función que evaluará cada uno de los elementos comprobando que el parámetro id sea igual al valor de la llave del elemento que se evalua.

function comprobarExistencia(usuarioID) {
    return usuarioID.id == id;
  }
// Guardamos en una variable el resultado obtenido por el método find y pasamos como argumento la función que evaluará los elementos.
  var usuarioEncontrado = users.find(comprobarExistencia);
// Realizamos un condicional que devolverá el valor de la llave name del elemento encontrado en caso de ser verdadero o false en caso de no encontrar nada.
  if (usuarioEncontrado) {
    return usuarioEncontrado.name;
  } else {
    return false;

Este código me ayudo a entender la solución!

export function solution(users, id) {
  // Tu código aquí 👈
  
  const user = users.find(user => user.id === id)
    return user?.name || false
}

Comparta mi solución:

export function solution(users, id) {
  let usuario = users.find((item) =>  item.id == id )
  if (usuario) {
    return usuario.name
  } else {
    return false
  }
}

export function solution(users, id) {
  // Tu código aquí 👈

  const user = users.find((user) => user.id === id);

  if (user) {
    return user.name;
  } else {
    return false;
  }
}

const users = [];
users.push({ id: 123, name: 'Juanito Alcachofa' });
users.push({ id: 456, name: 'Juanita Alcaparra' });

solution(users, 456);
solution(users, 999);

Mi solución

export function solution(users, id) {
  const searchUser = users.find(user => user.id == id);
  return searchUser?.name || false;
// Tu cód

Me encanta lque los cursos de platzi tengan playgrounds

export function solution(users, id) {
  const user = users.find(user => user.id == id);
    
  if (user) {
    const name = user.name;
      return name;
    } else {
      return false;
    } 
}

Mi solucion

export function solution(users, id) {
  const user = users.find(item => item.id == id)
  return user?.name || false
}

export function solution(users, id) {

  return users.find(user => user.id === id)?.name || false
}

mi solución

Comparto mi solución

export function solution(users, id) {
  let findUser = users.find(function (user) {
    return user.id == id;
  })

  if (!findUser) {
    return false;
  } else {
    return findUser.name;
  }
}

Mi solucion es esta

export function solution(users, id) {
  let isIdInArray = users.find(element => element.id == id);

  if (isIdInArray) {
    return isIdInArray.name
  } else {
    return false
  }
}

mi Solución :

export function solution(users, id) {
  const result = users.find(user => user.id === id);
  if (result === undefined) {
    return false;
  } else {
    return result.name;
  }
}

Comparto mi solución

Costo pero encontré la solución con el método Find(), esta es mi solución:

export function solution(users, id) {
  const find = users.find(e => e.id === id)

  if (!find) {
    return false
  } else {
    return find.name
  }
}

Este codigo me ayudo a entender la solucion!

export function solution(users, id) {
  // Buscar Id 👈
  function busquedaId(e) {
    return e.id === id
  } 
  let usuario = users.find(busquedaId);
  if (usuario) {
    return usuario.name;
  } else {
    return false;
  }
}

Mi solución:

export function solution(users, id) {
  let user = users.find(user => user.id === id);
  if (user) {
    return user.name
  }
  else 
  return false
}

export function solution(users, id) {
  return users.filter(user => user.id === id).map(user => user.name)[0] || false;
}

function solution(users, id) {
 let result= users.find(function usuario(user){
  return user.id == id;

  })

  if (result){
    return result.name;
  }else{
    return false;
  }
  
}

Mi solución

export function solution(users, id) {
    const usuarioID = users.find(usuario => usuario.id == id);
  
    if (usuarioID) {
      return usuarioID.name;
    } else {
      return false;
    }
  }
  

Doy mi aporte por si alguien busca.

<export function solution(users, id) {
  // Tu código aquí 👈
  let objetivo = users.find(encontrar);
  function encontrar(variable) { 
    return variable.id == id;
  }
  if (objetivo) {
    return objetivo.name;
  } else { 
    return false;
  }

}> 

Como yo lo resolví

export function solution(users, id) {
  const user = users.find((u) => u.id === id)
  return user === undefined ? false : user.name
}

!

)

export function solution(users, id) {
  function buscarUserId(user) {
    return user.id == id;
  }

  const usuario = users.find(buscarUserId);
  if (usuario) {
    return usuario.name;
  } else {
    return false
  }
}

Al Primer Intento!!! El profe explica bien o yo estoy practicando mucho

Reto logrado!! 😀💪💻🚀💚

JS

export function solution(users, id) {
  function isIdInArray(arrayElement) {
    return arrayElement.id == id;
  }

  const idInArray = users.find(isIdInArray);

  if (idInArray) {
    return idInArray.name;
  } else {
    return false;
  }
}

Trate de hacerlo con 2 lineas de codigo pero no se me ocurrio como 😅

SOLUCION:

export function solution(users, id) {
  let user = users.find((user) => user.id === id);
  if (!user) return false;
  return user.name;
}

Hola, aquí esta mi solución:

export function solution(users, id) {

  let is_user_in_db = false;

  let user = users.find(function (user) {

    if (user.id == id) {

      is_user_in_db = true;
      return user;
      
    }

  });

  if (is_user_in_db) {

    return user.name;

  } else {
    
    return false;
    
  }

}

Dado que el id debería ser único use el método find para encontrar la primera (y en teoría única) coincidencia 😁. Aquí les dejo mi solución, espero le sirva a quien tenga alguna duda.

export function solution(users, id) {
  const user = users.find(user => user.id === id);
  if (user) {
    return user.name;
  } else {
    return false;
  }
}

Esta fue mi solución, intentalo con mas esfuerzo, si al final no pudiste has esto

Mi respuesta:

export function solution(users, id) {
  return users.find(user => user.id === id)?.name || false
}

Aca mi solucion

export function solution(users, id) {
  // Tu código aquí 👈
  for (let i = 0; i < users.length; i++) {
    if (users[i].id === id) {
      return users[i].name;
    }
  }
  return false;
}

export function solution(users, id) {
  // Tu código aquí 👈
  function findId(user) {
    return user.id == id;
  }

  const IsJuanitaInTheArray = users.find(findId)

  if (IsJuanitaInTheArray) {
  return IsJuanitaInTheArray.name
  } else {
  return false
}
}

solucion al reto

export function solution(users, id) {
  // Tu código aquí 👈
  const findUser = users.find(function (user) {
    return user.id == id
  })

  if (findUser) {
     return findUser.name
  } else {
     return false
   }

}

Solución 😄…
.

.
.
.
.

export function solution(users, id) {
  const user = users.find(user => user.id === id);
  return user ? user.name : false;
}

Comparto mi solución,

export function solution(users, id) {
  const usuario = users.find(data => data.id == id);
  return usuario ? usuario.name : false
};

Mi solución

export function solution(users, id) {
  // Tu código aquí 👈
  const user = users.find(us => us.id == id)

  if (user == undefined) {
    return false
  } else {
    return user.name
  }
}

Veo que todos utilizaron “find” o al menos los que llegue a leer…
Use fitler, y este me devolvia un array, eso me complico un poco a la hora del return false, pero, me decidi por si era un array vacio, era false, y listo.

function solution(users, id){
    let found = users.filter((element)=>{
        return element.id == id;
          
    });
    
    if(found.length==0){
        return false;
    }else{
        return found[0].name;
    }
        
    
}```

Esta fue mi solución.

export function solution(users, id) {
  // Tu código aquí 👈
  const usersInArray = users.find(function (element) {
    return element.id == id;
  });

  if (usersInArray) {
    return usersInArray.name;
  }
  else {
    return false;
  }
}

export function solution(users, id) {
  const u = users.find((us) => us.id == id)
  return u?.name || false
}

function solution(users, id) {
  const a = users.find(b => b.id == id);

  if (a) {
    return a.name;
  } else {
    return false;
  }
}

mi solución:

  function idUser(ususario) {
    return ususario.id == id
  }

  let usuario = users.find(idUser);
  return usuario ? usuario.name : false

Comparto mi solucion usando “for()”, mi intencion fue hacer una funcion facil de leer y de interpretar:

export function solution(users, id) {
  for (let i = 0; i < users.length; i++) {
    console.log(users[i]);
    if (users[i].id == id) {
      return users[i].name;
    }
  }
  return false;
}

No entendi muy bien como resolver el ejercicio aquí, termine haciendolo como la clase anterior, con el html y sus inputs.

Esta fue mi solución

<export function solution(users, id) {
  const elegido = users.find(user => user.id === id)
  return elegido ? elegido.name : false 
}> 

mi solución

const users = [];
users.push({ id: 123, name: ‘Juanito Alcachofa’ });
users.push({ id: 456, name: ‘Juanita Alcaparra’ });

function encuentraUsuario(array, idUsuario) {
/* ASI FUNCIONA CON FUNCION FLECHA

    let usuarioEncontrado = array.find(itemInArray => itemInArray.id == idUsuario)
    if (usuarioEncontrado){
        console.log (usuarioEncontrado.name);
    }else{
        console.log ("usuario no encontrado")}

}
*/

// CON FUNCION FIND LAMANDO A OTRA FUNCION 

function itemInArray(indice) {
    
    if (indice.id == idUsuario) {
        return true;
    };
}
let usuarioEncontrado = array.find(itemInArray);


if (usuarioEncontrado) {
    console.log(usuarioEncontrado.name);
} else {
    console.log("usuario no encontrado")
}

}

encuentraUsuario(users, 456)
encuentraUsuario(users, 999)

export function solution(users, id) {
  const user = users.find(user => user.id === id)

  return typeof user === 'undefined'
    ? false
    : user.name
}

asi lo resolvi yo:

export function solution(users, id) {

  function IsUserID(userID) {
    return userID.id == id;
  }

  const userName = users.find(IsUserID);

  if (userName) {
    return userName.name;
  } else {
    return false;
  }
}

Comparto mi solución:

export function solution(users, id) {
  function isUsersInArray(element) {
    return element.id == id;
  }
  const userInArray = users.filter(isUsersInArray);

  if (userInArray.length > 0) {
    return userInArray[0].name;
  } else { 
    return false
  }

}

Mi solución, aunque no corrio.
export function solution(users, id) { users.find(element => { if (element.id == id) { console.log(element.name); } else { console.log(false); } }); }

Muy largo

Pero me funciono, le voy a dar una leída a sus soluciones. Se ven muy interesantes.

export function solution(users, id) {
  let trueOrFalse;
  let result;
  users.forEach(element => {
    trueOrFalse = element.id == id;
    if (trueOrFalse) {
      result = element.name
    } else {
      return
    }
  });
  if (trueOrFalse) {
    return result
  } else {
    return false
  }
}

Mis errores eran que retornaba users, cuando era usuario la variable que habia creado jaja xD

export function solution(users, id) {
  // Tu código aquí 👈
  const usuario = users.find((x)=> x.id==id)
  if (usuario) {
    return usuario.name
   }
  else {return false}
}

Yo lo hice asi…

export function solution(users, id) {
  for (let i = 0; i < users.length; i++) {
    const actualUser = (users[i]);
    if (id == actualUser.id) {
      return actualUser.name;
    }
  }
  return false;
}

A ver si logré resolverlo

export function solution(users, id) {
  const persona = users.find(elemento => elemento.id == id)
  if (persona) { return persona.name }
  else {return false}
}

Pero, estoy un poco confundido con la parte de

users.find(elemento => elemento.id == id)

¿Cómo se supone que funciona lo del interior del parentesis? Le estoy preguntando a una IA por ahora xd

Comparto mi solución al ejercicio:

export function solution(users, id) {

  let name;

  function isIdInArray(IdElement) {
    return IdElement.id == id;
  }
  const IdInArray = users.find(isIdInArray);

  if (IdInArray) {
    return name = IdInArray.name
  } else { 
    return false;
  }

}

Pos dejo mi solución 3:

export function solution(users, id) {
  const userFound = users.find((user) => user.id === id)
  return userFound ? userFound.name : false
}

export function solution(users, id) {
  const showUser = users.find(show => show.id == id);
  if (showUser) {
    return showUser.name;  
  } else {
    return false;
  }
}

Comparto mi solución

export function solution(users, id) {
  const validation = users.find(function (obj) {
    return obj.id == id;
  });
  if (validation)
    return validation.name;
  else
    return false;
  }

Mi solución:

acá dejo mi solución.
.
.
…
…

.
.
.
.
.
.
.
…

…
.
.
.
.
.
.

export function solution(users, id) {
  // Tu código aquí 👈
  const nuevo = users.find(user => user.id == id)
  if(!nuevo){
    return false
  }
  return nuevo.name
}

Use el operador ternario 😃

export function solution(users, id) {
  const usuario = users.find((e) => { return e.id == id })
    return (usuario ? usuario.name : false) 
}

Mi solucion:

export function solution(users, id) {
  // Tu código aquí 👈
  const result = users.find(user => user.id == id);
  return result?.name || false
}

Gracias al profe gndx por el curso de asincronismo y por el de ecmascript jajajajajaj

export function solution(users, id) {
  // Tu código aquí 👈

  function findUserById(user) {
    return user.id == id;
  }

  const findById = users.find(findUserById);

  return findById ? findById.name : false;
}

export function solution(users, id) {
  // Tu código aquí 👈

  function findUserById(user) {
    return user.id == id;
  }

  const findById = users.find(findUserById);

  if (!findById) {
    return false;
  } else {
    return findById.name;
}
}

Mi solución

export function solution(users, id) {
  
  const userID = users.find(user => user.id == id);

  return userID ? userID.name : false; 
}

Me mareé un poco pero salió

export function solution(users, id) {
  function buscarId(usuario) {
    return usuario.id == id
  }

  const idUsuario = users.find(buscarId);

  if (idUsuario) {
    return idUsuario.name;
  } else {
    return false;
  }
}

Mi aportación, por si os sirve de algo (aunque luego bicheando los comentarios, es verdad que podemos usar un ternario y escribir aún menos jeje)

export function solution(users, id) {
  const foundUserID = users.find((user) => user.id === id);
  let foundUserName;
  if (foundUserID) {
    foundUserName = foundUserID.name;
    return foundUserName;
  } else {
    return false;
  }
}

Mi solución:

export function solution(users, id) {
  const usuarioEncontrado = users.find(function (user) { return user.id == id });
  return (usuarioEncontrado) ? usuarioEncontrado.name : false;
}

Mi código

export function solution(users, id) {
  const userValidID = users.find(element => element.id == id);

  if (userValidID) {
    return userValidID.name;
  } else {
    return false
  }
}

Entre menos codigo para mi mejor jaja

export function solution(users, id) {
    const user = users.find(user => user.id == id);
    if (user){
        return user.name;
    }else{
        return false;
    }
}

Mi solucion

function solution(users, id) {
  // Tu código aquí 👈

  const resultUser = users.find(({ id: idUser }) => idUser == id)
  return resultUser ? resultUser.name : false 
}

export function solution(users, id) {
  let user = users.find((element) => element.id == id);
  return user ? user.name : false;
  }

export function solution(users, id) {
  const user = users.find(({ id: userId }) => userId === id);
  return user ? user.name : false;
}

Comparto mi solución, si no puedes te recomiendo seguir intentando, no veas la solución, VAMOS QUE TU PUEDES  🙌🏾🙌🏾🙌🏾🙌🏾🙌🏾
.
.
.
.
.
.
.
.

export function solution(users, id) {
  let user = users.find((user) => user.id === id);
  return user ? user.name : false;
}

gg

export function solution(users, id) {
  let userFilter = users.find(function (user) {
    return user.id == id;
  });
  if (!userFilter) {
    return false;
  }
  return userFilter.name; 
}

mi solucion

export function solution(users, id) {
  let extraerDatos = users.find((n) => {
    return n.id == id;
  })
  if (extraerDatos != undefined) {
    return extraerDatos.name;
  }
  return false
}

Mi solucion 😀

export function solution(users, id) {
  const obj = users.find(item => item.id === id)
  if (obj) {return obj.name}
  else{ return false} 
}

export function solution(users, id) {
  const userMatching = users.find(userId => {
    return userId.id === id
  })
  if (!userMatching) return false
  {
    return userMatching.name
  }
}

export function solution(users, id) {
  function isIdValid(idElement){
    return idElement.id == id
  }

  const userId = users.find(isIdValid);

  if (!userId) {
    return false;
  } else {
    return userId.name;
  }
}

No me salió. Lo quise hacer con un for, y solo me muestra el primer elemento 😦