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

Wenn ich das folgende Array von Objekten habe:

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

Gibt es eine Möglichkeit, das Array zu durchlaufen, um zu überprüfen, ob ein bestimmter Benutzername bereits vorhanden ist und ob er nichts tut, aber dem Array kein neues Objekt mit diesem Benutzernamen (und dieser neuen ID) hinzuzufügen?

Vielen Dank!

Ich habe angenommen, dass ids hier einzigartig sein sollen. someist eine großartige Funktion zum Überprüfen der Existenz von Dingen in Arrays:

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

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

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

Es ist ziemlich trivial, nach dem 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 Ausweg - einfach ein neues Element mit idgleichem Druck drücken 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

Dies garantiert die Eindeutigkeit der IDs, lässt dieses Array jedoch etwas seltsam aussehen, wenn einige Elemente von seinem Ende entfernt 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))

Ich denke, dies ist der kürzeste Weg, um dieses Problem anzugehen. Hier habe ich die ES6-Pfeilfunktion mit .filter verwendet, um das Vorhandensein eines neu hinzugefügten Benutzernamens 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

Dies habe ich zusätzlich zu der Antwort von @ sagar-gavhane getan

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)

Akzeptierte Antworten können auch folgendermaßen mit der Pfeilfunktion auf .some 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 }); }
 }

Ich mag Andys Antwort, aber die ID wird nicht unbedingt eindeutig sein. Deshalb habe ich mir Folgendes ausgedacht, um auch eine eindeutige ID zu erstellen. Kann auch bei jsfiddle überprüft werden. Bitte beachten Sie, dass dies arr.length + 1mö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 };
}

Sie können Ihr Array als Prototyp erstellen, um es modularer zu gestalten. Probieren Sie Folgendes aus

    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 Sie können es verwenden als:

 yourArray.hasElement(yourArrayElement)

Ich habe die obigen Schritte aus irgendeinem Grund ausprobiert, es scheint nicht für mich zu funktionieren, aber dies war meine endgültige Lösung für mein eigenes Problem, nur vielleicht hilfreich für jemanden, der dies liest:

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

hier post.likes ist eine Reihe von Benutzern, denen ein Beitrag gefallen hat.

Versuche dies

erste Methode mit einigen

  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)

zweite Methode mit Includes, 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)

Nehmen wir an, wir haben ein Array von Objekten und Sie möchten überprüfen, ob der Wert des Namens wie folgt definiert ist.

let persons = [ {"name" : "test1"},{"name": "test2"}];

if(persons.some(person => person.name == 'test1')) {
    ... here your code in case person.name is defined and available
}

Hier ist eine ES6-Methodenkette mit .map()und .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. Ordnen Sie vorhandene Benutzer zu, um ein Array von Benutzernamenzeichenfolgen zu erstellen.
2. Überprüfen Sie, ob dieses Array von Benutzernamen den neuen Benutzernamen enthält
3. Wenn es nicht vorhanden ist, fügen Sie den neuen Benutzer hinzu

Native Funktionen des Arrays sind manchmal 3- bis 5-mal langsamer als normale Schleifen. Außerdem funktionieren native Funktionen nicht in allen Browsern, sodass Kompatibilitätsprobleme auftreten.

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 Validierung schreiben.

xorWith in Lodash kann verwendet werden, um dies zu erreichen

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' } ]

Überprüfen Sie es hier:

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

Sie können so etwas wie wenn Bedingung danach erstellen, wie

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

Funktion number_present_or_not () { var arr = [ 2,5,9,67,78,8,454,4,6,79,64,688 ] ; var found = 6; var found_two; für (i = 0; i

    }
    if ( found_two == found )
    {
        console.log("number present in the array");
    }
    else
    {
        console.log("number not present in the array");
    }
}

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;