Question

我有一个可能包含或不包含属性的对象数组。

所以，为了过滤它，我这样做：

array = array.filter(v => v.myproperty != undefined);
array = array.filter(v => v.myproperty[0] != undefined);

这有效地删除了未定义myproperty的那些，以及之后myproperty内第一个元素的那些。

有没有办法让单个衬垫阻止我将filter两次应用到阵列？

类似的东西：

array = array.filter((v => v.myproperty || [])[0] != undefined);

Answer 1

最后，array.filter()采用一个期望布尔结果的匿名函数。你可以在里面做任何工作来确定是否应该过滤数组项。

var array = [1, 2, undefined, 3, "some text", [5,6,7],[], [undefined,8]]

array = array.filter(v => {

  if (!v) return false;

  if (v === "some text") return false;
  
  if (Array.isArray(v) && v.length === 0) return false;
  
  if (Array.isArray(v) && v[0] === undefined) return false;

  return true;

});


console.log(array);

Answer 2

怎么样：

filtered_array = array.filter(element => element.property && element.property[0]);

条件的作用是首先评估左侧部分。如果确实如此，它将尝试评估正确的部分并返回结果。

Fiddle here

Answer 3

您可以执行其他人已在此处建议的内容，如果第一个条件失败，该函数将返回。

    array => array.filter(v => v.ggwp && v.ggwp[0])

你也可以使用in运算符完成同样的事情：

    array => array.filter(v => ('myproperty' in v) && (0 in v.myproperty))

这里有一个jsbin，其中包含一些测试用例，可以将这两个函数与您的函数进行比较。

我不确定您是否希望在代码中使用!=而不是!==。 Javascript，因为类型强制有weird behaviour。

Answer 4

像array.filter((v => v.myproperty || [])[0] != undefined);
这样的东西

是的，就是这样的。你只错放了一个括号：

array.filter( v => (v.myproperty || [])[0] != undefined);
//           ^     ^

Answer 5

您的语句中可以包含复杂的布尔逻辑。

let array = [{num: [1]}, {num: [2]}, {num: [3]}, {num: undefined}, {}]
array = array.filter(v => v && v.num && v.num.length)

为了便于阅读和测试，您可能希望将其分解为可以在其他地方进行测试的函数。

function predicate(v) {
  return v && v.num && v.num.length
}
let array = [{num: [1]}, {num: [2]}, {num: [3]}, {num: undefined}, {}]
array = array.filter(predicate)

Answer 6

您还应该检查properties元素是否为数组。仅使用element.property[0]检查属性对于字符串也是如此。除此之外，您可以传递返回布尔值内部过滤器的任何内容，就像在if语句中一样。

arr.filter(e => 'myproperty' in e && 
      Array.isArray(e.myproperty) && 
      e.myproperty[0] !== undefined)

具有可能未定义属性的数组过滤器

6 个答案: