मैं जावास्क्रिप्ट में एक सरणी से खाली तत्वों को कैसे निकालूं?
क्या कोई सीधा रास्ता है, या क्या मुझे इसके माध्यम से लूप करने और उन्हें मैन्युअल रूप से हटाने की आवश्यकता है?
मैं जावास्क्रिप्ट में एक सरणी से खाली तत्वों को कैसे निकालूं?
क्या कोई सीधा रास्ता है, या क्या मुझे इसके माध्यम से लूप करने और उन्हें मैन्युअल रूप से हटाने की आवश्यकता है?
जवाबों:
EDIT: लगभग नौ साल पहले इस सवाल का जवाब दिया गया था जब कई उपयोगी बिल्ट-इन मेथड नहीं थे Array.prototype।
अब, निश्चित रूप से, मैं आपको filterविधि का उपयोग करने की सलाह दूंगा।
ध्यान रखें कि यह विधि आपको उन तत्वों के साथ एक नया सरणी लौटाएगी जो आपके द्वारा प्रदान किए गए कॉलबैक फ़ंक्शन के मानदंड को पास करते हैं।
उदाहरण के लिए, यदि आप हटाना nullया undefinedमान चाहते हैं:
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);यह इस बात पर निर्भर करेगा कि आप क्या "खाली" मानते हैं उदाहरण के लिए, यदि आप तार के साथ काम कर रहे थे, तो उपरोक्त फ़ंक्शन उन तत्वों को नहीं हटाएगा जो एक खाली स्ट्रिंग हैं।
एक विशिष्ट पैटर्न है कि मैं अक्सर इस्तेमाल किया जाता देखें तत्वों को दूर करने के लिए कर रहे हैं है falsy है, जो एक खाली स्ट्रिंग शामिल "", 0, NaN, null, undefined, और false।
आप filterविधि, Booleanकंस्ट्रक्टर फ़ंक्शन के पास जा सकते हैं या फ़िल्टर मापदंड फ़ंक्शन में उसी तत्व को वापस कर सकते हैं, उदाहरण के लिए:
var filtered = array.filter(Boolean);या
var filtered = array.filter(function(el) { return el; });दोनों तरीकों से, यह काम करता है क्योंकि filterपहले मामले में विधि, Booleanकंस्ट्रक्टर को फ़ंक्शन के रूप में कॉल करती है , मान को परिवर्तित करती है, और दूसरे मामले में, filterविधि आंतरिक रूप से कॉलबैक के रिटर्न मूल्य को संक्षेप में बदल देती है Boolean।
यदि आप विरल सरणियों के साथ काम कर रहे हैं, और आप "छिद्रों" से छुटकारा पाने की कोशिश कर रहे हैं, तो आप filterकॉलबैक पास करने की विधि का उपयोग कर सकते हैं जो उदाहरण के लिए सही है:
var sparseArray = [0, , , 1, , , , , 2, , , , 3],
cleanArray = sparseArray.filter(function () { return true });
console.log(cleanArray); // [ 0, 1, 2, 3 ]पुराना उत्तर: ऐसा मत करो!
मैं इस विधि का उपयोग करता हूं, जो मूल ऐरे प्रोटोटाइप को बढ़ाता है:
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);
या आप मौजूदा तत्वों को अन्य सरणी में धकेल सकते हैं:
// 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,,,,]);
spliceकॉल है वास्तव में पुराने ब्राउज़र पर महंगा है क्योंकि वे खाई को बंद करने सरणी कुंजी के सभी फिर से अंकित किया है।
Array.prototypeका उपयोग कर Object.definePropertyनए कार्य को एक बनाने के लिए गैर गणनीय संपत्ति और उसके बाद से बचने के प्रदर्शन डालने की वजह से हिट .hasOwnPropertyहर पाश में।
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]या - (केवल "टेक्स्ट" प्रकार के एकल सरणी आइटम के लिए)
['','1','2',3,,'4',,undefined,,,'5'].join('').split('');
// output: ["1","2","3","4","5"]या - क्लासिक तरीका: सरल पुनरावृत्ति
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]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]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]['foo', '',,,'',,null, ' ', 3, true, [], [1], {}, undefined, ()=>{}].filter(String)
// ["foo", null, " ", 3, true, [1], Object {}, undefined, ()=>{}]arr = arr.filter(function(n){return n; });
foo.join("").split("")केवल काम करने के लिए लगता है अगर तार एकल वर्ण हैं
arr.filter(e=>e)और भी सरल कर सकता है और इसे मैप, कम, इत्यादि से जंजीर बनाया जा सकता है
यदि आपको सभी खाली मानों को हटाने की आवश्यकता है ("", अशक्त, अपरिभाषित और 0):
arr = arr.filter(function(e){return e}); खाली मान और पंक्ति विराम हटाने के लिए:
arr = arr.filter(function(e){ return e.replace(/(\r\n|\n|\r)/gm,"")});उदाहरण:
arr = ["hello",0,"",null,undefined,1,100," "]
arr.filter(function(e){return e});वापसी:
["hello", 1, 100, " "]अद्यतन (Alnitak की टिप्पणी पर आधारित)
कुछ स्थितियों में आप सरणी में "0" रख सकते हैं और कुछ और हटा सकते हैं (अशक्त, अपरिभाषित और ""), यह एक तरीका है:
arr.filter(function(e){ return e === 0 || e });वापसी:
["hello", 0, 1, 100, " "]function(e){return !!e}
!!eइसमें NaN (0 के विपरीत) शामिल eहोगा जहाँ (जैसे 0) नहीं होगा।
var myarr=[1, 2,, 3,, 3,undefined,,"",,0, 4,, 4,, 5,, 6,,,,].filter(Boolean);अपरिभाषित, "" और 0 को हटा देता है
बस एक लाइनर:
[1, false, "", undefined, 2].filter(Boolean); // [1, 2]या underscorejs.org का उपयोग कर :
_.filter([1, false, "", undefined, 2], Boolean); // [1, 2]
// or even:
_.compact([1, false, "", undefined, 2]); // [1, 2]Booleanएक समारोह के रूप में काम करता हूं ...
Booleanएक फ़ंक्शन के रूप में व्यवहार करते हैं तो यह बस वापस आ जाएगा trueया falseमूल्य को ठीक कर देगा / झूठा होगा।
(true).constructor === Boolean। और फिर मुझे बताएं कि क्या हम जेएस में अन्य बिल्ड-इन के साथ ऐसा कर सकते हैं। ;)) (बेशक अन्य 5 बिल्ड-इन कन्स्ट्रक्टर्स को बहिष्कृत किया। (स्ट्रिंग, एरे, ऑब्जेक्ट, फंक्शन, नंबर))
यदि आपको जावास्क्रिप्ट 1.6 मिला है या बाद में आप Array.filterएक तुच्छ return trueकॉलबैक फ़ंक्शन का उपयोग कर सकते हैं , उदाहरण के लिए:
arr = arr.filter(function() { return true; });चूंकि .filterमूल सरणी में स्वचालित रूप से अनुपलब्ध तत्वों को छोड़ देता है।
उपरोक्त लिंक किए गए MDN पृष्ठ में एक अच्छा त्रुटि-जाँच संस्करण भी शामिल filterहै जिसका उपयोग जावास्क्रिप्ट दुभाषियों में किया जा सकता है जो आधिकारिक संस्करण का समर्थन नहीं करते हैं।
ध्यान दें कि यह nullएक स्पष्ट undefinedमूल्य के साथ प्रविष्टियों और प्रविष्टियों को नहीं हटाएगा , लेकिन ओपी ने विशेष रूप से "लापता" प्रविष्टियों का अनुरोध किया।
undefinedइसका दिया मान है।
छिद्रों को हटाने के लिए, आपको उपयोग करना चाहिए
arr.filter(() => true)
arr.flat(0) // Currently stage 3, check compatibility before using thisछेद को हटाने के लिए, और, मिथ्या (अशक्त, अपरिभाषित, 0, -0, NaN, "", गलत, document.all) मान:
arr.filter(x => x)छेद हटाने के लिए, अशक्त, और अपरिभाषित:
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][, ,]
arr.filter(x => x), जेएस यह जांच करेगा कि क्या x सत्य है या मिथ्या है if (x), इसलिए केवल सत्य मान को नई सूची में सौंपा जाएगा।
इसे करने का साफ तरीका।
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"]undefined; यह मूल रूप से सभी मिथ्या मूल्यों को दूर करता है।
अंडरस्कोर / लॉडश के साथ:
सामान्य उपयोग मामला:
_.without(array, emptyVal, otherEmptyVal);
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);खाली होने के साथ:
_.without(['foo', 'bar', '', 'baz', '', '', 'foobar'], '');
--> ["foo", "bar", "baz", "foobar"]बिना दर्ज किए दस्तावेज देखें ।
यदि लाइब्रेरी का उपयोग करना एक विकल्प है, तो मुझे पता है कि अंडरस्कोर। जेएस के पास कॉम्पैक्ट () http://documentcloud.github.com/underscore/ नामक एक फ़ंक्शन है, इसमें एरेज़ और संग्रह से संबंधित कई अन्य उपयोगी कार्य भी हैं।
यहाँ उनके प्रलेखन से एक अंश है:
_.compact (सरणी)
हटाए गए सभी गलत मूल्यों के साथ सरणी की एक प्रति लौटाता है। जावास्क्रिप्ट में, गलत, अशक्त, 0, "", अपरिभाषित और NaN सभी मिथ्या हैं।
_.compact ([0, 1, गलत, 2, '', 3]);
=> [1, 2, 3]
@Alnitak
यदि आप कुछ अतिरिक्त कोड जोड़ते हैं तो वास्तव में Array.filter सभी ब्राउज़रों पर काम करता है। निचे देखो।
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"] यह वह कोड है जिसे आपको IE के लिए जोड़ने की आवश्यकता है, लेकिन फ़िल्टर और फ़ंक्शनल प्रोग्रामिंग का मूल्य 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;
};
}let newArr = arr.filter(e => e);आपको अपने सरणी पर लूप करने में आसानी हो सकती है और उन मदों में से एक नया सरणी बना सकते हैं जिसे आप लूप और ब्याह की कोशिश से सरणी से रखना चाहते हैं जैसा कि सुझाया गया है, क्योंकि यह लूप किए जाने के दौरान सरणी की लंबाई को संशोधित करता है। ओवर समस्याएं पेश कर सकती हैं।
आप ऐसा कुछ कर सकते हैं:
function removeFalsyElementsFromArray(someArray) {
var newArray = [];
for(var index = 0; index < someArray.length; index++) {
if(someArray[index]) {
newArray.push(someArray[index]);
}
}
return newArray;
}वास्तव में यहाँ एक अधिक सामान्य समाधान है:
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]आपको यह विचार मिलता है - फिर आप अन्य प्रकार के फ़िल्टर कार्य कर सकते हैं। शायद आपकी जरूरत से ज्यादा, लेकिन मैं उदार महसूस कर रहा था ...;)
आपको खाली तत्वों के बिना सरणी प्राप्त करने के लिए फ़िल्टर का उपयोग करना चाहिए। ES6 पर उदाहरण
const array = [1, 32, 2, undefined, 3];
const newArray = array.filter(arr => arr);मैं बस के ऊपर "ES5 के कॉल करने के लिए मेरी आवाज जोड़ रहा Array..filter()एक वैश्विक निर्माता के साथ" गोल्फ हैक, लेकिन मैं उपयोग करने का सुझाव Objectके बजाय String, Booleanया Numberजैसा कि ऊपर का सुझाव दिया।
विशेष रूप से, ES5 filter()पहले से ही undefinedसरणी के भीतर तत्वों के लिए ट्रिगर नहीं करता है ; इसलिए एक ऐसा कार्य जो सार्वभौमिक रूप से रिटर्न करता है true, जो सभी तत्वों को filter()हिट करता है, आवश्यक रूप से केवल गैर- undefinedतत्वों को लौटाएगा :
> [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]हालाँकि, बाहर लिखना लेखन से ...(function(){return true;})अधिक लंबा है ...(Object); और किसी भी परिस्थिति में , किसी भी प्रकार की वस्तु के Objectतहत, निर्माता का रिटर्न-वैल्यू होगा । ऊपर सुझाए गए आदिम-बॉक्सिंग-कंस्ट्रक्टरों के विपरीत, कोई भी संभव वस्तु-मूल्य गलत नहीं है, और इस तरह एक बूलियन सेटिंग में, एक छोटा-सा हाथ है ।Objectfunction(){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]someArray.filter(String);वास्तव में बराबर है someArray.filter(function(x){ return String(x); });। यदि आप someArray.filter(Boolean);0, -0, NaN, असत्य, '', अशक्त, और अपरिभाषित को हटाने के लिए सभी मिथ्या मानों को हटाना चाहते हैं ।
Objectनिर्माण के return trueतरीके के विरोध में प्रदर्शन के उपर विधि के विपरीत है । @robocat ओपी ने खाली तत्वों को हटाने के लिए कहा, नल नहीं।
ऊपर दिए गए उच्चतम मतदान जवाब का उपयोग करते समय, पहला उदाहरण, मुझे 1. से अधिक स्ट्रिंग लंबाई के लिए व्यक्तिगत वर्ण मिल रहे थे। नीचे उस समस्या के लिए मेरा समाधान है।
var stringObject = ["", "some string yay", "", "", "Other string yay"];
stringObject = stringObject.filter(function(n){ return n.length > 0});अपरिभाषित होने पर वापस नहीं लौटने के बजाय, हम लौटते हैं यदि लंबाई 0. से अधिक है। आशा है कि किसी को वहां से निकालने में मदद करता है।
रिटर्न
["some string yay", "Other string yay"]["", "some string yay", "", "", 123, "Other string yay"].filter(function(n){ return n.length > 0}) //gives your same result removing 123उस फ़ंक्शन को बदल दिया जा सके। .. स्ट्रिंग के साथ, विडंबना यह है कि संख्या में छोड़ देता है, लेकिन आपके दिए गए सरणी में एक ही परिणाम देगा।
var data = [null, 1,2,3];
var r = data.filter(function(i){ return i != null; })console.log(r) [1,2,3]
उसका क्या:
js> [1,2,,3,,3,,,0,,,4,,4,,5,,6,,,,].filter(String).join(',')
1,2,3,3,0,4,4,5,6join() === join(','):)
यह काम करता है, मैंने इसे AppJet में परीक्षण किया (आप इसकी आईडीई पर कोड कॉपी-पेस्ट कर सकते हैं और इसे देखने के लिए "पुनः लोड करें" दबाएं, इसे बनाने के लिए खाता बनाने की आवश्यकता नहीं है)
/* 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]
*/for ... inजो वास्तव में लापता तत्वों को छोड़ देता है। के लिए परीक्षण undefinedकेवल वास्तविक तत्व है कि स्पष्ट रूप से वह मान पर सेट कर रहे हैं दूर करने के लिए कार्य करता है।
इसका एक और तरीका यह है कि आप सरणी की लंबाई संपत्ति का लाभ उठाएं: सरणी के 'बाएँ' पर गैर-अशक्त आइटम पैक करें, फिर लंबाई कम करें। यह एक इन-प्लेस एल्गोरिथ्म है, जो मेमोरी को आवंटित नहीं करता है, कचरा संग्रहकर्ता के लिए बहुत बुरा है- और इसमें बहुत अच्छा सर्वश्रेष्ठ / औसत / सबसे खराब मामला व्यवहार होता है।
यह समाधान, यहां दूसरों की तुलना में, क्रोम पर 2 से 50 गुना तेज है, और फ़ायरफ़ॉक्स पर 5 से 50 गुना तेज़ है, जैसा कि आप यहां देख सकते हैं: http://jsperf.com/remove-null-items-from-array
नीचे दिया गया कोड गैर-विलुप्त 'निष्कासन' विधि को ऐरे में जोड़ता है, जो डेज़ी-चेनिंग के लिए 'यह' लौटाता है:
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 } ) ;arr.filter(e => e)।
... (ऑब्जेक्ट-मेंबर) लूप के लिए 'मिसयूजिंग'। => लूप के शरीर में केवल सत्य मान दिखाई देते हैं।
// --- 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);for ... inहै जो सरणी से अपरिभाषित कुंजी को हटा देता है, लेकिन आपके पास वास्तव में कोई कोड नहीं है अन्यथा केवल "सत्य" मानों को स्वीकार करने के लिए
यह आपकी मदद कर सकता है: 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));
});
};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);आउटपुट:
मैं नोडज पर काम कर रहा हूं
यह खाली तत्व को सरणी से हटा देगा और अन्य तत्व प्रदर्शित करेगा।
यदि किसी सरणी में अन्य खाली तत्वों के साथ खाली ऑब्जेक्ट, एरे और स्ट्रिंग्स हैं, तो हम उन्हें निकाल सकते हैं:
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))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)सादे जावास्क्रिप्ट के साथ ->
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)एक नियमित अभिव्यक्ति के साथ अमान्य प्रविष्टियों को फ़िल्टर करना
array = array.filter(/\w/);
filter + regexpखाली तत्वों को निकालने का सबसे अच्छा तरीका, उपयोग करना है Array.prototype.filter(), जैसा कि पहले से ही अन्य उत्तरों में बताया गया है।
दुर्भाग्य से, Array.prototype.filter()IE <9 द्वारा समर्थित नहीं है। यदि आपको अभी भी IE8 या IE के पुराने संस्करण का समर्थन करने की आवश्यकता है, तो आप इन ब्राउज़रों में समर्थन जोड़ने के लिए निम्नलिखित पॉलीफ़िल का उपयोग कर सकते हैं Array.prototype.filter():
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;
};
}
var a = [,,]औरvar a = [undefined, undefined]। पूर्व वास्तव में खाली है, लेकिन बाद में वास्तव में दो कुंजी हैं, लेकिनundefinedमूल्यों के साथ ।