Prüfen Sie, ob der Objektwert in einem Javascript-Array von Objekten vorhanden ist, und fügen Sie dem Array ein neues Objekt hinzu

Es ist ziemlich trivial, nach vorhandenen Benutzernamen zu suchen:

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

Es ist jedoch nicht so offensichtlich, was zu tun ist, wenn Sie diesem Array einen neuen Benutzer hinzufügen müssen. Der einfachste Weg nach draußen - einfach ein neues Element mit id gleich array.length + 1 schieben:

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

Es garantiert die Eindeutigkeit der IDs, macht dieses Array jedoch etwas seltsam, wenn einige Elemente vom Ende genommen werden.

Diese kleinen Schnipsel funktionieren für mich ..

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

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

console.log(arrayOfObject.some(checkUsername))

Die Best Practice ist so.

var arr = ["a","b","c","d"];
console.log(arr.includes("a")); //---- true;
console.log(arr.includes("k")); //---- false;
console.log(arr.includes("c")); //---- true;

Ich mag Andys Antwort, aber die ID wird nicht unbedingt eindeutig sein, also habe ich mir dazu ein eigenes ID gemacht. Kann auch unter jsfiddle überprüft werden. Bitte beachten Sie, dass arr.length + 1 möglicherweise keine eindeutige ID garantiert, wenn zuvor etwas entfernt wurde.

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

Ich denke, das ist der kürzeste Weg, um dieses Problem anzugehen. Hier habe ich die ES6-Pfeilfunktion mit .filter verwendet, um das Vorhandensein von neu hinzugefügten Benutzernamen zu überprüfen. 

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 zu Fiddle

Sie könnten Ihr Array als Prototyp entwickeln, um es modularer zu machen

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

Und du kannst es verwenden als:

 yourArray.hasElement(yourArrayElement)

xorWith kann dazu in Lodash verwendet werden

let objects = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]
let existingObject = { id: 1, username: 'fred' };
let newObject = { id: 1729, username: 'Ramanujan' }

_.xorWith(objects, [existingObject], _.isEqual)
// returns [ { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]

_.xorWith(objects, [newObject], _.isEqual)
// returns [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ,{ id: 1729, username: 'Ramanujan' } ]

Die akzeptierte Antwort kann auch mit der Pfeilfunktion auf .some folgendermaßen geschrieben werden

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

Überprüfen Sie es hier:

https://stackoverflow.com/a/53644664/1084987

Sie können etwas wie if Bedingung hinterher erstellen, wie 

if(!contains(array, obj)) add();

Die systemeigenen Funktionen des Arrays sind manchmal 3 bis 5 Mal langsamer als normale Schleifen. Außerdem funktionieren native Funktionen nicht in allen Browsern, daher gibt es Kompatibilitätsprobleme.

Mein Code:

<script>
  var obj = [];

  function checkName(name) {
    // declarations
    var flag = 0;
    var len = obj.length;   
    var i = 0;
    var id = 1;

    // looping array
    for (i; i < len; i++) {
        // if name matches
        if (name == obj[i]['username']) {
            flag = 1;
            break;
        } else {
            // increment the id by 1
            id = id + 1;
        }
    }

    // if flag = 1 then name exits else Push in array
    if (flag == 0) {
      // new entry Push in array        
      obj.Push({'id':id, 'username': name});
    }
  }
  // function end

  checkName('abc');
</script>

Auf diese Weise können Sie schneller Ergebnisse erzielen.

Hinweis: Ich habe nicht überprüft, ob der übergebene Parameter leer ist oder nicht. Wenn Sie möchten, können Sie ihn überprüfen oder einen regulären Ausdruck für eine bestimmte Überprüfung schreiben.