¿Cómo encontrar el primer elemento de la matriz que coincida con una condición booleana en JavaScript?

Me pregunto si hay una forma conocida, integrada / elegante de encontrar el primer elemento de una matriz JS que coincida con una condición dada. AC # equivalente sería List.Find .

Hasta ahora he estado usando un combo de dos funciones como este:

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

Y luego puedo usar:

var result = someArray.findFirst(isNotNullNorUndefined);

Pero dado que hay tantos métodos de matriz de estilo funcional en ECMAScript , ¿tal vez ya exista algo como esto? Me imagino que mucha gente tiene que implementar cosas como esta todo el tiempo ...

Desde ES6 existe el findmétodo nativo para matrices; esto deja de enumerar la matriz una vez que encuentra la primera coincidencia y devuelve el valor.

const result = someArray.find(isNotNullNorUndefined);

Vieja respuesta:

Tengo que publicar una respuesta para detener estas filtersugerencias :-)

Dado que hay tantos métodos de matriz de estilo funcional en ECMAScript, ¿tal vez ya haya algo así como esto?

Puede usar el somemétodo Array para iterar la matriz hasta que se cumpla una condición (y luego se detenga). Desafortunadamente, solo devolverá si la condición se cumplió una vez, no por qué elemento (o en qué índice) se cumplió. Entonces tenemos que enmendarlo un poco:

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 de ECMAScript 6, puede usarlo Array.prototype.findpara esto. Esto se implementa y funciona en Firefox (25.0), Chrome (45.0), Edge (12) y Safari (7.1), pero no en Internet Explorer o en un montón de otras plataformas antiguas o poco comunes .

Por ejemplo, la siguiente expresión se evalúa como 106.

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

Si desea usar esto en este momento pero necesita soporte para IE u otros navegadores no compatibles, puede usar una cuña. Recomiendo el es6-shim . MDN también ofrece una cuña si, por alguna razón, no desea poner todo el es6-shim en su proyecto. Para obtener la máxima compatibilidad, desea el es6-shim, porque a diferencia de la versión MDN, detecta implementaciones nativas con errores findy las sobrescribe (vea el comentario que comienza "Solución de errores en Array # find y Array # findIndex" y las líneas que lo siguen inmediatamente) .

¿Qué pasa con el uso de filtro y obtener el primer índice de la matriz resultante?

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

Ya debería estar claro que JavaScript no ofrece tal solución de forma nativa; Aquí están los dos derivados más cercanos, los más útiles primero:

1. Array.prototype.some(fn)ofrece el comportamiento deseado de detenerse cuando se cumple una condición, pero solo devuelve si un elemento está presente; No es difícil aplicar algunos trucos, como la solución ofrecida por la respuesta de Bergi .

2. Array.prototype.filter(fn)[0]lo convierte en un gran one-liner pero es el menos eficiente, ya que tira los N - 1elementos solo para obtener lo que necesita.

Los métodos de búsqueda tradicionales en JavaScript se caracterizan por devolver el índice del elemento encontrado en lugar del elemento mismo o -1. Esto evita tener que elegir un valor de retorno del dominio de todos los tipos posibles; un índice solo puede ser un número y los valores negativos no son válidos.

Ambas soluciones anteriores tampoco admiten la búsqueda offset, por lo que he decidido escribir esto:

(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

Resumen:

• Para encontrar el primer elemento en una matriz que coincide con una condición booleana, podemos usar el ES6 find()
• find()se encuentra en Array.prototypemodo que se puede usar en cada matriz.
• find()toma una devolución de llamada donde booleanse prueba una condición. La función devuelve el valor (¡no el índice!)

Ejemplo:

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

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

console.log(found);   //  56

Si está usando underscore.js, puede usar sus funciones findy indexOffunciones para obtener exactamente lo que desea:

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

Documentación:

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

A partir de ES 2015, Array.prototype.find()proporciona esta funcionalidad exacta.

Para los navegadores que no admiten esta función, la Red de desarrolladores de Mozilla ha proporcionado un polyfill (pegado a continuación):

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 () hace exactamente eso, más información: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find

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

Me inspiré en múltiples fuentes en Internet para obtener la solución a continuación. Quería tener en cuenta algunos valores predeterminados y proporcionar una forma de comparar cada entrada para un enfoque genérico que esto resuelve.

Uso: (dando valor "Segundo")

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

Implementación:

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

No hay una función incorporada en Javascript para realizar esta búsqueda.

Si está utilizando jQuery, puede hacer a jQuery.inArray(element,array).

Una forma menos elegante que tendrá throwtodos los mensajes de error correctos (basados ​​en Array.prototype.filter) pero dejará de iterar en el primer resultado es

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

Entonces los ejemplos son

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 al terminar filterusando throw.