metodos - recorrer array de objetos javascript

Eliminar objeto de la matriz utilizando JavaScript

Question

¿Cómo puedo eliminar un objeto de una matriz? Deseo eliminar el objeto que incluye el nombre Kristian de someArray . Por ejemplo:

someArray = [{name:"Kristian", lines:"2,5,10"},
             {name:"John", lines:"1,19,26,96"}];

Quiero lograr:

someArray = [{name:"John", lines:"1,19,26,96"}];

Answer 1

¿Qué tal esto?

$.each(someArray, function(i){
    if(someArray[i].name === ''Kristian'') {
        someArray.splice(i,1);
        return false;
    }
});

Answer 2

Aunque es probable que esto no sea apropiado para esta situación, descubrí el otro día que también puede usar la palabra clave delete para eliminar un elemento de una matriz si no necesita modificar el tamaño de la matriz, por ejemplo

var myArray = [1,2,3];

delete myArray[1];

console.log(myArray[1]); //undefined

console.log(myArray.length); //3 - doesn''t actually shrink the array down

Answer 3

Con la función de flecha ES 6.

let someArray = [
                 {name:"Kristian", lines:"2,5,10"},
                 {name:"John", lines:"1,19,26,96"}
                ];
let arrayToRemove={name:"Kristian", lines:"2,5,10"};
someArray=someArray.filter((e)=>e.name !=arrayToRemove.name && e.lines!= arrayToRemove.lines)

Answer 4

ES2015

let someArray = [
               {name:"Kristian", lines:"2,5,10"},
               {name:"John", lines:"1,19,26,96"},
               {name:"Kristian", lines:"2,58,160"},
               {name:"Felix", lines:"1,19,26,96"}
            ];

someArray = someArray.filter(person => person.name != ''John'');

¡Se quitará a Juan !

Answer 5

Esta es una función que funciona para mí:

function removeFromArray(array, value) {
    var idx = array.indexOf(value);
    if (idx !== -1) {
        array.splice(idx, 1);
    }
    return array;
}

Answer 6

Esta respuesta

for (var i =0; i < someArray.length; i++)
   if (someArray[i].name === "Kristian") {
      someArray.splice(i,1);
   }

no esta trabajando para multiples registros cumpliendo la condicion !!! Si tiene dos registros consecutivos, solo se eliminará el primero y el otro se omitirá. Tienes que usar: for (var i = someArray.length - 1; i> = 0; i--) ... en su lugar

Answer 7

Este conceptos utilizando Kendo Grid

var grid = $("#addNewAllergies").data("kendoGrid");

var selectedItem = SelectedCheckBoxList;

for (var i = 0; i < selectedItem.length; i++) {
    if(selectedItem[i].boolKendoValue==true)
    {
        selectedItem.length= 0;
    }
}

Answer 8

Esto es lo que yo uso.

Array.prototype.delete = function(pos){
    this[pos] = undefined;
    var len = this.length - 1;
    for(var a = pos;a < this.length - 1;a++){
      this[a] = this[a+1];
    }
    this.pop();
  }

Entonces es tan simple como decir

var myArray = [1,2,3,4,5,6,7,8,9];
myArray.delete(3);

Reemplace cualquier número en lugar de tres. Después de la salida esperada debe ser:

console.log(myArray); //Expected output 1,2,3,5,6,7,8,9

Answer 9

Hice una función dinámica, toma los objetos Array, Key y value y devuelve la misma matriz después de eliminar el objeto deseado:

function removeFunction (myObjects,prop,valu)
        {
             return myObjects.filter(function (val) {
              return val[prop] !== valu;
          });

        }

Ejemplo completo: DEMO

var obj = {
            "results": [
              {
                  "id": "460",
                  "name": "Widget 1",
                  "loc": "Shed"
              }, {
                  "id": "461",
                  "name": "Widget 2",
                  "loc": "Kitchen"
              }, {
                  "id": "462",
                  "name": "Widget 3",
                  "loc": "bath"
              }
            ]
            };


        function removeFunction (myObjects,prop,valu)
        {
             return myObjects.filter(function (val) {
              return val[prop] !== valu;
          });

        }


console.log(removeFunction(obj.results,"id","460"));

Answer 10

La solución limpia sería utilizar Array.filter :

var filtered = someArray.filter(function(el) { return el.Name != "Kristian"; }); 

El problema con esto es que no funciona en IE <9. Sin embargo, puede incluir código de una biblioteca de Javascript (por ejemplo, underscore.js ) que implementa esto para cualquier navegador.

Answer 11

La solución más sencilla sería crear un mapa que almacene los índices de cada objeto por su nombre, como este:

//adding to array
var newPerson = {name:"Kristian", lines:"2,5,10"}
someMap[ newPerson.name ] = someArray.length;
someArray.push( newPerson );

//deleting from the array
var index = someMap[ ''Kristian'' ];
someArray.splice( index, 1 );

Answer 12

Parece que hay un error en la sintaxis de tu matriz, por lo que, suponiendo que te refieres a una matriz en lugar de un objeto, Array.splice es tu amigo aquí

someArray = [{name:"Kristian", lines:"2,5,10"}, {name:"John", lines:"1,19,26,96"}];
someArray.splice(1,1)

Answer 13

Podrías usar array.filter ().

p.ej

        someArray = [{name:"Kristian", lines:"2,5,10"},
                     {name:"John", lines:"1,19,26,96"}];

        someArray = someArray.filter(function(returnableObjects){
               return returnableObjects.name !== ''Kristian'';
        });

        //someArray will now be = [{name:"John", lines:"1,19,26,96"}];

Answer 14

Puede usar varios métodos para eliminar elementos de una matriz:

//1
someArray.shift(); // first element removed
//2
someArray = someArray.slice(1); // first element removed
//3
someArray.splice(0, 1); // first element removed
//4
someArray.pop(); // last element removed
//5
someArray = someArray.slice(0, a.length - 1); // last element removed
//6
someArray.length = someArray.length - 1; // last element removed

Si desea eliminar el elemento en la posición x , use:

someArray.splice(x, 1);

O

someArray = someArray.slice(0, x).concat(someArray.slice(-x));

Responda al comentario de @chill182 : puede eliminar uno o más elementos de una matriz utilizando Array.filter , o Array.splice combinado con Array.findIndex (consulte MDN ), por ejemplo

// non destructive filter > noJohn = John removed, but someArray will not change
let someArray = getArray();
let noJohn = someArray.filter( el => el.name !== "John" ); 
log("non destructive filter > noJohn = ", format(noJohn));
log(`**someArray.length ${someArray.length}`);

// destructive filter/reassign John removed > someArray2 =
let someArray2 = getArray();
someArray2 = someArray2.filter( el => el.name !== "John" );
log("", "destructive filter/reassign John removed > someArray2 =", 
  format(someArray2));
log(`**someArray2.length ${someArray2.length}`);

// destructive splice /w findIndex Brian remains > someArray3 =
let someArray3 = getArray();
someArray3.splice(someArray3.findIndex(v => v.name === "Kristian"), 1);
someArray3.splice(someArray3.findIndex(v => v.name === "John"), 1);
log("", "destructive splice /w findIndex Brian remains > someArray3 =", 
  format(someArray3));
log(`**someArray3.length ${someArray3.length}`);

function format(obj) {
  return JSON.stringify(obj, null, " ");
}

function log(...txt) {
  document.querySelector("pre").textContent += `${txt.join("/n")}/n`
}

function getArray() {
  return [ {name: "Kristian", lines: "2,5,10"},
           {name: "John", lines: "1,19,26,96"},
           {name: "Brian", lines: "3,9,62,36"} ];
}

<pre>
**Results**

</pre>

Answer 15

Puedes usar la función de mapa también.

someArray = [{name:"Kristian", lines:"2,5,10"},{name:"John",lines:"1,19,26,96"}];
newArray=[];
someArray.map(function(obj, index){
    if(obj.name !== "Kristian"){
       newArray.push(obj);
    }
});
someArray = newArray;
console.log(someArray);

Answer 16

Recomiendo usar underscore.js o sugar.js para tareas comunes como esta:

// underscore.js
someArray = _.reject(someArray, function(el) { return el.Name === "Kristian"; });

// sugar.js
someArray.remove(function(el) { return el.Name === "Kristian"; });

en la mayoría de los proyectos, tener un conjunto de métodos de ayuda proporcionados por bibliotecas como estas es bastante útil.

Answer 17

Si desea acceder y eliminar el objeto de una matriz, simplemente puede intentar algo como esto.

// inside some function

let someArray = [ {"ColumnName" : "a", "PropertySerno" : 100005,"UpdateType" : 1},
                  {"ColumnName" : "b", "PropertySerno" : 100202,"UpdateType" : 1,
        "ShowRemoveButton" : true} ];
        
        for (let item of someArray) {
          delete item.ShowRemoveButton;
        }
        console.log(item.outputMappingData.Data);
        
//output will be like that = [ {"ColumnName" : "a", "PropertySerno" : 100005,"UpdateType" : 1},
//                             {"ColumnName" : "b", "PropertySerno" : 100202,"UpdateType" : 1 }];
        

Answer 18

Si desea eliminar todas las apariciones de un objeto determinado (según alguna condición), utilice el método de empalme de javascript dentro de un bucle para el bucle.

Dado que la eliminación de un objeto afectaría la longitud de la matriz, asegúrese de disminuir el contador un paso, para que la verificación de la longitud permanezca intacta.

var objArr=[{Name:"Alex", Age:62},
  {Name:"Robert", Age:18},
  {Name:"Prince", Age:28},
  {Name:"Cesar", Age:38},
  {Name:"Sam", Age:42},
  {Name:"David", Age:52}
];

for(var i = 0;i < objArr.length; i ++)
{
  if(objArr[i].Age > 20)
  {
    objArr.splice(i, 1);
    i--;  //re-adjust the counter.
  }
}

El fragmento de código anterior elimina todos los objetos con una edad superior a 20.

Answer 19

Solo devuelve objetos de la matriz cuyo name propiedad no es "Kristian"

var noKristianArray = $.grep(someArray, function (el) { return el.name!= "Kristian"; }); Manifestación:

 var someArray = [
                {name:"Kristian", lines:"2,5,10"},
                {name:"John", lines:"1,19,26,96"},
                {name:"Kristian", lines:"2,58,160"},
                {name:"Felix", lines:"1,19,26,96"}
                ];
    
var noKristianArray = $.grep(someArray, function (el) { return el.name!= "Kristian"; });

console.log(noKristianArray);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Answer 20

Su "matriz" como se muestra no es válida para la sintaxis de JavaScript. Los corchetes {} son para objetos con pares de nombre / valor de propiedad, pero los corchetes [] son para arrays, por ejemplo:

someArray = [{name:"Kristian", lines:"2,5,10"}, {name:"John", lines:"1,19,26,96"}];

En ese caso, puede usar el método .splice() para eliminar un elemento. Para eliminar el primer elemento (índice 0), diga:

someArray.splice(0,1);

// someArray = [{name:"John", lines:"1,19,26,96"}];

Si no conoce el índice pero desea buscar en la matriz para encontrar el elemento con el nombre "Kristian" para eliminarlo, podría:

for (var i =0; i < someArray.length; i++)
   if (someArray[i].name === "Kristian") {
      someArray.splice(i,1);
      break;
   }

EDITAR: Acabo de notar que su pregunta está etiquetada con "jQuery", por lo que podría probar el $.grep() :

someArray = $.grep(someArray,
                   function(o,i) { return o.name === "Kristian"; },
                   true);

Answer 21

También podrías usar some :

someArray = [{name:"Kristian", lines:"2,5,10"},
             {name:"John", lines:"1,19,26,96"}];

someArray.some(item => { 
    if(item.name === "Kristian") // Case sensitive, will only remove first instance
        someArray.splice(someArray.indexOf(item),1) 
})

Answer 22

También puedes intentar hacer algo como esto:

var myArray = [{''name'': ''test''}, {''name'':''test2''}];
var myObject = {''name'': ''test''};
myArray.splice(myArray.indexOf(myObject),1);

Answer 23

Utilice la función de empalme () de javascript.

Esto puede ayudar: http://www.w3schools.com/jsref/jsref_splice.asp

Answer 24

Utilice la función de empalme en matrices. Especifique la posición del elemento de inicio y la longitud de la subsecuencia que desea eliminar.

someArray.splice(pos, 1);

Answer 25

Vote por el UndercoreJS para un trabajo simple con matrices.

_.without() función _.without() ayuda a eliminar un elemento:

 _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
    => [2, 3, 4]

Answer 26

el empalme (i, 1) donde i es el índice incremental de la matriz eliminará el objeto. Pero recuerde que el empalme también restablecerá la longitud de la matriz, así que tenga cuidado con ''indefinido''. Usando su ejemplo, si elimina ''Kristian'', en la próxima ejecución dentro del bucle, seré 2 pero someArray tendrá una longitud de 1, por lo tanto, si intenta eliminar "John" obtendrá un error "indefinido" . Una solución para esto, aunque no elegante, es tener un contador separado para realizar un seguimiento del índice del elemento que se eliminará.

Answer 27

someArray = jQuery.grep(someArray , function (value) {
        return value.name != ''Kristian'';
});