从数组中删除所有假值

您可以使用布尔值：

var myFilterArray = myArray.filter(Boolean);

既然你想摆脱"falsy"值，那就让JavaScript做它的事情吧：

function bouncer(arr) {
  return arr.filter(function(v) { return !!v; });
}

!运算符的双重应用将使过滤器回调在值为"真实"时返回true，当值为"假"时返回false。

(你的代码调用isNaN()但没有给它传递一个值;这就是为什么这个测试对你不起作用。如果 isNaN() 函数的参数在强制转换为数字时NaN，则返回true，否则false。

编辑 — 请注意

function bouncer(arr) {
  return arr.filter(Boolean);
}

正如 LoremIpsum 在另一个答案中指出的那样，也可以工作，因为内置的布尔构造函数与 !! 几乎完全相同。

truthyArray = arr.filter(el => el)

^ 这就是你的做法

使用这个简单的过滤器可以：

array.filter(Boolean)

您可以在此处阅读有关Boolean的更多信息

你用错了isNaN()。它应该是这样的：

function bouncer(arr) {
   return arr.filter(function (n) { 
       return n !== undefined && n !== null && n !== false && n !== 0 && n !== "" && !isNaN(n); 
   });

}

你也可以重写它：

function bouncer( arr ){
    return arr.filter( function( value ){
        return value;
    });
}

这是另一个等效但说明性的解决方案：

function bouncer( arr ){
    return arr.filter( function( value ){
        return value ? true : false;
    });
}

此代码示例具有说明性，因为它向读者指示变量value将被计算为真或假，并且匿名函数将返回布尔值(true或false，映射到value的计算。

这种根据真实性从数组中删除值的方法的人，或者对于不熟悉(或未阅读有关(filter函数的文档的人，此示例是最简洁的，仍然传达filter函数的行为。

当然，在您的应用程序中，您可以选择更简洁但不太有见地的实现：

function bouncer( arr ){
    return arr.filter( function( value ){
        return value;
    });
}

使用过滤器我们可以编写

function bouncer(arr) {
 return arr.filter(item => item);
}
bouncer([false, null, 0, NaN, undefined, ""]) // will return [].

这可以使用arr.filter((方法完成。但我更喜欢使用 Boolean(( 函数。对我来说更清楚。以下是我的做法，尽管时间稍长：

function bouncer(arr) {
// Don't show a false ID to this bouncer.
    var falsy;
    var trueArr = [];
    for (i = 0; i < arr.length; i++) {
        falsy =  Boolean(arr[i]);
        if (falsy === true) {
        trueArr.push(arr[i]);
        }
    }
    return trueArr;
}
bouncer([7, "ate", "", false, 9]);
// returns a new array that is filtered accordingly.

我认为这样更好

   function bouncer(arr) {
        arr = arr.filter(function(item) {
            return item;
        return arr;
    bouncer([7, "ate", "", false, 9, NaN, undefined, 0]);

保镖功能：

function bouncer(arr) {
  return arr.filter((val) => {
    return !!val;
  });
}
console.log(bouncer([7, "ate", "", false, 9]));

感谢上面的所有工作答案。以下是解决问题的 3 种方法。第三个解决方案通过您的方法解决了问题@Vignesh。

1. 
function bouncer(arr) {
  return arr.filter( function( val ){
        return val;
    });
}
2. 
function bouncer(arr) {
return arr.filter(Boolean);
}
3.
  function bouncer(arr) {
  return arr.filter(function(val){
      return val !== false && val !== "" && !(Number.isNaN(val)) && val !== 
undefined && val !== 0 && val !== null;
    });
 }

只需将两次求反以"投射"为布尔值。 !NaN === true => !!NaN === false

    const truthy = arr.filter(o => !!o)

的想法...

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
  var result = [];
  
    function isGood(obj){
      if(!Boolean(obj)){
        return false;
      } else {
        return true;
      }
    }
    
    for (var i=0; i < arr.length; i++){
      if (isGood(arr[i]) === true){
        result.push(arr[i]);
      }
    }
  return result;
}
console.log(bouncer([7, "ate", "", false, 9]));

尝试使用过滤器和布尔值：

let array = [7,"ate","",false,9];
array.filter((values) => {return Boolean(values) === true })

如果你喜欢使用像Lodash或Underscore这样的JS实用程序库.js你可以使用compact函数。

import _ from 'lodash' // or import _ from 'underscore'
_.compact([0, 1, false, 'hello', '', {}, null]) // returns [1, 'hello', {}]

文档：

• 洛达什.compact .
• 下划线.compact .

function bouncer(arr) {  
  var result = []; 
   for (var i = 0; i < arr.length; i++) {
     if (arr[i]) {
      result.push(arr[i]);
     }
   }
  return result;
 }
 bouncer([7, "ate", "", false, 9]);

function falsy(value) {
      if (value) {
        return value;
      }
    }
    function bouncer(arr) {
      var filter = arr.filter(falsy);
      return filter;
    }
    bouncer([7, "ate", "", false, 9]);

function removeFalsy(value){
  var val = Boolean(value);
  if(!val)
    return false;
  return true;
}
function bouncer(arr) {
  return arr.filter(removeFalsy);
}
bouncer([7, "ate", "", false, 9]);

这应该是您要查找的：

let array = [7, 'ate', '', false, 9, NaN];
function removeFalsyItems(array) {
   // Your result
   let filter = array.filter(Boolean);
   // Empty the array
   array.splice(0, array.length);
   // Push all items from the result to our array
   Array.prototype.push.apply(array, filter);
   return array
}
removeFalsyItems(array) // => [7, 'ate', 9], funny joke btw...

myArray = [false, null, 0, NaN, undefined, ""];
myArray.map(item => {
//if you want you can write logic
        console.log(item);
    })
    // Get rid of bad values
    .filter(Boolean);

它将返回 []。

我看到你从未接受过答案。问题是您依靠记录器.log或控制台.log来查看空删除是否有效？我认为@LoremIpsum建议的过滤器是最干净的解决方案。

  const src2DArr = [[34], [75], [30], [48], [976], [], [178], [473], [51], [75], [29], [47], [40]];
  Logger.log("src2DArr: " +JSON.stringify(src2DArr)); 
  // [[34],[75],[30],[48],[976],[],[178],[473],[51],[75],[29],[47],[40]]
  
  var src2DArr1 = src2DArr.filter(Boolean);
  Logger.log("src2DArr1: " + JSON.stringify(src2DArr1));
  // [[34],[75],[30],[48],[976],[],[178],[473],[51],[75],[29],[47],[40]] 

使用 .filter

myArray.filter(val => Boolean(val));

Falsy 值

• 假
• 零(0，-0(
• 空字符串("， ' ' ， ' '(
• BigIntZero(0,0x0n(
• 零
• 定义
• 南

const values = [false,'false','js', true, 0 , [],[1,2,3], 1, 'b', {}, 
'', NaN, undefined, null, -5,1n,0n,0x1n,0x0n];
console.log(values.filter((value)=> !!value));
console.log(values.filter((value) => value ));
console.log(values.filter((value)=> Boolean(value)));
console.log(values.filter(Boolean));
//=> [ 'false', 'js', true, [], [ 1, 2, 3 ], 1, 'b', {}, -5, 1n, 1n ]

// note: empty collections are not falsy like in python (empty array)
//note: will syntax error for 1x0n, 'false' is string here
const values = [false,'false','js', true, 0 , [],[1,2,3], 1, 'b', {}, '', NaN, undefined, null, -5,1n,0n,0x1n,0x0n];
//=> [ 'false', 'js', true, [], [ 1, 2, 3 ], 1, 'b', {}, -5, 1n, 1n ]
//=> [ 'false', 'js', true, [], [ 1, 2, 3 ], 1, 'b', {}, -5, null, null ] // BigInt not supported compilers
// double not 
// first not makes it as boolean opposite values, then  second not give its inversion
console.log(values.filter(
  (value)=> !!value
));
// Auto Coercion 
// values are self identified as falsy or not
console.log(values.filter(
  value => value
));
// Boolean type conversion
// get values as parem and return boolean as falsy or not
console.log(values.filter(
  (value)=> Boolean(value)
));
// Boolean constructor
// This works because Boolean itself is a function, and the arguments filter supplies are passed directly to it
console.log(values.filter(
  Boolean
));

有关详细说明，请参阅：三anthaming网站

function bouncer(arr) {
    function filterFalse(value) {
        var a = Boolean(value);
        if (a === true) {
            return a;
        }
        return a;
    }
    function filterArray(x) {
        var y = filterFalse(x);
        if (y) {
            return true;
        } else {
            return false;
        }
    }
    var newArr = arr.filter(filterArray);
    return newArr;
}
bouncer([1, null, NaN, 2, undefined]);

使用 ECMAscript 5 Vanila JS 从数组中删除假值

function bouncer(arr){
  let trueArray = [];
  for(int i=0; i<arr.lenght; i++){
    if(arr[i]===true){
      trueArray.push(arr[i]);
    }    
  }
  return trueArray;
}

使用 ECMAscript6 或 Ecma2015 方法从数组中删除假值

function bouncer(arr){
   let trueArray = arr.filter( item => item===true);
  return trueArray;
}

function compact(ar) {
  let newArr = []
  for (let i = 0; i < ar.length; i++) {
    if (
      !(
        ar[i] === false ||
        ar[i] === null ||
        ar[i] === 0 ||
        ar[i] === '' ||
        ar[i] === undefined ||
        (typeof ar[i] == 'number' && !ar[i])
      )
    ) {
      newArr.push(ar[i])
    }
  }
  return newArr
}