ජාවාස්ක්‍රිප්ට් හි අරාවකින් හිස් අංග ඉවත් කරන්නේ කෙසේද?

සරල ක්‍රමයක් තිබේද, නැතහොත් මට එය හරහා ගොස් ඒවා අතින් ඉවත් කළ යුතුද?

සංස්කරණය කරන්න: මෙම ප්‍රශ්නයට මීට වසර නවයකට පමණ පෙර පිළිතුරු සපයන ලද්දේ බොහෝ ප්‍රයෝජනවත් බිල්ට් ක්‍රම නොමැති විටය 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,,,,]);

සරල ක්‍රම:

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]

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]

යාවත්කාලීන කිරීම - තවත් වේගවත් සිසිල් ක්‍රමයක් (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]

හිස් අගයන් ඉවත් කරන්න

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

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

ඔබට සියලු හිස් අගයන් ඉවත් කිරීමට අවශ්‍ය නම් ("", ශුන්‍ය, නිර්වචනය නොකළ සහ 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, " "]

යාවත්කාලීන කිරීම (ඇල්නිටැක්ගේ අදහස මත පදනම්ව)

සමහර අවස්ථාවන්හිදී ඔබට "0" අරාව තුළ තබා වෙනත් ඕනෑම දෙයක් ඉවත් කිරීමට අවශ්‍ය විය හැකිය (ශුන්‍ය, නිර්වචනය නොකළ සහ ""), මෙය එක් ක්‍රමයකි:

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

ආපසු:

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

එක් ලයිනර් එකක්:

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

ඔබට ජාවාස්ක්‍රිප්ට් 1.6 හෝ ඊට පසු තිබේ නම් ඔබට Array.filterසුළු return trueඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයක් භාවිතා කළ හැකිය , උදා:

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

.filterමුල් අරාවෙහි නැතිවූ අංග ස්වයංක්‍රීයව මඟහරින බැවින් .

ඉහත සම්බන්ධ කර ඇති MDN පිටුවේ filterනිල අනුවාදයට සහය නොදක්වන ජාවාස්ක්‍රිප්ට් පරිවර්තකයන් තුළ භාවිතා කළ හැකි හොඳ දෝෂ පරීක්ෂා කිරීමේ අනුවාදයක් ද අඩංගු වේ .

nullමෙය පැහැදිලි undefinedඅගයක් සහිත ඇතුළත් කිරීම් හෝ ඇතුළත් කිරීම් ඉවත් නොකරන බව සලකන්න , නමුත් OP විශේෂයෙන් ඉල්ලා සිටියේ "අතුරුදහන්" ඇතුළත් කිරීම් ය.

සිදුරු ඉවත් කිරීම සඳහා, ඔබ භාවිතා කළ යුතුය

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]

එය කිරීමට පිරිසිදු ක්‍රමය.

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

සරල ES6

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

අන්ඩර්ස්කෝර් / ලොඩාෂ් සමඟ:

සාමාන්‍ය භාවිත නඩුව:

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

හිස් සමඟ:

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

නොමැතිව ලොඩාෂ් ප්‍රලේඛනය බලන්න .

සාධාරණ ES6හා නවතම අනුවාද ක්‍රමය, අරාව පහතින් යැයි උපකල්පනය කරන්න:

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

සරල ක්‍රමය:

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

ES6:

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

පුස්තකාලයක් භාවිතා කිරීම විකල්පයක් නම්, underscore.js හට සංයුක්ත () http://documentcloud.github.com/underscore/ නම් ශ්‍රිතයක් ඇති බව මම දනිමි. එයට අරා සහ එකතු කිරීම් හා සම්බන්ධ තවත් ප්‍රයෝජනවත් කාර්යයන් කිහිපයක් ඇත.

මෙන්න ඔවුන්ගේ ලියකියවිලි වලින් උපුටා ගැනීමකි:

_.com ගිවිසුම (අරාව)

සියලු ව්‍යාජ අගයන් ඉවත් කර අරාවෙහි පිටපතක් ලබා දෙයි. ජාවාස්ක්‍රිප්ට් හි, ව්‍යාජ, ශුන්‍ය, 0, "", නිර්වචනය නොකළ සහ NaN සියල්ලම ව්‍යාජ ය.

_.com ගිවිසුම ([0, 1, අසත්‍ය, 2, '', 3]);

=> [1, 2, 3]

L අල්නිටැක්

ඔබ අමතර කේතයක් එකතු කරන්නේ නම් ඇත්ත වශයෙන්ම 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 සඳහා ඔබ එකතු කළ යුතු කේතය මෙයයි, නමුත් පෙරණය සහ ක්‍රියාකාරී ක්‍රමලේඛනය වටී.

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

වෙනත් කිසිවෙකු එය සඳහන් කර නැති නිසා සහ බොහෝ අය ඔවුන්ගේ ව්‍යාපෘතියට අවධාරනය කර ඇති බැවින් ඔබට ද භාවිතා කළ හැකිය _.without(array, *values);.

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

යෝජනා කර ඇති පරිදි ලූප සහ බෙදීම් කිරීමට උත්සාහ කරනවාට වඩා, ඔබේ අරාව හරහා ලූප තබා නව අරාවක් සෑදීම ඔබට පහසු විය හැකිය. over මගින් ගැටළු හඳුන්වා දිය හැකිය.

ඔබට මේ වගේ දෙයක් කළ හැකිය:

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): අරාවකින් ව්‍යාජ අගය ඉවත් කිරීම.

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

හිස් මූලද්‍රව්‍ය නොමැතිව අරාව ලබා ගැනීමට ඔබ පෙරණය භාවිතා කළ යුතුය. ES6 පිළිබඳ උදාහරණය

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

ඒ ගැන කුමක් ද:

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

මම හුදෙක් සඳහා ඉහත "ES5 ගේ කතා මාගේ හඬ එකතු කරනවා Array..filter()ගොල්ෆ්-නම්න් ගෝලීය ඉදිකිරීමටත් සමග", නමුත් මම භාවිතා යෝජනා Objectවෙනුවට String, Booleanහෝ Numberයෝජනා ඉහත සඳහන් ලෙස.

විශේෂයෙන්, අරාව තුළ ඇති මූලද්‍රව්‍ය filter()සඳහා ES5 දැනටමත් ක්‍රියාත්මක නොවේ 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ඉදිකිරීමටත් යටතේ වනු ඇත , කුමන හෝ තත්වයන් වස්තුව වන කිසි යම් ආකාරයක. ඉහත යෝජනා කර ඇති ප්‍රාථමික-බොක්සිං-ඉදිකිරීම්කරුවන් මෙන් නොව, හැකි වස්තු-වටිනාකමක් වැරදියි, එබැවින් බූලියන් පසුබිමක, Objectඑය කෙටි අතකි 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]

ඉහත වැඩිම ඡන්දය දුන් පිළිතුර භාවිතා කරන විට, පළමු උදාහරණය, ​​මම 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"]

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

console.log(r) 

[1,2,3]

එය කළ හැකි තවත් ක්‍රමයක් නම් අරාවෙහි දිග දේපල වලින් ප්‍රයෝජන ගැනීමයි: ශුන්‍ය නොවන අයිතම අරාවෙහි 'වමේ' ඇසුරුම් කර දිග අඩු කරන්න. එය ස්ථානීය ඇල්ගොරිතමයකි - මතකය වෙන් නොකෙරේ, කසළ එකතු කරන්නාට එතරම් නරක නැත, සහ එය ඉතා හොඳ / සාමාන්‍ය / නරකම හැසිරීම් ඇත.

මෙහි ඇති අනෙක් ඒවාට සාපේක්ෂව මෙම විසඳුම ක්‍රෝම් හි 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 } ) ;

සියලුම හිස් අංග ඉවත් කිරීම

අරාවෙහි හිස් හිස් වස්තු, අරා සහ නූල් වෙනත් හිස් මූලද්‍රව්‍ය සමඟ තිබේ නම්, අපට ඒවා ඉවත් කළ හැකිය:

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)

මෙය ක්‍රියාත්මක වන අතර, මම එය ඇප්ජෙට් හි පරීක්‍ෂා කළෙමි (ඔබට එහි IDE හි කේතය පිටපත් කර ඇලවිය හැකි අතර එය ක්‍රියාත්මක වන බව දැකීමට "රීලෝඩ්" ඔබන්න, ගිණුමක් නිර්මාණය කිරීමට අවශ්‍ය නොවේ)

/* 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]
*/

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

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

ප්‍රතිලාභ

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

සඳහා ... වස්තු-සාමාජික ලූපය 'වැරදි ලෙස භාවිතා කිරීම'. => ලූපයේ ශරීරයේ සත්‍ය සත්‍ය අගයන් පමණක් දිස් වේ.

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

මෙය ඔබට උදව් වනු ඇත: 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);

ප්‍රතිදානය:

මම nodejs මත වැඩ කරමින් සිටිමි

එය හිස් මූලද්‍රව්‍යය අරාවෙන් ඉවත් කර වෙනත් මූලද්‍රව්‍ය පෙන්වනු ඇත.

array.filter(String); එය භාවිතා කිරීමෙන් හිස් හිස් සියල්ලම අරාවකින් ඉවත් කළ හැකිය

සාමාන්‍ය ප්‍රකාශනයක් සමඟ අවලංගු ඇතුළත් කිරීම් පෙරීම

array = array.filter(/\w/);
filter + regexp