Eliminar elementos vacíos de una matriz en Javascript

¿Cómo elimino elementos vacíos de una matriz en JavaScript?

¿Existe una forma sencilla o tengo que recorrerla y eliminarla manualmente?

preguntado el 11 de noviembre de 08 a las 13:11

Sería útil si su pregunta hubiera especificado exactamente lo que quiere decir con "elementos vacíos", ya que la mayoría de las respuestas aquí interpretan eso incorrectamente (en mi humilde opinión) para significar elementos "falsos". NB: hay una diferencia entre lo que obtienes var a = [,,] y var a = [undefined, undefined]. El primero está realmente vacío, pero el último en realidad tiene dos claves, pero con undefined valores. -

30 Respuestas

EDIT: Esta pregunta fue respondida hace casi nueve años cuando no había muchos métodos incorporados útiles en el Array.prototype.

Ahora, sin duda, le recomendaría que utilice el filter método.

Ten en cuenta que este método te devolverá una nueva matriz con los elementos que pasan los criterios de la función de devolución de llamada que le proporcionas.

Por ejemplo, si desea eliminar null or undefined valores:

var array = [0, 1, null, 2, "", 3, undefined, 3,,,,,, 4,, 4,, 5,, 6,,,,];

var filtered = array.filter(function (el) {
  return el != null;
});

console.log(filtered);

Dependerá de lo que considere "vacío", por ejemplo, si estuviera tratando con cadenas, la función anterior no eliminaría los elementos que son una cadena vacía.

Un patrón típico que veo que se usa con frecuencia es eliminar elementos que son falsedad, que incluyen una cadena vacía "", 0, NaN, null, undefinedy false.

Puedes pasar a la filter método, el Boolean función constructora, o devolver el mismo elemento en la función de criterios de filtro, por ejemplo:

var filtered = array.filter(Boolean);

Or

var filtered = array.filter(function(el) { return el; });

En ambos sentidos, esto funciona porque el filter método en el primer caso, llama al Boolean constructor como una función, convirtiendo el valor, y en el segundo caso, el filter El método convierte internamente el valor de retorno de la devolución de llamada implícitamente en Boolean.

Si está trabajando con matrices dispersas y está tratando de deshacerse de los "agujeros", puede utilizar el filter método que pasa una devolución de llamada que devuelve verdadero, por ejemplo:

var sparseArray = [0, , , 1, , , , , 2, , , , 3],
    cleanArray = sparseArray.filter(function () { return true });

console.log(cleanArray); // [ 0, 1, 2, 3 ]

Respuesta anterior: ¡No hagas esto!

Utilizo este método, ampliando el prototipo de Array nativo:

Array.prototype.clean = function(deleteValue) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] == deleteValue) {         
      this.splice(i, 1);
      i--;
    }
  }
  return this;
};

test = new Array("", "One", "Two", "", "Three", "", "Four").clean("");
test2 = [1, 2,, 3,, 3,,,,,, 4,, 4,, 5,, 6,,,,];
test2.clean(undefined);

O simplemente puede empujar los elementos existentes a otra matriz:

// Will remove all falsy values: undefined, null, 0, false, NaN and "" (empty string)
function cleanArray(actual) {
  var newArray = new Array();
  for (var i = 0; i < actual.length; i++) {
    if (actual[i]) {
      newArray.push(actual[i]);
    }
  }
  return newArray;
}

cleanArray([1, 2,, 3,, 3,,,,,, 4,, 4,, 5,, 6,,,,]);

Respondido 21 ago 19, 13:08

ADVERTENCIA: La segunda opción eliminará cualquier elemento de una matriz considerada "falsa", es decir, los valores de falso, 2, nulo e indefinido. Esta matriz terminaría sin nada en absoluto: [null ,,, 0,, ​​0, false, null, 0,0,0] aunque podría querer los elementos con valores de 0, como en esta matriz: [ 0] - jason empavesado

Me doy cuenta de eso, por eso solo hablé de la segunda opción. En cuanto al primero, tiene un alcance tan limitado que dudaría en convertirlo en parte del prototipo de Array. Vea la respuesta de Alnitak en esta página para ver algo que sería más ideal. El tuyo sí permite el encadenamiento, obviamente. - jason empavesado

Su primera solución es realmente buena si no tiene acceso al método de "filtro". De lo contrario, creo que la respuesta de Alnitak es mejor. - jose pineda

@AlfaTek: todos, excepto los navegadores más nuevos # 2, tendrán el mejor rendimiento, porque las matrices en JS no son realmente matrices. La splice la llamada es realmente caro en los navegadores más antiguos porque tienen que volver a numerar todas las claves de matriz para cerrar la brecha. - Alnitak

@David no, en código moderno deberías de manera segura ampliar Array.prototype usar Object.defineProperty para hacer que la nueva función sea un propiedad no enumerable y luego evitar el impacto en el rendimiento causado por poner .hasOwnProperty en cada bucle. - Alnitak

Maneras simples:

var arr = [1,2,,3,,-3,null,,0,,undefined,4,,4,,5,,6,,,,];


arr.filter(n => n)
// [1, 2, 3, -3, 4, 4, 5, 6]

arr.filter(Number) 
// [1, 2, 3, -3, 4, 4, 5, 6]

arr.filter(Boolean) 
// [1, 2, 3, -3, 4, 4, 5, 6]

o - (solo para soltero elementos de matriz de tipo "texto")

['','1','2',3,,'4',,undefined,,,'5'].join('').split(''); 
// output:  ["1","2","3","4","5"]

o - Forma clásica: iteración simple

var arr = [1,2,null, undefined,3,,3,,,0,,,[],,{},,5,,6,,,,],
    len = arr.length, i;

for(i = 0; i < len; i++ )
    arr[i] && arr.push(arr[i]);  // copy non-empty values to the end of the array

arr.splice(0 , len);  // cut the array and leave only the non-empty values

arr // [1,2,3,3,[],Object{},5,6]


a través de jQuery:

var arr = [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,];

arr = $.grep(arr,function(n){ return n == 0 || n });

arr // [1, 2, 3, 3, 0, 4, 4, 5, 6]


ACTUALIZACIÓN: solo otra forma rápida y genial (usando ES6):

var arr = [1,2,null, undefined,3,,3,,,0,,,4,,4,,5,,6,,,,], 
    temp = [];

for(let i of arr)
    i && temp.push(i); // copy each non-empty value to the 'temp' array

arr = temp;

arr // [1, 2, 3, 3, 4, 4, 5, 6]

Eliminar valores vacíos

['foo', '',,,'',,null, ' ', 3, true, [], [1], {}, undefined, ()=>{}].filter(String)

// ["foo", null, " ", 3, true, [1], Object {}, undefined, ()=>{}]

Respondido 28 Jul 19, 16:07

El primer soporte de IE para el filtro es el modo estándar IE9. - yincrash

para javascript puro debería ser arr = arr.filter(function(n){return n; }); - iluminar

foo.join("").split("") solo parece funcionar si las cadenas son caracteres únicos - Atav32

Su código JavaScript puro tiene un error. Si la matriz tiene un valor con "0", el valor se filtrará porque "0" es falso. Lo que quieres es: arr.filter (function (n) {return (n! == undefined && n! == null);}); - Juan Kurlak

ES6 puede hacerlo aún más simple arr.filter(e=>e) y esto se puede encadenar por mapa, reducir, etc. - Sheepy

Si necesita eliminar TODOS los valores vacíos ("", nulo, indefinido y 0):

arr = arr.filter(function(e){return e}); 

Para eliminar valores vacíos y saltos de línea:

arr = arr.filter(function(e){ return e.replace(/(\r\n|\n|\r)/gm,"")});

Ejemplo:

arr = ["hello",0,"",null,undefined,1,100," "]  
arr.filter(function(e){return e});

Regreso:

["hello", 1, 100, " "]

ACTUALIZAR (basado en el comentario de Alnitak)

En algunas situaciones, es posible que desee mantener "0" en la matriz y eliminar cualquier otra cosa (nulo, indefinido y ""), esta es una forma:

arr.filter(function(e){ return e === 0 || e });

Regreso:

["hello", 0, 1, 100, " "]

contestado el 18 de mayo de 18 a las 07:05

Sí, esto es bueno porque elimina "" también. - Vladimirs

La función de prueba podría ser un poco más explícita: function(e){return !!e} - Koen

@Koen Tenga en cuenta que !!e incluirá NaN (a diferencia de 0) donde e no lo haría (como 0). - Sheepy

En realidad, no responde a la pregunta que se hizo. - Alnitak

O usar var myarr=[1, 2,, 3,, 3,undefined,,"",,0, 4,, 4,, 5,, 6,,,,].filter(Boolean); elimina indefinido, "" y 0 - Marcos Schultheiss

Simplemente un forro:

[1, false, "", undefined, 2].filter(Boolean); // [1, 2]

o utilizando underscorejs.org:

_.filter([1, false, "", undefined, 2], Boolean); // [1, 2]
// or even:
_.compact([1, false, "", undefined, 2]); // [1, 2]

Respondido 14 ago 13, 14:08

Esto es realmente genial; sin embargo, tengo una pregunta nueva: parece que estás usando un nombre de clase como una llamada de función, ¿eso es encasillado? No he visto esto antes y no estoy seguro de entender por qué pasar Boolean funciona como una función ... - Andrés

Si tratas Boolean como función, simplemente regresará true or false si el valor es verdadero / falso. - andlrc

Tu no eres tratar Booleano como función; eso is Una función. (Una función completamente normal, excepto que está implementada de forma nativa). Alguien necesita investigar un poco sobre el modelo de objetos de JavaScript. ;) - ELLIOTTCABLE

@ELLIOTTCABLE Voy a dejar esto aquí, (true).constructor === Boolean. Y luego dime si podemos hacer esto con otras incorporaciones en JS. ;)) (por supuesto, excluyó los otros 5 constructores incorporados. (Cadena, Matriz, Objeto, Función, Número)) - andlrc

Fallará ambos si hay un valor 0 en la matriz: sai ram

Si tiene Javascript 1.6 o posterior, puede usar Array.filter usando un trivial return true función de devolución de llamada, por ejemplo:

arr = arr.filter(function() { return true; });

desde .filter omite automáticamente los elementos que faltan en la matriz original.

La página de MDN vinculada anteriormente también contiene una buena versión de verificación de errores de filter que se puede utilizar en intérpretes de JavaScript que no admiten la versión oficial.

Tenga en cuenta que esto no eliminará null entradas ni entradas con un explícito undefined valor, pero el OP solicitó específicamente entradas "faltantes".

Respondido 10 Jul 14, 08:07

¡Estás bien! Puede ser tan simple como esto (¡y funciona!): Test3 = [1,2,, 3,, 3 ,,,, 7 ,,, 7 ,,, 0 ,,, 4,, 4,, 5 ,, 6, indefinido ,, nulo ,,]; printp ("Usando el filtrado nativo de la matriz:", test3.filter (function (value) {return (value == undefined)? 0: 1;})); - jose pineda

+1 Como dijo Alnitak, tienen el código que se puede usar en el caso de no tener js 1.6 disponible - Sameer Alibhai

@katsh lo he aclarado: el código de arriba trabajar para eliminar entradas para las que no existe ningún valor, que (posteriormente) aprendí que es semánticamente diferente al caso de una clave que existe pero que tiene undefined como su valor dado. - Alnitak

Para eliminar entradas no definidas o nulas, simplemente haga una pequeña modificación ... arr = arr.filter (function (v) {return v;}); - alan cn

@AlanCN has perdido completamente mi punto. El OP pidió eliminar que falta entradas, mientras que la mayor parte de las respuestas aquí (incorrectamente) eliminan cualquier entrada "falsey". - Alnitak

Para quitar agujeros, debe usar

arr.filter(() => true)
arr.flat(0) // New in ES2019, check compatibility before using this

Para eliminar agujero, nulo y no definido:

arr.filter(x => x != null)

Para eliminar los valores de hole, y, falsy (null, undefined, 0, -0, 0n, NaN, "", false, document.all):

arr.filter(x => x)

arr = [, null, (void 0), 0, -0, 0n, NaN, false, '', 42];
console.log(arr.filter(() => true)); // [null, (void 0), 0, -0, 0n, NaN, false, '', 42]
console.log(arr.filter(x => x != null)); // [0, -0, 0n, NaN, false, "", 42]
console.log(arr.filter(x => x)); // [42]

Respondido el 15 de diciembre de 20 a las 06:12

Esto debería ocupar un lugar destacado en la respuesta. ¿Puede ampliar lo que quiere decir con agujeros / agujero ...? - samayo

Los agujeros de @samayo son elementos de matriz sin llenar, es decir [, ,] - Jimmy Obonyo Abor

Mediante el uso arr.filter(x => x), JS comprobará si x es verdadero o falso, es decir if (x), por lo tanto, solo se asignará el valor de veracidad a la nueva lista. - kuan yu chu

La forma limpia de hacerlo.

var arr = [0,1,2,"Thomas","false",false,true,null,3,4,undefined,5,"end"];
arr = arr.filter(Boolean);
// [1, 2, "Thomas", "false", true, 3, 4, 5, "end"]

respondido 26 mar '11, 16:03

Los elementos vacíos son undefined; esto básicamente elimina todos los valores falsos. - pimvdb

ES6 simple

['a','b','',,,'w','b'].filter(v => v);

respondido 22 mar '17, 20:03

Esto no funciona: [1, 'two', null, undefined, , NaN, false, true, 0].filter(v => v). - cremallera

ES6:

let newArr = arr.filter(e => e);

contestado el 27 de mayo de 20 a las 07:05

Con subrayado / Lodash:

Caso de uso general:

_.without(array, emptyVal, otherEmptyVal);
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);

Con vacíos:

_.without(['foo', 'bar', '', 'baz', '', '', 'foobar'], '');
--> ["foo", "bar", "baz", "foobar"]

Vea documentación lodash para sin.

Respondido 10 Jul 15, 17:07

El problema con #compact es que elimina los valores falsos. Entonces, si su matriz contiene valores 0, también se eliminarán. - Samuel Brandao

Sólo ES6 y el método de versiones más recientes, suponga que la matriz está a continuación:

 const arr = [1,2,3,undefined,4,5,6,undefined,7,8,undefined,undefined,0,9];

Manera simple:

 const clearArray = arr.filter( i => i );

Respondido 16 Oct 18, 07:10

Si usar una biblioteca es una opción, sé que underscore.js tiene una función llamada compact () http://documentcloud.github.com/underscore/ también tiene varias otras funciones útiles relacionadas con matrices y colecciones.

Aquí hay un extracto de su documentación:

_.compact (matriz)

Devuelve una copia de la matriz con todos los valores falsos eliminados. En JavaScript, false, null, 0, "", undefined y NaN son falsos.

_.compact ([0, 1, falso, 2, '', 3]);

=> [1, 2, 3]

Respondido el 19 de diciembre de 11 a las 18:12

También elimina elementos no vacíos, elementos definidos como 0. - Timoteo Gu

@Alnitak

En realidad, Array.filter funciona en todos los navegadores si agrega algún código adicional. Vea abajo.

var array = ["","one",0,"",null,0,1,2,4,"two"];

function isempty(x){
if(x!=="")
    return true;
}
var res = array.filter(isempty);
document.writeln(res.toJSONString());
// gives: ["one",0,null,0,1,2,4,"two"]  

Este es el código que necesita agregar para IE, pero el filtro y la programación funcional vale la pena.

//This prototype is provided by the Mozilla foundation and
//is distributed under the MIT license.
//http://www.ibiblio.org/pub/Linux/LICENSES/mit.license

if (!Array.prototype.filter)
{
  Array.prototype.filter = function(fun /*, thisp*/)
  {
    var len = this.length;
    if (typeof fun != "function")
      throw new TypeError();

    var res = new Array();
    var thisp = arguments[1];
    for (var i = 0; i < len; i++)
    {
      if (i in this)
      {
        var val = this[i]; // in case fun mutates this
        if (fun.call(thisp, val, i, this))
          res.push(val);
      }
    }

    return res;
  };
}

respondido 18 mar '09, 23:03

Esta debería ser la respuesta aceptada, ya que funciona de inmediato. Muchas gracias. - tony

@Tony no, no debería, porque un elemento con una cadena vacía no es lo mismo que un "elemento vacío", siendo este último lo que pidió el OP. - Alnitak

Como nadie más lo mencionó y la mayoría de las personas han incluido un subrayado en su proyecto, también puede usar _.without(array, *values);.

_.without(["text", "string", null, null, null, "text"], null)
// => ["text", "string", "text"]

respondido 08 nov., 14:18

Puede que le resulte más fácil recorrer su matriz y construir una nueva matriz a partir de los elementos que desea mantener de la matriz que tratando de hacer un bucle y unir como se ha sugerido, ya que se modificó la longitud de la matriz mientras se repite más puede introducir problemas.

Podrías hacer algo como esto:

function removeFalsyElementsFromArray(someArray) {
    var newArray = [];
    for(var index = 0; index < someArray.length; index++) {
        if(someArray[index]) {
            newArray.push(someArray[index]);
        }
    }
    return newArray;
}

En realidad, aquí hay una solución más genérica:

function removeElementsFromArray(someArray, filter) {
    var newArray = [];
    for(var index = 0; index < someArray.length; index++) {
        if(filter(someArray[index]) == false) {
            newArray.push(someArray[index]);
        }
    }
    return newArray;
}

// then provide one or more filter functions that will 
// filter out the elements based on some condition:
function isNullOrUndefined(item) {
    return (item == null || typeof(item) == "undefined");
}

// then call the function like this:
var myArray = [1,2,,3,,3,,,,,,4,,4,,5,,6,,,,];
var results = removeElementsFromArray(myArray, isNullOrUndefined);

// results == [1,2,3,3,4,4,5,6]

Entiende la idea, entonces podría tener otros tipos de funciones de filtro. Probablemente más de lo que necesitas, pero me sentía generoso ...;)

respondido 11 nov., 08:16

¿Qué pasa con esto (ES6): Para eliminar el valor Falsy de una matriz.

var arr = [0,1,2,"test","false",false,true,null,3,4,undefined,5,"end"];

arr.filter((v) => (!!(v)==true));

//output:

//[1, 2, "test", "false", true, 3, 4, 5, "end"]

Respondido el 11 de diciembre de 15 a las 11:12

Debe usar el filtro para obtener una matriz sin elementos vacíos. Ejemplo en ES6

const array = [1, 32, 2, undefined, 3];
const newArray = array.filter(arr => arr);

Respondido el 28 de diciembre de 17 a las 10:12

Al usar la respuesta más votada anterior, el primer ejemplo, obtenía caracteres individuales para longitudes de cadena superiores a 1. A continuación se muestra mi solución para ese problema.

var stringObject = ["", "some string yay", "", "", "Other string yay"];
stringObject = stringObject.filter(function(n){ return n.length > 0});

En lugar de no regresar si no está definido, regresamos si la longitud es mayor que 0. Espero que eso ayude a alguien.

Devoluciones

["some string yay", "Other string yay"]

Respondido 21 Oct 14, 23:10

+1 ya que esto es muy práctico y exactamente lo que normalmente necesito para trabajar con matrices de cadenas, pero tenga en cuenta que esto elimina los números (si no están en forma de cadena) ya que no tienen una longitud. ["", "some string yay", "", "", 123, "Other string yay"].filter(function(n){ return n.length > 0}) //gives your same result removing 123 Reemplazar esa función ... con String, irónicamente, deja números pero daría el mismo resultado en su matriz dada. - aamarcas

¿Qué pasa con eso?

js> [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,].filter(String).join(',')
1,2,3,3,0,4,4,5,6

Respondido el 12 de diciembre de 10 a las 18:12

Simplemente estoy agregando mi voz a la anterior "llame a ES5 Array..filter() con un constructor global ”golf-hack, pero sugiero usar Object en lugar de String, Boolean o el Number como se sugirió anteriormente.

Específicamente, ES5 filter() ya no se activa para undefined elementos dentro de la matriz; por lo que una función que devuelve universalmente true, que regresa todos los elementos filter() hits, necesariamente solo devolverán noundefined elementos:

> [1,,5,6,772,5,24,5,'abc',function(){},1,5,,3].filter(function(){return true})
[1, 5, 6, 772, 5, 24, 5, 'abc', function (){}, 1, 5, 3]

Sin embargo, escribiendo ...(function(){return true;}) es más largo que escribir ...(Object); y el valor de retorno de la Object constructor estará, bajo cualquier circunstancia, algún tipo de objeto. A diferencia de los constructores de boxeo primitivos sugeridos anteriormente, ningún valor de objeto posible es falsey y, por lo tanto, en una configuración booleana, Object es una abreviatura de function(){return true}.

> [1,,5,6,772,5,24,5,'abc',function(){},1,5,,3].filter(Object)
[1, 5, 6, 772, 5, 24, 5, 'abc', function (){}, 1, 5, 3]

respondido 27 nov., 12:15

CUIDADO: el filtro (Cadena) y el filtro (Objeto) no filtran nulos o números. Debido a que un constructor también es una función, puede pasar String para filtrar, es decir someArray.filter(String); es en realidad equivalente a someArray.filter(function(x){ return String(x); });. Si desea eliminar todos los valores falsos someArray.filter(Boolean); funciona para eliminar 0, -0, NaN, falso, '', nulo e indefinido. - robogato

Buena respuesta, aunque me pregunto sobre la sobrecarga de rendimiento de llamar al Object constructor en contraposición al return true método. @robocat el OP pidió que se eliminen los elementos vacíos, no los nulos. - Alnitak

Prefiero la solución más corta y clara, excepto en bucles estrechos. Preferencia personal, supongo. (= - ELLIOTTCABLE

var data = [null, 1,2,3];
var r = data.filter(function(i){ return i != null; })

console.log(r) 

[*]

respondido 30 mar '17, 05:03

¡Esta es la forma obviamente correcta de hacerlo y debería estar en la parte superior! - martín andersson

Eliminar todos los elementos vacíos

Si una matriz contiene objetos, matrices y cadenas vacías junto con otros elementos vacíos, podemos eliminarlos con:

const arr = [ [], ['not', 'empty'], {}, { key: 'value' }, 0, 1, null, 2, "", "here", " ", 3, undefined, 3, , , , , , 4, , 4, , 5, , 6, , , ]

let filtered = JSON.stringify(
  arr.filter((obj) => {
    return ![null, undefined, ''].includes(obj)
  }).filter((el) => {
    return typeof el != "object" || Object.keys(el).length > 0
  })
)

console.log(JSON.parse(filtered))

Compactación simple (eliminando elementos vacíos de una matriz)

Con ES6:

const arr = [0, 1, null, 2, "", 3, undefined, 3, , , , , , 4, , 4, , 5, , 6, , , ,]

let filtered = arr.filter((obj) => { return ![null, undefined].includes(obj) })

console.log(filtered)

Con JavaScript simple ->

var arr = [0, 1, null, 2, "", 3, undefined, 3, , , , , , 4, , 4, , 5, , 6, , , ,]

var filtered = arr.filter(function (obj) { return ![null, undefined].includes(obj) })

console.log(filtered)

Respondido el 25 de enero de 20 a las 00:01

Oye, solo quería preguntar si hay alguna manera de eliminar elementos nulos de una matriz 2D / anidada en ES 6. - Mob_Abominator

Hola @Mob_Abominator, ciertamente se puede hacer, prueba esta misma lógica accediendo a la matriz anidada. - Zlatko Alomerovic

Puede utilizar el filtro con índice y in operador

let a = [1,,2,,,3];
let b = a.filter((x,i)=> i in a);

console.log({a,b});

Respondido el 01 de diciembre de 20 a las 17:12

suponiendo que la matriz contiene números de índice ...? - Magne

@Magne en JS, los índices de matrices estándar son números. Los objetos JS pueden contener otras claves además de números. Las matrices JS también son objeto y puede ponerle un par clave-valor, por ejemplo let a=[]; a.abc=1 - pero generalmente ningún cuerpo lo hace (es bastante exótico hacerlo, porque en su lugar, puede usar matrices, por ejemplo, object {}). Y cuando usa una matriz de una manera tan exótica, entonces los métodos de matriz JS estándar como map, filter etc. ignorará tales pares clave-valor - mi solución basada en filter e ignóralo también. Es bastante obvio que OP pregunta sobre la matriz JS estándar (porque no menciona un caso de uso tan exótico): Kamil Kielczewski

sí, no me refería a eso, en realidad, pero gracias por aclarar eso también. Rocé la parte superior de desarrollador.mozilla.org/en-US/docs/Web/JavaScript/Reference/… y cree confusamente el in El operador devolvió el valor en la matriz. Así que pensé que solo funcionaría si los valores en la matriz eran los mismos que los números de índice por los que se quería filtrar. Pero ahora veo in se refiere a las propiedades (como índices), no a los valores, de una matriz. - Magne

@Magne ok, lo edito ahora - Kamil Kielczewski

genial, voté a favor ahora. - Magne

Otra forma de hacerlo es aprovechar la propiedad de longitud de la matriz: empaque los elementos no nulos a la 'izquierda' de la matriz y luego reduzca la longitud. Es un algoritmo en el lugar -no asigna memoria, es una lástima para el recolector de basura-, y tiene muy buen comportamiento en el mejor / promedio / peor caso.

Esta solución, en comparación con otras aquí, es entre 2 y 50 veces más rápida en Chrome y de 5 a 50 veces más rápida en Firefox, como puede ver aquí: http://jsperf.com/remove-null-items-from-array

El siguiente código agrega el método 'removeNull' no enumerable al Array, que devuelve 'this' para la conexión en cadena:

var removeNull = function() {
    var nullCount = 0           ;
    var length    = this.length ;
    for (var i=0, len=this.length; i<len; i++) { if (!this[i]) {nullCount++} }
    // no item is null
    if (!nullCount) { return this}
    // all items are null
    if (nullCount == length) { this.length = 0; return this }
    // mix of null // non-null
    var idest=0, isrc=length-1;
    length -= nullCount ;                
    while (true) {
         // find a non null (source) slot on the right
         while (!this[isrc])  { isrc--; nullCount--; } 
         if    (!nullCount) { break }       // break if found all null
         // find one null slot on the left (destination)
         while ( this[idest]) { idest++  }  
         // perform copy
         this[idest]=this[isrc];
         if (!(--nullCount)) {break}
         idest++;  isrc --; 
    }
    this.length=length; 
    return this;
};  

Object.defineProperty(Array.prototype, 'removeNull', 
                { value : removeNull, writable : true, configurable : true } ) ;

contestado el 25 de mayo de 13 a las 20:05

Buena respuesta, ¡aunque sería bueno ver algunos casos de prueba para mostrarlo en acción! - Alnitak

Esta respuesta es muy fascinante, pero me recuerda un poco a mirar una computadora construida en 1945 cuando tengo un teléfono inteligente: arr.filter(e => e). - agm1984

@ agm1984 su teléfono inteligente no es inteligente - Hernán Eche

Eso puede depender de tu definición de smart--como el verbo, causar un dolor punzante agudo. Esto es relevante debido al dolor físico si uso mi teléfono como arma debido a tu comentario. - agm1984

Todos los elementos vacíos se pueden eliminar de una matriz simplemente usando array.filter(String); Devuelve todos los elementos no vacíos de una matriz en javascript.

contestado el 21 de mayo de 20 a las 07:05

Tristemente acepta null durante el uso Boolean lo quita una cadena vacía. - Paul Watson

@PaulWatson Sí, desafortunadamente, acepta null como una cadena, pero puede eliminar elementos vacíos de la matriz. Espero que entiendas - Bhupesh

Esto funciona, lo probé en AppJet (puede copiar y pegar el código en su IDE y presionar "recargar" para ver cómo funciona, no es necesario crear una cuenta)

/* appjet:version 0.1 */
function Joes_remove(someArray) {
    var newArray = [];
    var element;
    for( element in someArray){
        if(someArray[element]!=undefined ) {
            newArray.push(someArray[element]);
        }
    }
    return newArray;
}

var myArray2 = [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,];

print("Original array:", myArray2);
print("Clenased array:", Joes_remove(myArray2) );
/*
Returns: [1,2,3,3,0,4,4,5,6]
*/

respondido 11 nov., 08:17

Esto solo parece funcionar "por accidente", ya que es el acto de enumerar las claves a través de for ... in que en realidad provoca la omisión de elementos faltantes. La prueba para undefined solo sirve para eliminar elementos reales que se establecen explícitamente en ese valor. - Alnitak

foo = [0, 1, 2, "", , false, 3, "four", null]

foo.filter(function(e) {
    return e === 0 ? '0' : e
})

devoluciones

[0, 1, 2, 3, "four"]

Respondido 25 ago 15, 02:08

'Mal uso' del bucle for ... in (object-member). => Solo los valores veraces aparecen en el cuerpo del bucle.

// --- Example ----------
var field = [];

field[0] = 'One';
field[1] = 1;
field[3] = true;
field[5] = 43.68;
field[7] = 'theLastElement';
// --- Example ----------

var originalLength;

// Store the length of the array.
originalLength = field.length;

for (var i in field) {
  // Attach the truthy values upon the end of the array. 
  field.push(field[i]);
}

// Delete the original range within the array so that
// only the new elements are preserved.
field.splice(0, originalLength);

respondido 14 mar '16, 12:03

el código es correcto, el comentario es incorrecto. El acto de usar for ... in es lo que elimina las claves indefinidas de la matriz, pero en realidad no tiene código aquí para aceptar solo valores "verdaderos" - Alnitak

Esto podría ayudarlo a: https://lodash.com/docs/4.17.4#remove

var details = [
            {
                reference: 'ref-1',
                description: 'desc-1',
                price: 1
            }, {
                reference: '',
                description: '',
                price: ''
            }, {
                reference: 'ref-2',
                description: 'desc-2',
                price: 200
            }, {
                reference: 'ref-3',
                description: 'desc-3',
                price: 3
            }, {
                reference: '',
                description: '',
                price: ''
            }
        ];

        scope.removeEmptyDetails(details);
        expect(details.length).toEqual(3);

scope.removeEmptyDetails = function(details){
            _.remove(details, function(detail){
                return (_.isEmpty(detail.reference) && _.isEmpty(detail.description) && _.isEmpty(detail.price));
            });
        };

respondido 30 mar '17, 06:03

var data= { 
    myAction: function(array){
        return array.filter(function(el){
           return (el !== (undefined || null || ''));
        }).join(" ");
    }
}; 
var string = data.myAction(["I", "am","", "working", "", "on","", "nodejs", "" ]);
console.log(string);

Salida:

Estoy trabajando en nodejs

Eliminará el elemento vacío de la matriz y mostrará otro elemento.

Respondido 21 Feb 18, 09:02

salida: 'Estoy trabajando en nodejs'. eliminará el elemento vacío de la matriz y mostrará otro elemento. - Jitendra virani

Mejoré tu respuesta. Intente hacer una respuesta simple, clara y legible;) - OGM

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.