从数组中删除所有虚假值答案

【问题标题】：Remove all falsy values from an array从数组中删除所有虚假值
【发布时间】：2015-12-30 15:32:12
【问题描述】：

我想从数组中删除所有虚假值。 JavaScript 中的 Falsy 值为 false、null、0、""、undefined 和 NaN。

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

bouncer([7, "ate", "", false, 9, NaN], "");

除了 NaN 测试用例之外，上述所有测试都得到了满足。有人可以帮我检查数组是否包含 NaN 吗？

【问题讨论】：

标签： javascript arrays

【解决方案1】：

您可以使用布尔值：

var myFilterArray = myArray.filter(Boolean);

【讨论】：

那是个聪明人
Boolean 是布尔值的构造函数。这相当于var myFilterArray = myArray.filter((v) => new Boolean(v));。如果给定值为0、-0（我知道...）、null、false、NaN、undefined 或空字符串，则生成的布尔值将为false。如果通过了其他任何内容，它将是true。
@LoremIpsum：如果你尝试这样做，你会发现它永远不会过滤掉任何东西，因为 Boolean 用作 构造函数 创建布尔包装对象（JavaScript 最愚蠢的功能，完全没有任何目的），这些都是真实的。 Boolean(v) 而不是 new Boolean(v)，这是通过 Boolean 直接实现的，转换为布尔值。
@LoremIpsum 相当于var myFilterArray = myArray.filter((v) => Boolean(v));，没有new。 new Boolean 将创建真实的布尔对象，这意味着 filter 接受所有元素，这反过来相当于 var myFilterArray = myArray.filter(() => true);。
哦，为什么这是在最底部？我只是发布了这个，因为所有的答案似乎都很棘手

【解决方案2】：

既然你想摆脱“虚假”值，就让 JavaScript 来做吧：

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

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

(您的代码正在调用isNaN()，但没有传递一个值；这就是为什么该测试不适合您。isNaN() 函数返回true，如果它的参数，当强制为一个数字，是@ 987654328@，否则false。）

编辑——注意

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

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

【讨论】：

优秀。函数方法的好技术
这不是 { return !!v; } 与 { 返回 v; 相同}
从技术上讲，这里甚至不需要!!，因为filter 正在测试真实性，而不是与true 进行比较。

【解决方案3】：

truthyArray = arr.filter(el => el)

^你就是这样做的

【讨论】：

花括号禁用隐式返回，所以你会得到空数组。

【解决方案4】：

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

array.filter(Boolean)

你可以阅读更多关于Booleanhere的信息

【讨论】：

简单最好的解决方案！

【解决方案5】：

您以错误的方式使用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;
    });
}

【讨论】：

上面的代码完美运行...你能解释一下 return arr.filter(function(value){ return value; });
@Vignesh Array.prototype.filter 检查值是否为真，然后将其添加到数组中。以上所有值均不真实developer.mozilla.org/en-US/docs/Glossary/Truthy
在第一种情况下，即使字符串不为空，过滤器也会删除字符串，为什么？

【解决方案6】：

使用过滤器我们可以写

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

【讨论】：

【解决方案7】：

我知道这可以使用 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.

【讨论】：

【解决方案8】：

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

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

【讨论】：

x ? true : false 总是多余的。 return value 就够了。在某些情况下您需要使用Boolean(value) 或!!value，但不是这种情况。
我写了这个答案，认为它说明filter 根据布尔返回值评估值。如果没有明确说明 filter 将回调的返回值评估为布尔值，那么 return value; 将不足以向 filter 函数的新手表达这个概念。
有这样的插图更容易阅读代码。

【解决方案9】：

我觉得这样比较划算

   function bouncer(arr) {
        arr = arr.filter(function(item) {
            return item;
        return arr;

    bouncer([7, "ate", "", false, 9, NaN, undefined, 0]);

【讨论】：

【解决方案10】：

保镖功能：

function bouncer(arr) {
  return arr.filter((val) => {
    return !!val;
  });
}

console.log(bouncer([7, "ate", "", false, 9]));

【讨论】：

【解决方案11】：

感谢以上所有有效的答案。这里有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;
    });
 }

【讨论】：

【解决方案12】：

只需两次否定即可“转换”为布尔值。 !NaN === true => !!NaN === false

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

【讨论】：

【解决方案13】：

这是我的想法……

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

【讨论】：

【解决方案14】：

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

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

【讨论】：

【解决方案15】：

使用.filter

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

【讨论】：

【解决方案16】：

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

【讨论】：

【解决方案17】：

function falsy(value) {
      if (value) {
        return value;
      }
    }

    function bouncer(arr) {
      var filter = arr.filter(falsy);
      return filter;
    }

    bouncer([7, "ate", "", false, 9]);

【讨论】：

【解决方案18】：

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

【讨论】：

【解决方案19】：

这应该是你要找的：

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...

【讨论】：

您也可以通过Array.prototype将其转换为数组方法，以使其更方便例如：[1, 0, 1].removeFalsyItems() // => [1, 1]

【解决方案20】：

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

它将返回 []。

【讨论】：

【解决方案21】：

我看到你从未接受过答案。您是否依赖 Logger.log 或 console.log 来查看 null 删除是否有效？我认为@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]]

【讨论】：

【解决方案22】：

如果您喜欢使用 Lodash 或 Underscore.js 等 JS 实用程序库，您可以使用 compact 函数。

import _ from 'lodash' // or import _ from 'underscore'

_.compact([0, 1, false, 'hello', '', {}, null]) // returns [1, 'hello', {}]

文档：

Lodash .compact。
Underscore .compact。

【讨论】：

【解决方案23】：

假值

假
零(0,-0)
空字符串（“”，''，``）
BigIntZero(0,0x0n)
空
未定义
NaN


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

详细解释请参考：samanthaming website

【讨论】：

【解决方案24】：

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

【讨论】：

【解决方案25】：

使用 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;
}

【讨论】：