Controllare se esiste un valore oggetto all'interno di un array Javascript di oggetti e se non aggiungere un nuovo oggetto all'array

Se ho il seguente array di oggetti:

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

C'è un modo per passare in rassegna l'array per verificare se esiste già un determinato valore del nome utente e se non fa nulla, ma se non aggiunge un nuovo oggetto all'array con detto nome utente (e nuovo ID)?

Grazie!

Ho supposto che ids siano fatti per essere unici qui. someè un'ottima funzione per verificare l'esistenza di cose negli array:

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

È piuttosto banale controllare il nome utente esistente:

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

Ma non è così ovvio cosa fare quando si deve aggiungere un nuovo utente a questo array. La via d'uscita più semplice: basta spingere un nuovo elemento iduguale a 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

Garantirà l'unicità degli ID, ma renderà un po 'strano questo array se alcuni elementi verranno rimossi dalla sua estremità.

Questo piccolo frammento funziona per me ..

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

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

console.log(arrayOfObject.some(checkUsername))

Penso che questo sia il modo più breve per affrontare questo problema. Qui ho usato la funzione freccia ES6 con .filter per verificare l'esistenza di un nuovo nome utente.

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

Questo è ciò che ho fatto oltre alla risposta di @ 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 risposta accettata può anche essere scritta nel modo seguente usando la funzione freccia su .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 }); }
 }

Ecco una catena di metodi ES6 che utilizza .map()e .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. Mappare gli utenti esistenti per creare una serie di stringhe di nomi utente.
2. Controlla se quell'array di nomi utente include il nuovo nome utente
3. Se non è presente, aggiungi il nuovo utente

Mi piace la risposta di Andy, ma l'id non sarà necessariamente unico, quindi ecco cosa mi è venuto in mente per creare anche un ID univoco. Può essere controllato anche su jsfiddle . Si noti che arr.length + 1potrebbe non garantire un ID univoco se qualcosa è stato rimosso in precedenza.

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

Potresti prototipare il tuo array per renderlo più modulare, provare qualcosa del genere

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

E puoi usarlo come:

 yourArray.hasElement(yourArrayElement)

ho provato i passaggi precedenti per qualche motivo che sembra non funzionare per me, ma questa è stata la mia soluzione finale al mio problema, forse utile a chiunque legga questo:

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

qui post.likes è un array di utenti a cui è piaciuto un post.

prova questo

primo metodo usando alcuni

  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)

secondo metodo usando 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)

Supponiamo di avere una matrice di oggetti e vuoi verificare se il valore del nome è definito in questo modo,

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

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

Le funzioni native dell'array sono talvolta 3X - 5X volte più lente dei normali loop. Inoltre le funzioni native non funzioneranno in tutti i browser, quindi sussistono problemi di compatibilità.

Il mio codice:

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

In questo modo è possibile ottenere risultati più velocemente.

Nota: non ho verificato se il parametro passato è vuoto o meno, se vuoi puoi metterlo su un controllo o scrivere un'espressione regolare per una convalida particolare.

xorWith a Lodash può essere usato per raggiungere questo obiettivo

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

Controlla qui:

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

È possibile creare qualcosa di simile se la condizione in seguito, come

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

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

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

La migliore pratica è così.

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