Entfernen Sie leere Elemente aus einem Array in Javascript
https://stackoverflow.com/questions/281264
-
07-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie entferne ich leere Elemente aus einem Array in JavaScript?
Gibt es eine einfache Möglichkeit, oder brauche ich durch sie Schleife und entfernen Sie sie manuell?
Lösung
EDIT:. Diese Frage vor fast 9 Jahren beantwortet wurde, wenn es nicht viel sinnvoll integrierte Methoden in der Array.prototype waren
Nun, auf jeden Fall würde ich empfehlen Sie nur die filter Methode zu verwenden.
im Kopf Nehmen Sie, dass diese Methode kehren Sie ein neues Array mit den Elementen, die die Kriterien der Callback-Funktion übergeben Sie es aus, zum Beispiel, wenn Sie null oder undefined Werte entfernen möchten :
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);
Es wird davon abhängen, was Sie als „leer“ sein, zum Beispiel, wenn Sie mit Strings zu tun, würde die obige Funktion nicht Elemente entfernen, die eine leere Zeichenfolge sind.
Ein gemeinsames Muster, das ich oft gebraucht wird Elemente zu entfernen, die falsy , zu denen eine leere Zeichenfolge "", 0, NaN, null, undefined und false.
Sie können einfach auf die filter-Methode übergeben, die Boolean Konstruktorfunktion oder einfach das gleiche Element in den Filterkriterium Funktion zurückgeben, zum Beispiel:
var filtered = array.filter(Boolean);
oder
var filtered = array.filter(function(el) { return el; });
In beiden Möglichkeiten, dies funktioniert, weil die filter Verfahren im ersten Fall, rufen den Boolean Konstruktor als eine Funktion, um den Wert umwandelt, und im zweiten Fall die filter Methode intern wandelt den Rückgabewert des Callback implizit Boolean.
Wenn Sie mit spärlichen Arrays arbeiten, und Sie versuchen, loszuwerden, die „Löcher“ zu bekommen, können Sie einfach die filter Methode verwenden, um einen Rückruf vorbei, die true zurückgibt, zum Beispiel:
var sparseArray = [0, , , 1, , , , , 2, , , , 3],
cleanArray = sparseArray.filter(function () { return true });
console.log(cleanArray); // [ 0, 1, 2, 3 ]
Alt Antwort: Tu das nicht
Ich benutze diese Methode, die native Array-Prototyp erstreckt:
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);
Oder Sie können einfach die vorhandenen Elemente in andere Array drücken:
// 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,,,,]);
Andere Tipps
Einfache Möglichkeiten:
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]
oder - (nur für Single Array-Elemente vom Typ "text")
['','1','2',3,,'4',,undefined,,,'5'].join('').split('');
// output: ["1","2","3","4","5"]
oder - klassische Art und Weise: einfache Iteration
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]
über 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]
UPDATE - nur eine weitere schnelle, kühle Art und Weise (mit 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;
delete temp; // discard the variable
arr // [1, 2, 3, 3, 4, 4, 5, 6]
entfernen leere Werte
['foo', '',,,'',,null, ' ', 3, true, [], [1], {}, undefined, ()=>{}].filter(String)
// ["foo", null, " ", 3, true, [1], Object {}, undefined, ()=>{}]
Wenn Sie alle leeren Werte ( "", null, nicht definiert und 0) entfernen:
arr = arr.filter(function(e){return e});
Um leere Werte zu entfernen und Zeilenumbrüche:
arr = arr.filter(function(e){ return e.replace(/(\r\n|\n|\r)/gm,"")});
Beispiel:
arr = ["hello",0,"",null,undefined,1,100," "]
arr.filter(function(e){return e});
Zurück:
["hello", 1, 100, " "]
UPDATE (basierend auf Alnitak Kommentar)
In einigen Situationen Sie können „0“ in der Anordnung zu halten und alles andere entfernen (null, nicht definiert und „“), das ist eine Art und Weise:
arr.filter(function(e){ return e === 0 || e });
Zurück:
["hello", 0, 1, 100, " "]
Einfach Motto:
[1, false, "", undefined, 2].filter(Boolean); // [1, 2]
oder mit underscorejs.org :
_.filter([1, false, "", undefined, 2], Boolean); // [1, 2]
// or even:
_.compact([1, false, "", undefined, 2]); // [1, 2]
Wenn Sie haben Javascript 1.6 oder höher können Sie verwenden, Array.filter eine triviale return true Callback-Funktion, zum Beispiel:
arr = arr.filter(function() { return true; });
da .filter automatisch überspringt fehlende Elemente in der ursprünglichen Anordnung.
Die MDN Seite oben auch verknüpft enthält eine nette Fehlerprüfung Version von filter, die in JavaScript-Interpreter verwendet werden können, die die offizielle Version nicht unterstützen.
Beachten Sie, dass dies nicht null Einträge noch Einträge mit einem expliziten undefined Wert, aber die OP ausdrücklich darum gebeten „fehlenden“ Einträge.
Löcher Zum Entfernen, sollten Sie verwenden
arr.filter(() => true)
arr.flat(0) // Currently stage 3, check compatibility before using this
Für Loch zu entfernen und, falsy (null, nicht definiert, 0, -0, NaN, "", false, document.all) Werte:
arr.filter(x => x)
Für Loch zu entfernen, null und undefined:
arr.filter(x => x != null)
arr = [, null, (void 0), 0, -0, NaN, false, '', 42];
console.log(arr.filter(() => true)); // [null, (void 0), 0, -0, NaN, false, '', 42]
console.log(arr.filter(x => x)); // [42]
console.log(arr.filter(x => x != null)); // [0, -0, NaN, false, "", 42]
Die saubere Art und Weise, es zu tun.
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"]
Einfach ES6
['a','b','',,,'w','b'].filter(v => v);
Mit Unders / Lodash:
Allgemeiner Anwendungsfall:
_.without(array, emptyVal, otherEmptyVal);
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
Mit Leergut:
_.without(['foo', 'bar', '', 'baz', '', '', 'foobar'], '');
--> ["foo", "bar", "baz", "foobar"]
Siehe lodash Dokumentation ohne .
Just ES6 und neuere Versionen Methode Array übernehmen unter:
const arr = [1,2,3,undefined,4,5,6,undefined,7,8,undefined,undefined,0,9];
Einfache Art und Weise:
const clearArray = arr.filter( i => i );
Wenn eine Bibliothek ist eine Option Ich weiß Underscore.js eine Funktion namens compact () http: // documentcloud.github.com/underscore/ es auch mehrere andere nützliche Funktionen im Zusammenhang mit Arrays und Sammlungen hat.
Hier ist ein Auszug aus ihrer Dokumentation:
_. Compact (array)
Gibt eine Kopie des Arrays mit allen falsy entfernt Werte. In JavaScript, false, null, 0, "", undefiniert und NaN sind alle falsy.
_ compact ([0, 1, false, 2 '', 3]);.
=> [1, 2, 3]
@Alnitak
Eigentlich Array.filter auf allen Browsern funktioniert, wenn Sie etwas mehr Code hinzufügen. Siehe unten.
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"]
Dies ist der Code, den Sie für den Internet Explorer hinzufügen müssen, aber Filter und Functional programmingis wert ist imo.
//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;
};
}
Da sonst niemand erwähnt, und die meisten Menschen haben Strich in ihrem Projekt enthalten Sie auch _.without(array, *values); verwenden können.
_.without(["text", "string", null, null, null, "text"], null)
// => ["text", "string", "text"]
Sie können es einfacher, eine Schleife über das Array finden und ein neues Array bauen aus dem Array aus den Artikeln, die Sie behalten wollen, als durch eine Schleife und Spleiß versuchen, so wird vorgeschlagen, da, während er die Länge des Arrays Modifizieren geschleift über wird, kann Probleme einführen.
Sie können etwas tun:
function removeFalsyElementsFromArray(someArray) {
var newArray = [];
for(var index = 0; index < someArray.length; index++) {
if(someArray[index]) {
newArray.push(someArray[index]);
}
}
return newArray;
}
Eigentlich ist hier eine allgemeinere Lösung:
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]
Sie erhalten die Idee - man könnte dann haben andere Arten von Filterfunktionen. Wahrscheinlich mehr, als Sie brauchen, aber ich fühlte mich großzügig ...;)
ES6: let newArr = arr.filter(e => e);
Was ist die (ES6). Falsy Wert aus einem Array entfernen
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"]
Sie sollten Filter verwenden Array zu erhalten, ohne leere Elemente. Beispiel auf ES6
const array = [1, 32, 2, undefined, 3];
const newArray = array.filter(arr => arr);
Ich bin einfach meine Stimme des oben Hinzufügen „nennen ES5 des Array..filter() mit einem globalen Konstruktor“ Golf-Hack, aber ich schlage vor, mit Object statt String, Boolean oder Number wie oben vorgeschlagen.
Insbesondere ES5 des filter() bereits erfolgt keine Auslösung für undefined Elemente innerhalb des Arrays; so eine Funktion, die universell true zurückgibt, die zurückgibt alle -Elemente filter() Hits, notwendigerweise nur nicht-undefined Elemente zurück:
> [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]
Allerdings ...(function(){return true;}) auszuschreiben ist länger als ...(Object) zu schreiben; und der Rückgabewert des Object Konstruktor wird unter keine Umstände , irgendeine Art von Objekt. Im Gegensatz zu den primitiven-Boxen-Konstrukteuren oben vorgeschlagen, kein möglicher Objekt-Wert ist Falsey, und somit in einer boolean Einstellung ist Object eine kurze Hand für 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]
Wenn die höchste gestimmte Antwort unter Verwendung von oben, erstem Beispiel, ich war immer einzelne Zeichen für Streichlängen größer als 1. Unterhalb meine Lösung für dieses Problem ist.
var stringObject = ["", "some string yay", "", "", "Other string yay"];
stringObject = stringObject.filter(function(n){ return n.length > 0});
Statt nicht, wenn undefinierte Rückkehr, fahren wir zurück, wenn die Länge größer als 0 Hoffnung ist, dass jemand da hilft aus.
Returns
["some string yay", "Other string yay"]
var data = [null, 1,2,3];
var r = data.filter(function(i){ return i != null; })
console.log(r)
[1,2,3]
Was ist das:
js> [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,].filter(String).join(',')
1,2,3,3,0,4,4,5,6
Das funktioniert, Getestet habe ich es in AppJet (Sie den Code auf dem IDE und drücken Sie copy-paste können " reload“zu sehen, es funktioniert, braucht kein Konto)
erstellen/* 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]
*/
Eine andere Möglichkeit, es zu tun ist, den Vorteil der Eigenschaft length des Arrays zu nehmen: auf der ‚linken‘ des Arrays die Nicht-Null-Elemente packen, dann die Länge reduzieren. Es ist ein In-Place -nicht Speicher reserviert, zu schlecht für den Müll Kollektor-, und es hat sehr gut beste / mittel / Worst-Case-Verhalten.
Diese Lösung, im Vergleich zu anderen hier ist zwischen 2 bis 50-mal schneller auf Chrom und 5 bis 50-mal schneller auf Firefox, wie Sie hier sehen können: http://jsperf.com/remove-null-items-from-array
Der folgende Code fügt den nicht-enumerable 'removeNull' Verfahren zum Array, welches Returns 'Dieses' für Kaskadierung:
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 } ) ;
foo = [0, 1, 2, "", , false, 3, "four", null]
foo.filter(function(e) {
return e === 0 ? '0' : e
})
zeigt
[0, 1, 2, 3, "four"]
'Missbrauch von' die für ... in (Objektträger) -Schleife. => Nur truthy Werte erscheinen im Körper der Schleife.
// --- 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);
Dies könnte Ihnen helfen: https://lodash.com/docs/4.17.4# entfernen
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));
});
};
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);
Ausgabe:
Ich arbeite an NodeJS
Es wird von Array leer Element entfernen und ein anderes Element angezeigt werden soll.
Ausfiltern ungültige Einträge mit einem regulären Ausdruck
array = array.filter(/\w/);
filter + regexp
Der beste Weg, leere Elemente zu entfernen, zu verwenden ist Array.prototype.filter() , wie bereits in anderen Antworten erwähnt.
Leider ist Array.prototype.filter() nicht durch IE <9 unterstützt. Wenn Sie noch IE8 unterstützen müssen oder eine noch ältere Version von IE, können Sie den folgenden polyfill , um Unterstützung für Array.prototype.filter() in diesen Browsern:
if (!Array.prototype.filter) {
Array.prototype.filter = function(fun/*, thisArg*/) {
'use strict';
if (this === void 0 || this === null) {
throw new TypeError();
}
var t = Object(this);
var len = t.length >>> 0;
if (typeof fun !== 'function') {
throw new TypeError();
}
var res = [];
var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
for (var i = 0; i < len; i++) {
if (i in t) {
var val = t[i];
if (fun.call(thisArg, val, i, t)) {
res.push(val);
}
}
}
return res;
};
}
Wenn jemand sucht das gesamte Array Reinigung oder Objekt dieser helfen könnte .
var qwerty = {
test1: null,
test2: 'somestring',
test3: 3,
test4: {},
test5: {
foo: "bar"
},
test6: "",
test7: undefined,
test8: " ",
test9: true,
test10: [],
test11: ["77","88"],
test12: {
foo: "foo",
bar: {
foo: "q",
bar: {
foo:4,
bar:{}
}
},
bob: {}
}
}
var asdfg = [,,"", " ", "yyyy", 78, null, undefined,true, {}, {x:6}, [], [2,3,5]];
function clean_data(obj) {
for (var key in obj) {
// Delete null, undefined, "", " "
if (obj[key] === null || obj[key] === undefined || obj[key] === "" || obj[key] === " ") {
delete obj[key];
}
// Delete empty object
// Note : typeof Array is also object
if (typeof obj[key] === 'object' && Object.keys(obj[key]).length <= 0) {
delete obj[key];
}
// If non empty object call function again
if(typeof obj[key] === 'object'){
clean_data(obj[key]);
}
}
return obj;
}
var objData = clean_data(qwerty);
console.log(objData);
var arrayData = clean_data(asdfg);
console.log(arrayData);
Ausgang:
Entfernt alles, was null ist, undefined, "", " ", empty object oder empty array
