Como encontrar o primeiro elemento da matriz que corresponde a uma condição booleana no JavaScript?

Gostaria de saber se existe uma maneira conhecida, embutida / elegante de encontrar o primeiro elemento de uma matriz JS que corresponda a uma determinada condição. AC # equivalente seria List.Find .

Até agora, eu tenho usado uma combinação de duas funções como esta:

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

E então eu posso usar:

var result = someArray.findFirst(isNotNullNorUndefined);

Mas como existem muitos métodos de matriz de estilo funcional no ECMAScript , talvez já exista algo como esse? Eu imagino que muitas pessoas precisam implementar coisas assim o tempo todo ...

Desde o ES6, existe o findmétodo nativo para matrizes; isso para de enumerar a matriz depois de encontrar a primeira correspondência e retornar o valor.

const result = someArray.find(isNotNullNorUndefined);

Resposta antiga:

Tenho que postar uma resposta para interromper essas filtersugestões :-)

Como existem muitos métodos de matriz de estilo funcional no ECMAScript, talvez já exista algo como esse?

Você pode usar o somemétodo Array para iterar a matriz até que uma condição seja atendida (e depois pare). Infelizmente, ele retornará apenas se a condição foi atendida uma vez, não por qual elemento (ou em qual índice) foi atendida. Então, temos que corrigi-lo um pouco:

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

A partir do ECMAScript 6, você pode usar Array.prototype.findpara isso. Isso é implementado e funciona no Firefox (25.0), Chrome (45.0), Edge (12) e Safari (7.1), mas não no Internet Explorer ou em várias outras plataformas antigas ou incomuns .

Por exemplo, a expressão abaixo é avaliada como 106.

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

Se você quiser usar isso agora, mas precisar de suporte para o IE ou outros navegadores não compatíveis, use um calço. Eu recomendo o es6-shim . O MDN também oferece um calço se, por algum motivo, você não quiser colocar todo o es6-shim em seu projeto. Para obter compatibilidade máxima, você deseja o es6-shim, porque, ao contrário da versão MDN, ele detecta implementações nativas de bugs finde as substitui (consulte o comentário que começa em "Como solucionar bugs na matriz # find e Array # findIndex" e nas linhas imediatamente a seguir) .

Que tal usar filtro e obter o primeiro índice da matriz resultante?

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

Já deve estar claro que o JavaScript não oferece essa solução nativamente; Aqui estão as duas derivadas mais próximas, as mais úteis primeiro:

1. Array.prototype.some(fn)oferece o comportamento desejado de parar quando uma condição é atendida, mas retorna apenas se um elemento está presente; não é difícil aplicar alguns truques, como a solução oferecida pela resposta de Bergi .

2. Array.prototype.filter(fn)[0]cria um ótimo one-liner, mas é o menos eficiente, porque você joga fora os N - 1elementos apenas para conseguir o que precisa.

Os métodos de pesquisa tradicionais em JavaScript são caracterizados pelo retorno do índice do elemento encontrado em vez do próprio elemento ou -1. Isso evita ter que escolher um valor de retorno do domínio de todos os tipos possíveis; um índice pode ser apenas um número e valores negativos são inválidos.

As duas soluções acima também não oferecem suporte à pesquisa de deslocamento, então decidi escrever o seguinte:

(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

Resumo:

• Para encontrar o primeiro elemento em uma matriz que corresponda a uma condição booleana, podemos usar o ES6 find()
• find()está localizado Array.prototypepara que possa ser usado em todas as matrizes.
• find()recebe um retorno de chamada onde uma booleancondição é testada. A função retorna o valor (não o índice!)

Exemplo:

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

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

console.log(found);   //  56

Se você estiver usando, underscore.jspoderá usar as funções finde indexOfpara obter exatamente o que deseja:

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

Documentação:

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

A partir do ES 2015, Array.prototype.find()fornece essa funcionalidade exata.

Para navegadores que não suportam esse recurso, a Mozilla Developer Network forneceu um polyfill (colado abaixo):

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 () faz exatamente isso, mais informações: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find

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

Eu me inspirei em várias fontes na internet para derivar a solução abaixo. Queria levar em consideração algum valor padrão e fornecer uma maneira de comparar cada entrada para uma abordagem genérica que isso resolve.

Uso: (dando valor "Segundo")

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

Implementação:

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

Não há função interna no Javascript para realizar esta pesquisa.

Se você estiver usando o jQuery, poderá fazer a jQuery.inArray(element,array).

Uma maneira menos elegante que exibirá throwtodas as mensagens de erro corretas (com base em Array.prototype.filter), mas interromperá a iteração no primeiro resultado é

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

Então exemplos são

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

Funciona terminando filterusando throw.