Sprawdź, czy wartość obiektu istnieje w tablicy obiektów JavaScript, a jeśli nie, dodaj nowy obiekt do tablicy

Sprawdzenie istniejącej nazwy użytkownika jest raczej trywialne:

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

Ale nie jest takie oczywiste, co zrobić, gdy musisz dodać nowego użytkownika do tej tablicy. Najłatwiejsze wyjście - wystarczy popchnąć nowy element z idrównymi 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

Zagwarantuje to unikalność identyfikatorów, ale sprawi, że tablica będzie wyglądać nieco dziwnie, jeśli niektóre elementy zostaną zdjęte z jej końca.

Ten mały fragment działa dla mnie.

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

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

console.log(arrayOfObject.some(checkUsername))

Myślę, że to najkrótszy sposób rozwiązania tego problemu. Tutaj użyłem funkcji strzałek ES6 z .filter, aby sprawdzić istnienie nowo dodanej nazwy użytkownika.

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

Link do Fiddle

To, co zrobiłem, oprócz @ Sagar-gavhane „s odpowiedź

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)

Zaakceptowaną odpowiedź można również zapisać w następujący sposób używając funkcji strzałek na .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 }); }
 }

Oto łańcuch metod ES6 wykorzystujący .map()i .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. Mapuj istniejących użytkowników, aby utworzyć tablicę ciągów nazw użytkowników.
2. Sprawdź, czy ta tablica nazw użytkowników zawiera nową nazwę użytkownika
3. Jeśli go nie ma, dodaj nowego użytkownika

Podoba mi się odpowiedź Andy'ego, ale identyfikator niekoniecznie będzie unikalny, więc oto, co wymyśliłem, aby utworzyć unikalny identyfikator. Można też sprawdzić na jsfiddle . Należy pamiętać, że arr.length + 1może to nie zagwarantować unikalnego identyfikatora, jeśli coś zostało wcześniej usunięte.

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

Możesz prototypować swoją tablicę, aby była bardziej modularna, spróbuj czegoś takiego

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

Możesz go używać jako:

 yourArray.hasElement(yourArrayElement)

Z jakiegoś powodu wypróbowałem powyższe kroki, wydaje się, że nie działają one dla mnie, ale to było moje ostateczne rozwiązanie mojego własnego problemu, może być pomocne dla każdego, kto to przeczytał:

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

tutaj post.likes to tablica użytkowników, którzy polubili post.

Spróbuj tego

pierwsza metoda przy użyciu niektórych plików

  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)

druga metoda wykorzystująca include, 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)