todos - limpiar datos de una tabla javascript

Eliminar elementos de matriz en JavaScript-eliminar vs empalme

Question

¿Cuál es la diferencia entre usar el operador de delete en el elemento de la matriz en lugar de usar 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 matriz como puedo con objetos?

Answer 1

delete : delete eliminará la propiedad del objeto, pero no reindexará la matriz ni actualizará su longitud. Esto hace que parezca que no está definido:

empalme : en realidad elimina el elemento, vuelve a indexar la matriz y cambia su longitud.

Eliminar elemento del último

arrName.pop();

Eliminar elemento de la primera

arrName.shift();

Eliminar de medio

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

Ex: arrName.splice(1,1);

Eliminar un elemento del último

arrName.splice(-1);

Eliminar utilizando el número de índice de matriz

 delete arrName[1];

Answer 2

Array.remove () Método

John Resig , creador de jQuery, creó un método Array.remove muy práctico 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 podría usarse:

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

Sitio web de john

Answer 3

¿Por qué no solo filtrar? Creo que es la forma más clara de considerar los arreglos en js.

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

Answer 4

Actualmente hay dos formas de hacer esto.

1. utilizando splice ()

   arrayObject.splice(index, 1);

2. usando eliminar

   delete arrayObject[index];

Pero siempre sugiero usar el empalme para los objetos de matriz y eliminar para los atributos de objeto porque eliminar no actualiza la longitud de la matriz.

Answer 5

Como se dijo muchas veces anteriormente, usar splice() parece un ajuste perfecto. Documentación en Mozilla:

El método splice() cambia el contenido de una matriz eliminando elementos existentes y / o agregando 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

comienzo

Índice en el que comenzar a cambiar la matriz. Si es mayor que la longitud de la matriz, el índice de inicio real se establecerá en la longitud de la matriz. Si es negativo, comenzarán tantos elementos desde el final.

deleteCount

Un entero que indica el número de elementos de matriz antiguos para eliminar. Si deleteCount es 0, no se eliminan elementos. En este caso, debe especificar al menos un elemento nuevo. Si deleteCount es mayor que la cantidad de elementos que quedan en la matriz desde el inicio, se eliminarán todos los elementos hasta el final de la matriz.

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

item1, item2, ...

Los elementos a agregar a la matriz, comenzando en el índice de inicio. Si no especifica ningún elemento, splice() solo eliminará elementos de la matriz.

Valor de retorno

Una matriz que contiene los elementos eliminados. Si solo se elimina un elemento, se devuelve una matriz de un elemento. Si no se eliminan elementos, se devuelve una matriz vacía.

[...]

Answer 6

Debido a que eliminar solo elimina el objeto del elemento en la matriz, la longitud de la matriz no cambiará. Splice elimina el objeto y acorta la matriz.

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

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

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

Mientras que esto 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 7

Desde la Referencia Core JavaScript 1.5> Operadores> Operadores Especiales> eliminar Operador :

Cuando elimina un elemento de matriz, la longitud de la matriz no se ve afectada. Por ejemplo, si elimina un [3], un [4] sigue siendo un [4] y un [3] no está definido. Esto se mantiene incluso si elimina el último elemento de la matriz (elimine un [a.length-1]).

Answer 8

La forma 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 9

Me topé con esta pregunta al tratar de entender cómo eliminar cada aparición de un elemento de un Array. Aquí hay una comparación de splice y delete para eliminar cada ''c'' de los items Array.

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 10

OK, imagina que tenemos esta matriz a continuación:

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

Vamos a eliminar primero:

delete arr[1];

Y este es el resultado:

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

¡vacío! y vamos a conseguirlo:

arr[1]; //undefined

Entonces significa solo el valor eliminado y ahora está indefinido , así que la longitud es la misma, también devolverá verdadero ...

Vamos a restablecer nuestra matriz y hacerlo con empalme esta vez:

arr.splice(1, 1);

Y este es el resultado esta vez:

[1, 3, 4, 5];

Como ves, la longitud de la matriz ha cambiado y arr[1] es 3 ahora ...

También esto devolverá el elemento eliminado en una matriz que es [3] en este caso ...

Answer 11

Para aquellos que quieran usar Lodash puede usar: myArray = _.without(myArray, itemToRemove)

O como uso en Angular2

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

Answer 12

Probablemente también vale la pena mencionar que el empalme solo funciona en matrices. (No se puede confiar en que las propiedades de los objetos sigan un orden consistente).

Para eliminar el par clave-valor de un objeto, eliminar es realmente lo que desea:

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

Answer 13

Si desea iterar una matriz grande y eliminar elementos de forma selectiva, sería costoso llamar a splice () para cada eliminación porque splice () tendría que volver a indexar los elementos subsiguientes cada vez. Debido a que las matrices son asociativas en Javascript, sería más eficiente eliminar los elementos individuales y luego volver a indexar la matriz.

Puedes hacerlo construyendo una nueva matriz. p.ej

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

Pero no creo que pueda modificar los valores clave en la matriz original, lo que sería más eficiente, parece que tendrá que crear una nueva matriz.

Tenga en cuenta que no necesita verificar las entradas "indefinidas" ya que realmente no existen y el bucle for no las devuelve. Es un artefacto de la impresión matricial que los muestra como indefinidos. No parecen existir en la memoria.

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

En realidad, es probable que pueda hacerlo de la siguiente manera, lo que probablemente sea más eficiente en términos de 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 14

Si el elemento que desea eliminar está en el medio (digamos que queremos eliminar ''c'', cuyo índice es 1):

var arr = [''a'',''b'',''c''];

Puedes usar: var indexToDelete = 1; var newArray = arr.slice(0, indexToDelete).combine(arr.slice(indexToDelete+1, arr.length)) var indexToDelete = 1; var newArray = arr.slice(0, indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

Answer 15

Son cosas diferentes que tienen propósitos diferentes.

splice es específico de la matriz y, cuando se utiliza para eliminar, elimina las entradas de la matriz y mueve todas las entradas anteriores para llenar el vacío. (También se puede usar para insertar entradas, o ambas al mismo tiempo). splice cambiará la length de la matriz (suponiendo que no sea una llamada no theArray.splice(x, 0) : theArray.splice(x, 0) ).

delete no es específico de la matriz; está diseñado para su uso en objetos: elimina una propiedad (par clave / valor) del objeto en el que se usa. Solo se aplica a las matrices porque las matrices estándar (por ejemplo, no tipificadas) en JavaScript no son realmente matrices en absoluto *, son objetos con un manejo especial para ciertas propiedades, como aquellas cuyos nombres son "índices de matrices" (que son defined como nombres de cadena "... cuyo valor numérico i está en el rango +0 ≤ i < 2^32-1 ") y length . Cuando utiliza delete para eliminar una entrada de matriz, todo lo que hace es eliminar la entrada; no mueve otras entradas seguidas para llenar el vacío, por lo que la matriz se vuelve "dispersa" (faltan algunas entradas por completo). No tiene efecto en la length .

Un par de las respuestas actuales a esta pregunta declaran incorrectamente que el uso de delete "establece la entrada como undefined ". Eso no es correcto. Se elimina la entrada (propiedad) por completo, dejando un hueco.

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

* (Eso es un post en mi pequeño blog anémico)

Answer 16

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

Debe mostrar [1, 2, 3, 4, 6]

Answer 17

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

Diferentemente:

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 18

delete eliminará la propiedad del objeto, pero no reindexará la matriz ni actualizará su longitud. Esto hace que parezca que no está definido:

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

Tenga en cuenta que, de hecho, no está establecido en el valor undefined , sino que la propiedad se elimina de la matriz, lo que hace que aparezca como no definido. Las herramientas de desarrollo de Chrome aclaran esta distinción imprimiendo en empty cuando se registra la matriz.

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

myArray.splice(start, deleteCount) realmente elimina el elemento, vuelve a indexar 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 19

splice funcionará con índices numéricos.

mientras que delete puede ser usado contra otro tipo de índices ..

ejemplo:

delete myArray[''text1''];

Answer 20

eliminar Vs splice

cuando eliminas un elemento de una matriz

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

cuando empalme

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

en caso de eliminar el elemento se elimina pero el índice permanece vacío

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

Answer 21

eliminar actúa como una situación del mundo no real, simplemente elimina el elemento, pero la longitud de la matriz sigue siendo la misma:

ejemplo de terminal de nodo:

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

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

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

Lo que hace la función anterior es llevar a todos los miembros al índice y a todos los miembros después del índice, y los concatena, y devuelve el resultado.

Aquí hay un ejemplo que usa la función anterior como módulo de nodo, ya que 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

tenga en cuenta que esto no funcionará con una matriz con duplicados en él, porque indexOf ("c") solo obtendrá la primera aparición, y solo empalmará y eliminará la primera "c" que encuentre.

Answer 22

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

Answer 23

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 el plátano y la longitud de la matriz = 2