Uklonite prazne elemente iz niza u JavaScriptu

Kako ukloniti prazne elemente iz niza u JavaScriptu?

Postoji li jednostavan način, ili trebam prolaziti kroz to i ukloniti ih ručno?

Odgovor #1

Nekoliko jednostavnih načina:

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]

ili - Klasičan način: jednostavna iteracija

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
// [1,2,3,3,[],Object{},5,6]

jQuery :

var arr = [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,];
    
arr = $.grep(arr, n => n == 0 || n);
// [1, 2, 3, 3, 0, 4, 4, 5, 6]

Odgovor #2

UREDI: Ovo je pitanje odgovoreno skoro prije devet godina kada nije bilo mnogo korisnih ugrađenih metoda u Array.prototype.

Sada, zasigurno, preporučio bih vam da koristite metodu filter.

Imajte na umu da će vam ova metoda vratiti novi niz s elementima koji zadovoljavaju kriterije funkcije povratnog poziva koju joj date.

Na primjer, ako želite ukloniti null ili undefined vrijednosti:

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

To će ovisiti o tome što smatrate 'praznim', na primjer, ako radite sa stringovima, gornja funkcija ne bi uklonila elemente koji su prazan string.

Jedan tipičan obrazac koji često vidim kako se koristi jest uklanjanje elemenata koji su falsi, uključujući prazni niz "", 0, NaN, null, undefined i false.

Možete proslijediti metodi filter konstruktor funkciju Boolean, ili vratiti isti element u funkciji kriterija filtriranja, na primjer:

var filtered = array.filter(Boolean);

Ili

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

Na oba načina, ovo funkcionira jer metoda filter u prvom slučaju poziva konstruktor Boolean kao funkciju, pretvarajući vrijednost, a u drugom slučaju metoda filter interno implicitno pretvara povratnu vrijednost callback funkcije u Boolean.

Ako radite s rijetkim nizovima i pokušavate se riješiti "praznina", možete koristiti metodu filter prosljeđujući povratni poziv koji vraća true, na primjer:

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

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

Stari odgovor: Nemoj to raditi!

Koristim ovu metodu, proširujući izvorni Array prototip:

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

Ili jednostavno možete gurnuti postojeće elemente u drugi niz:

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

Odgovor #3

Ako trebate ukloniti SVE prazne vrijednosti ("", null, undefined i 0):

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

Za uklanjanje praznih vrijednosti i prijeloma linija:

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

Primjer :

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

Povratak :

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

AŽURIRANJE (na temelju Alnitakovog komentara)

U nekim situacijama možda ćete htjeti zadržati "0" u nizu i ukloniti sve ostalo (null, undefined i ""), ovo je jedan način:

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

Povratak :

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

Odgovor #4

Jednostavno u jednoj liniji:

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

ili korištenjem underscorejs.org:

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

Odgovor #5

Ako imate Javascript 1.6 ili noviji, možete koristiti Array.filter koristeći trivijalnu return true callback funkciju, npr.:

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

budući da .filter automatski preskače nedostajuće elemente u izvornom nizu.

Gornja MDN stranica također sadrži lijepu verziju filter za provjeru pogrešaka koja se može koristiti u JavaScript interpreterima koji ne podržavaju službenu verziju.

Imajte na umu da ovo neće ukloniti null unose niti unose s eksplicitnom undefined vrijednošću, ali je OP posebno zatražio "nedostajuće" unose.

Odgovor #6

Za uklanjanje rupa trebali biste koristiti

arr.filter(() => true)
arr.flat(0) // New in ES2019

Za uklanjanje praznina, null i undefined:

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

Za uklanjanje rupa i lažnih (null, undefined, 0, -0, 0n, NaN, "", false, document.all) vrijednosti:

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]

Napomena :

  • Rupe su neki indeksi niza bez elemenata.
arr = [, ,];
console.log(arr[0], 0 in arr, arr.length); // undefined, false, 2; arr[0] is a hole
arr[42] = 42;
console.log(arr[10], 10 in arr, arr.length); // undefined, false, 43; arr[10] is a hole

arr1 = [1, 2, 3];
arr1[0] = (void 0);
console.log(arr1[0], 0 in arr1); // undefined, true; a[0] is undefined, not a hole

arr2 = [1, 2, 3];
delete arr2[0]; // NEVER do this please
console.log(arr2[0], 0 in arr2, arr2.length); // undefined, false; a[0] is a hole
  • Sve gore navedene metode vraćaju kopiju zadane niz, ne mijenjajući je na licu mjesta.
arr = [1, 3, null, 4];
filtered = arr.filter(x => x != null);
console.log(filtered); // [1, 3, 4]
console.log(arr); // [1, 3, null, 4]; not modified

Odgovor #7

Čist način da se to učini.

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

Odgovor #8

Zapravo, možete koristiti ES6+ metode, pretpostavimo da je niz sljedeći:

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

A odgovor bi mogao biti na jedan od ova dva načina:

  • Prvi način:

    const clearArray = arr.filter(i => i); // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

  • Drugi način:

    const clearArray = arr.filter(Boolean); // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Ažuriranje 14. listopada 2022.

Ta dva odgovora nisu potpuno točna, čak ni u danom primjeru, da, radi, ali obrati pažnju na broj 0 u danom nizu, na oba načina broj nula nestaje i očito je povezan s provjerom elemenata korištenjem boolean prisile.

Potpuno ispravan način je provjeriti nul vrijednosti i ukloniti ih:

const notNil = (i) => !(typeof i === 'undefined' || i === null);

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


const arr = [1,2,3,undefined,4,5,6,undefined,7,8,undefined,undefined,0,9];
const notNil = (i) => !(typeof i === 'undefined' || i === null);

console.log("Not nil: ", arr.filter(notNil));

Odgovor #9

ES6:

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

Odgovor #10

Jednostavan ES6

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

Odgovor #11

Uz Underscore/Lodash:

Opći slučaj uporabe:

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

S praznima:

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

Pogledajte lodash dokumentaciju za funkciju without.

Odgovor #12

Ako je korištenje biblioteke opcija, znam da underscore.js ima funkciju koja se zove compact() http://documentcloud.github.com/underscore/ također ima nekoliko drugih korisnih funkcija vezanih uz nizove i kolekcije.

Evo isječak iz njihove dokumentacije:

_.compact(niz)

Vraća kopiju niza s uklonjenim svim neistinitim vrijednostima. U JavaScriptu, false, null, 0, "", undefined i NaN svi su neistiniti.

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

=> [1, 2, 3]

Odgovor #13

@Alnitak

Zapravo Array.filter radi na svim preglednicima ako dodate neki dodatni kod. Pogledajte dolje.

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

Ovo je kod koji trebate dodati za IE, ali filter i funkcionalno programiranje vrijede po mom mišljenju.

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

Odgovor #14

Budući da nitko drugi nije spomenuo i većina ljudi ima uključen underscore u svom projektu, također možete koristiti _.without(array, *values);.

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

Odgovor #15

Za uklanjanje nedefiniranih elemenata iz niza možete jednostavno koristiti

const array = [
  { name: "tim", age: 1 },
  undefined,
  { name: "ewrfer", age: 22 },
  { name: "3tf5gh", age: 56 },
  null,
  { name: "kygm", age: 19 },
  undefined,
];
console.log(array.filter(Boolean));

Odgovor #16

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

foo.filter(e => e === 0 ? true : e)

vraća

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

Ako ste sigurni da u svom nizu nećete imati nijedan 0, to može izgledati malo ljepše:

foo.filter(e => e)

Povezani članci