Eliminación de elementos de la matriz en JavaScript - eliminar vs empalme

Question

¿Cuál es la diferencia entre usar el operador delete en el elemento de matriz en lugar de utilizar el método Array.splice ?

Por ejemplo:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

¿Por qué incluso tener el método de empalme si puedo eliminar elementos de la matriz como puedo con objetos?

Answer 1

delete eliminará la propiedad del objeto, pero no va a indexar la matriz o actualizar su longitud. Esto hace que aparece como si no está definido:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

Tenga en cuenta que no es, de hecho, establecido en el valor undefined, en lugar de la propiedad se retira de la matriz, por lo que es aparece indefinido. Las herramientas de Chrome dev hacen esta distinción clara mediante la impresión de empty cuando se conecta la matriz.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) en realidad elimina el elemento, reindexa la matriz, y cambia su longitud.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Answer 2

Array.remove () Método

John Resig , creador de jQuery creado un método muy práctico Array.remove que siempre lo uso en mis proyectos.

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

y aquí hay algunos ejemplos de cómo se podría usar:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

página web de John

Answer 3

Debido a borrar sólo elimina el objeto del elemento de la matriz, la longitud de la matriz no va a cambiar. Splice quita el objeto y acorta la matriz.

El código siguiente mostrará "a", "b", "indefinido", "d"

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Considerando que la presente mostrará "a", "b", "d"

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Answer 4

había tropezado con esta cuestión al tratar de comprender cómo quitar todas las apariciones de un elemento de una matriz. He aquí una comparación de splice y delete para la eliminación de todas las 'c' de la matriz items.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Answer 5

Referencia de JavaScript 1.5> Operadores> Operadores especiales> borrar Operador :

  

Cuando se elimina un elemento de matriz, la   longitud de la matriz no se ve afectada. por   ejemplo, si se elimina un [3], una [4] es   siendo una [4] y una [3] es indefinido. Esta   se mantiene incluso si se elimina el último   elemento de la matriz (eliminar   un [a.length-1]).

Answer 6

splice trabajará con índices numéricos.

mientras que delete puede usarse contra otro tipo de índices ..

ejemplo:

delete myArray['text1'];

Answer 7

Es probable que también vale la pena mencionar que el empalme sólo funciona en las matrices. (Propiedades de objeto no se puede confiar en que seguir un orden coherente.)

Para quitar el par clave-valor de un objeto, se elimina está en realidad lo que quiere:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Answer 8

Como se ha dicho muchas veces por encima, usando splice() parece ser un ajuste perfecto. Documentación en Mozilla:

  

La splice() método cambia el contenido de una matriz mediante la eliminación de los elementos existentes y / o la adición de nuevos elementos.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

     

Sintaxis

     

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

  

     

Parámetros

     

Iniciar

     

Índice en el que para empezar a cambiar la matriz. Si es mayor que la longitud de la matriz, índice de inicio real se establece en la longitud de la matriz. Si es negativo, comenzará a tantos elementos del final.

     

deleteCount

     

Un entero que indica el número de elementos de matriz viejo para eliminar. Si deleteCount es 0, se eliminan no hay elementos. En este caso, se debe especificar al menos un elemento nuevo. Si deleteCount es mayor que el número de elementos que quedan en la matriz a partir de inicio, a continuación, todos los elementos a través de la final de la matriz será eliminado.

     

Si se omite deleteCount, deleteCount será igual a (arr.length - start).

     

elemento1, elemento2, ...

     

Los elementos a añadir a la matriz, comenzando en el índice de inicio. Si no se especifica ningún elemento, splice() sólo eliminará elementos de la matriz.

     

Valor de retorno

     

Una matriz que contiene los elementos eliminados. Si se retira sólo un elemento, se devuelve una matriz de un elemento. Si se eliminan no hay elementos, se devuelve una matriz vacía.

     

[...]

Answer 9

eliminar Vs empalme

cuando se elimina un elemento de una matriz

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

cuando empalmar

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

En el caso de eliminar se elimina el elemento , pero el índice se mantiene vacío

mientras que en caso de empalme elemento se elimina y el índice de elementos de apoyo se reduce en consecuencia

Answer 10

eliminar actúa como una situación que no es el mundo real, sólo elimina el artículo, pero la longitud de la matriz sigue siendo el mismo:

ejemplo desde el terminal de nodo:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

Esta es una función para eliminar un elemento de una matriz mediante un índice, usando slice () , que toma el arr como el primer argumento, y el índice del elemento que desee eliminar como el segundo argumento. Como se puede ver, en realidad elimina el miembro de la matriz, y se reducirá la longitud de la matriz por 1

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

Lo que la función anterior es tomar todos los miembros hasta el índice, y todos los miembros después de que el índice, y los concatena juntos, y devuelve el resultado.

Aquí está un ejemplo usando la función anterior como un módulo de nodo, al ver el terminal será útil:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

Por favor, tenga en cuenta que esto no funcionará una matriz con duplicados en el mismo, debido a indexOf ( "C") se acaba de conseguir la primera ocurrencia, y sólo empalmar hacia fuera y quitar la primera "c" que encuentra.

Answer 11

Si desea recorrer una gran variedad y eliminar selectivamente los elementos, sería costoso llamar empalme () para cada eliminar porque empalme () tendría que volver a indexar los elementos posteriores cada vez. Debido a que las matrices son asociativos en Javascript, sería más eficiente para eliminar los elementos individuales a continuación, volver a índice de la matriz después.

Puede hacerlo mediante la construcción de una nueva matriz. por ejemplo

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

Pero no creo que se pueden modificar los valores de las claves de la matriz original, lo que sería más eficiente -. Parece que es posible que tenga que crear una nueva matriz

Tenga en cuenta que no es necesario comprobar si las entradas "indefinido", ya que en realidad no existen y el bucle no se ríe les devuelven. Es un artefacto de la impresión de matriz que los muestra como no definidos. No parecen existir en la memoria.

Sería bueno si pudiera usar algo como slice (), que sería más rápido, pero no volver a indexar. Alguien sabe de una mejor manera?

---

En realidad, es probable que pueda hacerlo en el lugar de la siguiente manera, que es probablemente más eficiente, en cuanto al rendimiento:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

Answer 12

se puede usar algo como esto

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

Answer 13

¿Por qué no filtrar? Creo que es la forma más clara a considerar las matrices de js.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Answer 14

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

ejemplo:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

se elimina plátano y longitud de la matriz = 2

Answer 15

Son cosas diferentes que tienen diferentes propósitos.

splice es específica de la matriz y, cuando se usa para borrar, elimina las entradas de la matriz y mueve todas las entradas anteriores hasta llenar el vacío. (. También se puede utilizar para insertar entradas, o ambos al mismo tiempo) splice cambiará el length de la matriz (suponiendo que no es una llamada no-op: theArray.splice(x, 0)).

delete no es específica de la matriz; que está diseñado para su uso en objetos: Se elimina una propiedad (valor par / clave) del objeto que lo utilice en. Sólo se aplica a las matrices porque estándar (por ejemplo, no mecanografiadas) arrays en JavaScript no son realmente los arrays en absoluto *, son objetos con un manejo especial para ciertas propiedades, tales como aquellos cuyos nombres son "los índices de matriz" (que son definido como nombres de cadena" ... cuya i valor numérico está en el rango +0 ≤ i < 2^32-1" ) y length. Cuando se utiliza delete para quitar una entrada de la matriz, lo único que hace es eliminar la entrada; no se mueve otras entradas siguiéndolo hasta llenar el vacío, por lo que el conjunto se convierte en "escasa" (tiene algunas entradas que faltan por completo). No tiene ningún efecto sobre length.

Un par de las respuestas actuales a esta pregunta indicar erróneamente que el uso de delete "establece la entrada a undefined". Eso no es correcto. Es elimina de la entrada (propiedad) por completo, dejando un hueco.

Vamos a usar algo de código para ilustrar las diferencias:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

---

* (que es un post en mi blog poco anémica)

Answer 16

En la actualidad hay dos maneras de hacer esto

1. mediante splice ()

   arrayObject.splice(index, 1);

2. usando eliminar

   delete arrayObject[index];

Pero siempre es recomendable usar los empalmes de los objetos de matriz y borrar para eliminar atributos de los objetos ya no se actualiza longitud de la matriz.

Answer 17

La diferencia puede ser visto por el registro de la longitud de cada matriz después se aplican al operador delete y método splice(). Por ejemplo:

eliminar operador

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

El operador delete elimina el elemento de la matriz, pero el "marcador de posición" del elemento todavía existe. oak se ha eliminado pero todavía tiene espacio en la matriz. Debido a esto, la longitud de la matriz sigue siendo 5.

empalme método ()

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

El método splice() elimina por completo el valor objetivo y el "marcador de posición" también. oak se ha eliminado, así como el espacio que utiliza para ocupar en la matriz. La longitud de la matriz es ahora 4.

Answer 18

bien, imaginemos que tenemos esta matriz a continuación:

const arr = [1, 2, 3, 4, 5];

Vamos a hacer que Supr:

delete arr[1];

y este es el resultado:

[1, empty, 3, 4, 5];

vacío y vamos a conseguirlo:

arr[1]; //undefined

Así que significa que sólo el valor borrada y es Indefinido ahora, para la longitud es la misma, también se volverá true ...

Vamos a restablecer nuestra matriz y lo hacen con empalme de este tiempo:

arr.splice(1, 1);

y este es el resultado esta vez:

[1, 3, 4, 5];

Como se puede ver la longitud de la matriz cambió y arr[1] es 3 ahora ...

Además, este devolverá el elemento eliminado en una matriz que se [3] en este caso ...

Answer 19

La manera más fácil es probablemente

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

Espero que esto ayude. Referencia: https://lodash.com/docs#compact

Answer 20

Para los que quiere usar Lodash puede utilizar: myArray = _.without(myArray, itemToRemove)

O, como lo uso en Angular2

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

Answer 21

  

eliminar : borrar borrará la propiedad del objeto, pero no indexar   la matriz o actualizar su longitud. Esto hace que aparece como si fuera   indefinido:

     

empalme : en realidad elimina el elemento, reindexa la matriz, y cambios   su longitud.

Eliminar elemento de la última

arrName.pop();

Eliminar elemento de primera

arrName.shift();

Borrar de la media

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

Eliminar un elemento de la última

arrName.splice(-1);

Eliminar mediante el uso de número de índice de array

 delete arrName[1];

Answer 22

Si el elemento que desea borrar está en el medio (digamos que queremos eliminar 'c', que su índice es 1), se puede utilizar:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

Answer 23

IndexOf acepta también un tipo de referencia. Supongamos el siguiente escenario:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

A diferencia:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

Answer 24

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// resultado: myArray = [ 'b', 'c', 'd'];