如何在JavaScript中找到匹配布尔条件的数组的第一个元素？

我想知道是否有一种已知的，内置的/优雅的方法来找到匹配给定条件的JS数组的第一个元素。AC＃等效项为List.Find。

到目前为止，我一直在使用这样的两功能组合：

// Returns the first element of an array that satisfies given predicate
Array.prototype.findFirst = function (predicateCallback) {
    if (typeof predicateCallback !== 'function') {
        return undefined;
    }

    for (var i = 0; i < arr.length; i++) {
        if (i in this && predicateCallback(this[i])) return this[i];
    }

    return undefined;
};

// Check if element is not undefined && not null
isNotNullNorUndefined = function (o) {
    return (typeof (o) !== 'undefined' && o !== null);
};

然后我可以使用：

var result = someArray.findFirst(isNotNullNorUndefined);

但是，既然ECMAScript中有很多函数式数组方法，也许已经有类似的东西了？我想象很多人必须一直执行这样的事情...

从ES6开始，存在数组的本机find方法。一旦找到第一个匹配项并返回值，此操作将停止枚举数组。

const result = someArray.find(isNotNullNorUndefined);

旧答案：

我必须发布答案以停止这些filter建议：-)

由于ECMAScript中有很多功能样式的数组方法，所以也许已经有类似的东西了？

您可以使用someArray方法来迭代数组，直到满足条件为止（然后停止）。不幸的是，它将仅返回是否满足条件一次，而不返回满足条件的元素（或索引）。因此，我们必须对其进行一些修改：

function find(arr, test, ctx) {
    var result = null;
    arr.some(function(el, i) {
        return test.call(ctx, el, i, arr) ? ((result = el), true) : false;
    });
    return result;
}

var result = find(someArray, isNotNullNorUndefined);

从ECMAScript 6开始，您可以使用Array.prototype.find它。这是在Firefox（25.0），Chrome（45.0），Edge（12）和Safari（7.1）中实现并运行的，但在Internet Explorer或其他许多旧的或不常见的平台中却没有。

例如，以下表达式的计算结果为106。

[100,101,102,103,104,105,106,107,108,109].find(function (el) {
    return el > 105;
});

如果您现在想使用此功能，但需要IE或其他不支持的浏览器的支持，则可以使用填充程序。我推荐es6-shim。如果您出于某种原因不想将整个es6-shim放入您的项目中，则MDN也提供了一个shim。为了获得最大的兼容性，您需要es6-shim，因为与MDN版本不同，它会检测存在错误的本机实现find并将其覆盖（请参阅以“解决Array＃find和Array＃findIndex中的错误”开头的注释以及紧随其后的代码行） 。

如何使用过滤器并从结果数组中获取第一个索引？

var result = someArray.filter(isNotNullNorUndefined)[0];

现在应该很清楚，JavaScript本身没有提供这种解决方案。这是最接近的两个导数，最有用的是第一：

1. Array.prototype.some(fn)提供满足条件时停止的期望行为，但仅返回是否存在元素；不难运用一些技巧，例如Bergi的答案提供的解决方案。

2. Array.prototype.filter(fn)[0]只能提供出色的一线服务，但却效率最低，因为您N - 1为了获得所需的东西而丢弃了一些元素。

JavaScript中的传统搜索方法的特征是返回找到的元素的索引，而不是返回元素本身或-1。这样避免了必须从所有可能类型的域中选择返回值；索引只能是数字，并且负值无效。

上面的两个解决方案都不支持偏移搜索，因此我决定这样写：

(function(ns) {
  ns.search = function(array, callback, offset) {
    var size = array.length;

    offset = offset || 0;
    if (offset >= size || offset <= -size) {
      return -1;
    } else if (offset < 0) {
      offset = size - offset;
    }

    while (offset < size) {
      if (callback(array[offset], offset, array)) {
        return offset;
      }
      ++offset;
    }
    return -1;
  };
}(this));

search([1, 2, NaN, 4], Number.isNaN); // 2
search([1, 2, 3, 4], Number.isNaN); // -1
search([1, NaN, 3, NaN], Number.isNaN, 2); // 3

摘要：

• 为了找到匹配布尔条件的数组中的第一个元素，我们可以使用 ES6 find()
• find()位于上，Array.prototype因此可以在每个阵列上使用。
• find()接受boolean测试条件的回调。该函数返回值（不是索引！）

例：

const array = [4, 33, 8, 56, 23];

const found = array.find((element) => {
  return element > 50;
});

console.log(found);   //  56

如果您正在使用underscore.js，则可以使用其find和indexOf函数来获取所需的确切信息：

var index = _.indexOf(your_array, _.find(your_array, function (d) {
    return d === true;
}));

说明文件：

• http://underscorejs.org/#find
• http://underscorejs.org/#indexOf

从ES 2015开始，Array.prototype.find()提供了此确切功能。

对于不支持此功能的浏览器，Mozilla开发人员网络提供了polyfill（粘贴在下面）：

if (!Array.prototype.find) {
  Array.prototype.find = function(predicate) {
    if (this === null) {
      throw new TypeError('Array.prototype.find called on null or undefined');
    }
    if (typeof predicate !== 'function') {
      throw new TypeError('predicate must be a function');
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

    for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return value;
      }
    }
    return undefined;
  };
}

Array.prototype.find（）就是这样做，更多信息：https : //developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/find

foundElement = myArray[myArray.findIndex(element => //condition here)];

我从互联网上的多个来源获得了灵感，可以得出以下解决方案。希望同时考虑一些默认值，并提供一种比较每个条目的方法，以解决此问题。

用法：（赋予值“ Second”）

var defaultItemValue = { id: -1, name: "Undefined" };
var containers: Container[] = [{ id: 1, name: "First" }, { id: 2, name: "Second" }];
GetContainer(2).name;

实现方式：

class Container {
    id: number;
    name: string;
}

public GetContainer(containerId: number): Container {
  var comparator = (item: Container): boolean => {
      return item.id == containerId;
    };
    return this.Get<Container>(this.containers, comparator, this.defaultItemValue);
  }

private Get<T>(array: T[], comparator: (item: T) => boolean, defaultValue: T): T {
  var found: T = null;
  array.some(function(element, index) {
    if (comparator(element)) {
      found = element;
      return true;
    }
  });

  if (!found) {
    found = defaultValue;
  }

  return found;
}

Javascript中没有内置函数可以执行此搜索。

如果您使用的是jQuery，则可以执行jQuery.inArray(element,array)。

一种不太好用的方法，它会throw保留所有正确的错误消息（基于Array.prototype.filter），但会停止对第一个结果进行迭代

function findFirst(arr, test, context) {
    var Result = function (v, i) {this.value = v; this.index = i;};
    try {
        Array.prototype.filter.call(arr, function (v, i, a) {
            if (test(v, i, a)) throw new Result(v, i);
        }, context);
    } catch (e) {
        if (e instanceof Result) return e;
        throw e;
    }
}

然后的例子是

findFirst([-2, -1, 0, 1, 2, 3], function (e) {return e > 1 && e % 2;});
// Result {value: 3, index: 5}
findFirst([0, 1, 2, 3], 0);               // bad function param
// TypeError: number is not a function
findFirst(0, function () {return true;}); // bad arr param
// undefined
findFirst([1], function (e) {return 0;}); // no match
// undefined

它的工作方式结束filter使用throw。