Compruebe si el valor del objeto existe dentro de una matriz de objetos Javascript y, si no, agregue un nuevo objeto a la matriz

Si tengo la siguiente matriz de objetos:

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

¿Hay alguna manera de recorrer la matriz para verificar si ya existe un valor de nombre de usuario en particular y si no hace nada, pero si no lo hace, agregar un nuevo objeto a la matriz con dicho nombre de usuario (y nueva ID)?

¡Gracias!

Supuse que los ids están destinados a ser únicos aquí. somees una gran función para verificar la existencia de cosas en matrices:

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 bastante trivial verificar el nombre de usuario existente:

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

Pero no es tan obvio qué hacer cuando tiene que agregar un nuevo usuario a esta matriz. La salida más fácil: simplemente empujando un nuevo elemento con idigual 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

Garantizará la unicidad de los ID, pero hará que esta matriz se vea un poco extraña si se quitan algunos elementos.

Estos pequeños fragmentos me funcionan ...

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

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

console.log(arrayOfObject.some(checkUsername))

Creo que esta es la forma más corta de abordar este problema. Aquí he usado la función de flecha ES6 con .filter para verificar la existencia de un nuevo nombre de usuario agregado.

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

Enlace a violín

Esto es lo que hice además de la respuesta 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 respuesta aceptada también se puede escribir de la siguiente manera usando la función de flecha en .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 }); }
 }

Me gusta la respuesta de Andy, pero la identificación no necesariamente será única, así que esto es lo que se me ocurrió para crear una identificación única también. También se puede verificar en jsfiddle . Tenga en cuenta que es arr.length + 1muy posible que no garantice una identificación única si se ha eliminado algo anteriormente.

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

Podrías crear un prototipo de tu matriz para hacerla más modular, prueba algo como esto

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

Y puedes usarlo como:

 yourArray.hasElement(yourArrayElement)

Intenté los pasos anteriores por alguna razón, parece que no funciona para mí, pero esta fue mi solución final a mi propio problema, tal vez útil para cualquiera que lea esto:

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

aquí post.likes es una variedad de usuarios a los que les gustó una publicación.

prueba esto

primer método usando algunos

  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)

segundo método usando incluye, mapa

   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)

Supongamos que tenemos una matriz de objetos y desea verificar si el valor del nombre se define así,

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

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

Aquí hay una cadena de métodos ES6 que usa .map()y .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. Asigne sobre usuarios existentes para crear una matriz de cadenas de nombre de usuario.
2. Compruebe si ese conjunto de nombres de usuario incluye el nuevo nombre de usuario
3. Si no está presente, agregue el nuevo usuario

Las funciones nativas de la matriz a veces son entre 3 y 5 veces más lentas que los bucles normales. Además, las funciones nativas no funcionarán en todos los navegadores, por lo que hay problemas de compatibilidad.

Mi código:

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

De esta manera puede lograr resultados más rápido.

Nota: No he verificado si el parámetro pasado está vacío o no, si lo desea, puede marcarlo o escribir una expresión regular para una validación particular.

xorWith en Lodash se puede usar para lograr esto

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

Compruébalo aquí:

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

Puede crear algo como si la condición posterior, como

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

function number_present_or_not () { var arr = [ 2,5,9,67,78,8,454,4,6,79,64,688 ] ; var encontrado = 6; var encontrado_dos; para (i = 0; i

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

La mejor práctica es así.

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