Comment trouver le premier élément d'un tableau correspondant à une condition booléenne en JavaScript ?

Question

Je me demande s'il existe un moyen connu, intégré/élégant de trouver le premier élément d'un tableau JS correspondant à une condition donnée. Un équivalent en C# serait Liste.Rechercher .

Jusqu'à présent, j'ai utilisé un combo à deux fonctions comme celui-ci :

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

Et puis je peux utiliser :

var result = someArray.findFirst(isNotNullNorUndefined);

Mais comme il y a tant de méthodes de tableau de style fonctionnel dans ECMAScript peut-être existe-t-il déjà quelque chose de ce genre ? J'imagine que beaucoup de gens doivent mettre en œuvre des trucs comme ça tout le temps...

Answer 1

Depuis ES6, il y a l'option native find méthode pour les tableaux ; cela arrête d'énumérer le tableau une fois qu'il a trouvé la première correspondance et retourne la valeur.

const result = someArray.find(isNotNullNorUndefined);

---

Vieille réponse :

Je dois poster une réponse pour arrêter ces filter suggestions :-)

Comme il existe de nombreuses méthodes de tableau de style fonctionnel dans l'ECMAScript, peut-être existe-t-il déjà quelque chose de ce type ?

Vous pouvez utiliser le some Méthode des tableaux pour itérer le tableau jusqu'à ce qu'une condition soit remplie (et ensuite s'arrêter). Malheureusement, elle ne retournera que si la condition a été remplie une fois, et non par quel élément (ou à quel index) elle a été remplie. Nous devons donc la modifier un peu :

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

Answer 2

A partir d'ECMAScript 6, vous pouvez utiliser Array.prototype.find pour ça. Ceci est implémenté et fonctionne dans Firefox (25.0), Chrome (45.0), Edge (12), et Safari (7.1), mais pas dans Internet Explorer ou un tas d'autres plateformes anciennes ou peu courantes .

Par exemple, x ci-dessous est 106 :

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

Si vous voulez l'utiliser dès maintenant mais que vous avez besoin de la prise en charge d'IE ou d'autres navigateurs non pris en charge, vous pouvez utiliser une cale. Je recommande la es6-shim . MDN propose également une cale si pour une raison quelconque vous ne voulez pas mettre l'ensemble de la es6-shim dans votre projet. Pour une compatibilité maximale, il faut utiliser la version es6-shim, car contrairement à la version MDN, elle détecte les implémentations natives boguées de find et les écrase (voir le commentaire qui commence par "Contourner les bogues dans Array#find et Array#findIndex". et les lignes qui le suivent immédiatement).

Answer 3

Et si on utilisait filtre et obtenir le premier indice du tableau résultant ?

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

Answer 4

Il devrait être clair maintenant que JavaScript n'offre pas une telle solution en natif ; voici les deux dérivés les plus proches, le plus utile en premier :

1. Array.prototype.some(fn) offre le comportement souhaité, à savoir s'arrêter lorsqu'une condition est remplie, mais ne renvoie que si un élément est présent ; il n'est pas difficile d'appliquer quelques astuces, telles que la solution proposée par La réponse de Bergi .

2. Array.prototype.filter(fn)[0] c'est une bonne phrase, mais c'est la moins efficace, car on jette N - 1 éléments juste pour obtenir ce dont vous avez besoin.

Les méthodes de recherche traditionnelles en JavaScript se caractérisent par le fait qu'elles renvoient l'index de l'élément trouvé au lieu de l'élément lui-même ou -1. Cela évite de devoir choisir une valeur de retour dans le domaine de tous les types possibles ; un index ne peut être qu'un nombre et les valeurs négatives ne sont pas valables.

Les deux solutions ci-dessus ne supportent pas non plus la recherche de décalage, j'ai donc décidé d'écrire ceci :

(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

Answer 5

Si vous utilisez underscore.js vous pouvez utiliser son find y indexOf pour obtenir exactement ce que vous voulez :

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

Documentation :

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