Rimuovere l'oggetto dall'array utilizzando JavaScript

Come posso rimuovere un oggetto da un array? Vorrei rimuovere l'oggetto che include il nome Kristianda someArray. Per esempio:

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

Voglio raggiungere:

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

È possibile utilizzare diversi metodi per rimuovere gli elementi da una matrice:

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

Se si desidera rimuovere l'elemento in posizione x, utilizzare:

someArray.splice(x, 1);

O

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

Rispondi al commento di @ chill182 : puoi rimuovere uno o più elementi da un array usando Array.filter, o Array.splicecombinato con Array.findIndex(vedi MDN ), ad es.

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

// Note: if you're not sure about the contents of your array, 
// you should check the results of findIndex first
let someArray4 = getArray();
const indx = someArray4.findIndex(v => v.name === "Michael");
someArray4.splice(indx, indx >= 0 ? 1 : 0);
log("", "check findIndex result first > someArray4 (nothing is removed) > ",
  format(someArray4));
log(`**someArray4.length (should still be 3) ${someArray4.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>

Consiglio di utilizzare lodash.js o sugar.js per attività comuni come questa:

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

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

nella maggior parte dei progetti, avere una serie di metodi di supporto forniti da librerie come queste è abbastanza utile.

La soluzione pulita sarebbe quella di utilizzare Array.filter:

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

Il problema è che non funziona su IE <9. Tuttavia, è possibile includere codice da una libreria Javascript (ad esempio underscore.js ) che implementa questo per qualsiasi browser.

Cosa ne pensi di questo?

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

Il tuo "array" come mostrato è una sintassi JavaScript non valida. Le parentesi graffe {}sono per oggetti con coppie nome / valore della proprietà, mentre le parentesi quadre []sono per matrici - in questo modo:

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

In tal caso, è possibile utilizzare il .splice()metodo per rimuovere un elemento. Per rimuovere il primo elemento (indice 0), dire:

someArray.splice(0,1);

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

Se non si conosce l'indice ma si desidera cercare nell'array per trovare l'elemento con il nome "Kristian" da rimuovere, è possibile:

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

EDIT: Ho appena notato che la tua domanda è taggata con "jQuery", quindi puoi provare il $.grep()metodo :

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

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

Rimuoverà John !

È possibile utilizzare array.filter ().

per esempio

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

Funzioni freccia:

someArray = someArray.filter(x => x.name !== 'Kristian')

Ho creato una funzione dinamica che prende gli oggetti Array, Key e value e restituisce lo stesso array dopo aver rimosso l'oggetto desiderato:

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

        }

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

Questa è una funzione che funziona per me:

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

Potresti anche provare a fare qualcosa del genere:

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

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

Utilizzare la funzione di giunzione su array. Specificare la posizione dell'elemento iniziale e la lunghezza della sottosequenza che si desidera rimuovere.

someArray.splice(pos, 1);

Vota per UndercoreJS per un lavoro semplice con le matrici.

La funzione _.without () aiuta a rimuovere un elemento:

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

Con la funzione freccia 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)

La soluzione più semplice sarebbe quella di creare una mappa che memorizzi gli indici per ciascun oggetto per nome, in questo modo:

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

Anche se questo probabilmente non è appropriato per questa situazione, ho scoperto l'altro giorno che puoi anche usare la deleteparola chiave per rimuovere un elemento da un array se non hai bisogno di modificare le dimensioni dell'array, ad es.

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

Questa risposta

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

non funziona per più record che soddisfano la condizione. Se si dispone di due record consecutivi, viene rimosso solo il primo e l'altro ignorato. Devi usare:

for (var i = someArray.length - 1; i>= 0; i--)
   ...

anziché .

Sembra esserci un errore nella sintassi dell'array, quindi supponendo che tu intenda un array anziché un oggetto, Array.splice è il tuo amico qui:

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

Puoi anche usare la funzione mappa .

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

Puoi anche usare 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) 
})

Questo è quello che 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();
  }

Quindi è semplice come dire

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

Sostituisci qualsiasi numero al posto di tre. Dopo l'output previsto dovrebbe essere:

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

Se si desidera rimuovere tutte le occorrenze di un determinato oggetto (in base a una condizione), utilizzare il metodo di giunzione javascript all'interno di a per il ciclo.

Poiché la rimozione di un oggetto influirebbe sulla lunghezza dell'array, assicurarsi di ridurre il contatore di un passo, in modo che il controllo della lunghezza rimanga intatto.

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

Lo snippet di codice sopra rimuove tutti gli oggetti con età maggiore di 20 anni.

Usa la funzione splice () di javascript.

Questo può essere d'aiuto: http://www.w3schools.com/jsref/jsref_splice.asp

splice (i, 1) dove i è l'indice incrementale dell'array rimuoverà l'oggetto. Ma ricorda che splice ripristinerà anche la lunghezza dell'array, quindi fai attenzione a "non definito". Usando il tuo esempio, se rimuovi 'Kristian', quindi nella prossima esecuzione all'interno del ciclo, sarò 2 ma someArray avrà una lunghezza di 1, quindi se provi a rimuovere "John" otterrai un errore "indefinito" . Una soluzione a questo, sebbene non elegante, è quella di avere un contatore separato per tenere traccia dell'indice dell'elemento da rimuovere.

Restituisce solo oggetti dall'array la cui proprietà namenon è "Kristian"

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

 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>

Questo concetto usa 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;
    }
}

Immagino che le risposte siano molto ramificate e annodate.

È possibile utilizzare il seguente percorso per rimuovere un oggetto array che corrisponde all'oggetto indicato nel gergo JavaScript moderno.

coordinates = [
    { lat: 36.779098444109145, lng: 34.57202827508546 },
    { lat: 36.778754712956506, lng: 34.56898128564454 },
    { lat: 36.777414146732426, lng: 34.57179224069215 }
];

coordinate = { lat: 36.779098444109145, lng: 34.57202827508546 };

removeCoordinate(coordinate: object) {
  const found = this.coordinates.find((obj) => obj === obj);
  if (found) {
    this.coordinates.splice(found, 1);
  }
}

this.removeCoordinate(coordinate);

Se vuoi accedere e rimuovere l'oggetto di un array semplicemente puoi provare qualcosa del genere.

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