Как найти первый элемент массива, соответствующий логическому условию в 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 так много методов массива в функциональном стиле, может быть, есть что-то подобное?

Вы можете использовать someметод Array для итерации массива до тех пор, пока не будет выполнено условие (и затем остановитесь). К сожалению, он вернет только то, было ли условие выполнено один раз, а не по какому элементу (или по какому индексу) оно было выполнено. Поэтому мы должны немного изменить его:

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 . MDN также предлагает шимм, если по какой-то причине вы не хотите использовать весь эс6 шим в своем проекте. Для максимальной совместимости вы хотите использовать es6-shim, потому что в отличие от версии MDN он обнаруживает ошибочные собственные реализации findи перезаписывает их (см. Комментарий, который начинается «Обойти ошибки в Array # find и Array # findIndex» и строки, следующие непосредственно за ней) ,

Как насчет использования фильтра и получения первого индекса из полученного массива?

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

К настоящему времени должно быть ясно, что JavaScript не предлагает такого решения изначально; Вот два ближайших производных, самый полезный первый:

1. Array.prototype.some(fn)предлагает желаемое поведение остановки при выполнении условия, но возвращает только наличие элемента; нетрудно применить некоторые хитрости, такие как решение, предложенное ответом Берги .

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 Developer Network предусмотрена поли-заливка (вставлено ниже):

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/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find

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

Я получил вдохновение из нескольких источников в Интернете, чтобы получить решение ниже. Хотел принять во внимание как некоторые значения по умолчанию, так и предоставить способ сравнения каждой записи для общего подхода, который решается.

Использование: (давая значение "Второй")

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.