Vérifiez si la valeur de l'objet existe dans un tableau d'objets Javascript et sinon ajoutez un nouvel objet au tableau

Il est assez simple de vérifier le nom d'utilisateur existant:

var arr = [{ id: 1, username: 'fred' }, 
  { id: 2, username: 'bill'}, 
  { id: 3, username: 'ted' }];

function userExists(username) {
  return arr.some(function(el) {
    return el.username === username;
  }); 
}

console.log(userExists('fred')); // true
console.log(userExists('bred')); // false

Mais ce n'est pas si évident que faire lorsque vous devez ajouter un nouvel utilisateur à ce tableau. La solution la plus simple - il suffit de pousser un nouvel élément idégal à array.length + 1:

function addUser(username) {
  if (userExists(username)) {
    return false; 
  }
  arr.push({ id: arr.length + 1, username: username });
  return true;
}

addUser('fred'); // false
addUser('bred'); // true, user `bred` added

Cela garantira l'unicité des ID, mais rendra ce tableau un peu étrange si certains éléments sont retirés de sa fin.

Ce petit extrait fonctionne pour moi.

const arrayOfObject = [{ id: 1, name: 'john' }, {id: 2, name: 'max'}];

const checkUsername = obj => obj.name === 'max';

console.log(arrayOfObject.some(checkUsername))

Je pense que c'est le moyen le plus court de résoudre ce problème. Ici, j'ai utilisé la fonction de flèche ES6 avec .filter pour vérifier l'existence d'un nom d'utilisateur nouvellement ajouté.

var arr = [{
    id: 1,
    username: 'fred'
}, {
    id: 2,
    username: 'bill'
}, {
    id: 3,
    username: 'ted'
}];

function add(name) {
    var id = arr.length + 1;        
            if (arr.filter(item=> item.username == name).length == 0){
            arr.push({ id: id, username: name });
        }
}

add('ted');
console.log(arr);

Lien vers Fiddle

C'est ce que j'ai fait en plus de la réponse de @ sagar-gavhane

const newUser = {_id: 4, name: 'Adam'}
const users = [{_id: 1, name: 'Fred'}, {_id: 2, name: 'Ted'}, {_id: 3, 'Bill'}]

const userExists = users.some(user => user.name = newUser.name);
if(userExists) {
    return new Error({error:'User exists'})
}
users.push(newUser)

La réponse acceptée peut également être écrite de la manière suivante en utilisant la fonction de flèche sur .some

 function checkAndAdd(name) {
     var id = arr.length + 1;
     var found = arr.some((el) => {
           return el.username === name;
     });
     if (!found) { arr.push({ id: id, username: name }); }
 }

Voici une chaîne de méthodes ES6 utilisant .map()et .includes():

const arr = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]

const checkForUser = (newUsername) => {
      arr.map(user => {
        return user.username
      }).includes(newUsername)
    }

if (!checkForUser('fred')){
  // add fred
}

1. Mappez sur les utilisateurs existants pour créer un tableau de chaînes de nom d'utilisateur.
2. Vérifiez si ce tableau de noms d'utilisateur inclut le nouveau nom d'utilisateur
3. S'il n'est pas présent, ajoutez le nouvel utilisateur

J'aime la réponse d'Andy, mais l'identifiant ne sera pas nécessairement unique, alors voici ce que j'ai proposé pour créer un identifiant unique également. Peut également être vérifié sur jsfiddle . Veuillez noter que cela arr.length + 1peut très bien ne pas garantir un identifiant unique si quelque chose avait été supprimé précédemment.

var array = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' } ];
var usedname = 'bill';
var newname = 'sam';

// don't add used name
console.log('before usedname: ' + JSON.stringify(array));
tryAdd(usedname, array);
console.log('before newname: ' + JSON.stringify(array));
tryAdd(newname, array);
console.log('after newname: ' + JSON.stringify(array));

function tryAdd(name, array) {
    var found = false;
    var i = 0;
    var maxId = 1;
    for (i in array) {
        // Check max id
        if (maxId <= array[i].id)
            maxId = array[i].id + 1;

        // Don't need to add if we find it
        if (array[i].username === name)
            found = true;
    }

    if (!found)
        array[++i] = { id: maxId, username: name };
}

Vous pouvez prototyper votre baie pour la rendre plus modulaire, essayez quelque chose comme ça

    Array.prototype.hasElement = function(element) {
        var i;
        for (i = 0; i < this.length; i++) {
            if (this[i] === element) {
                return i; //Returns element position, so it exists
            }
        }

        return -1; //The element isn't in your array
    };

Et vous pouvez l'utiliser comme:

 yourArray.hasElement(yourArrayElement)

J'ai essayé les étapes ci-dessus pour une raison quelconque, cela ne semble pas fonctionner pour moi, mais c'était ma solution finale à mon propre problème, peut-être utile à quiconque lit ceci:

let pst = post.likes.some( (like) => {  //console.log(like.user, req.user.id);
                                     if(like.user.toString() === req.user.id.toString()){
                                         return true
                                     } } )

ici post.likes est un tableau d'utilisateurs qui ont aimé un message.

essaye ça

première méthode utilisant certains

  let arr = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
    let found = arr.some(ele => ele.username === 'bill');
    console.log(found)

deuxième méthode utilisant inclut, map

   let arr = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
    let mapped = arr.map(ele => ele.username);
    let found = mapped.includes('bill');
    console.log(found)