Come trovare il primo elemento dell'array che corrisponde a una condizione booleana in JavaScript?

Mi chiedo se esista un modo noto, integrato / elegante per trovare il primo elemento di un array JS che corrisponde a una determinata condizione. L'equivalente AC # sarebbe List.Find .

Finora ho utilizzato una combinazione a due funzioni come questa:

// 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 poi posso usare:

var result = someArray.findFirst(isNotNullNorUndefined);

Ma poiché ci sono così tanti metodi di array in stile funzionale in ECMAScript , forse c'è già qualcosa di simile? Immagino che molte persone debbano implementare cose del genere tutto il tempo ...

A partire da ES6 esiste il findmetodo nativo per gli array; questo interrompe l'enumerazione dell'array una volta che trova la prima corrispondenza e restituisce il valore.

const result = someArray.find(isNotNullNorUndefined);

Vecchia risposta:

Devo pubblicare una risposta per interrompere questi filtersuggerimenti :-)

poiché ci sono così tanti metodi di array in stile funzionale in ECMAScript, forse c'è già qualcosa di simile?

È possibile utilizzare il somemetodo Array per iterare l'array fino a quando non viene soddisfatta una condizione (e quindi interrompere). Sfortunatamente restituirà solo se la condizione è stata soddisfatta una volta, non da quale elemento (o in quale indice) è stata soddisfatta. Quindi dobbiamo modificarlo un po ':

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 partire da ECMAScript 6, puoi usare Array.prototype.findper questo. Questo è implementato e funziona in Firefox (25.0), Chrome (45.0), Edge (12) e Safari (7.1), ma non in Internet Explorer o in un mucchio di altre piattaforme vecchie o non comuni .

Ad esempio, di xseguito è 106:

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

Se vuoi usarlo adesso ma hai bisogno del supporto per IE o altri browser non supportati, puoi usare uno shim. Raccomando es6-shim . MDN offre anche uno shim se per qualche motivo non vuoi inserire l'intero es6-shim nel tuo progetto. Per la massima compatibilità si desidera es6-shim, perché a differenza della versione MDN rileva le implementazioni native difettose finde le sovrascrive (vedere il commento che inizia "Work around bugs in Array # find e Array # findIndex" e le righe immediatamente successive) .

Che ne dici di usare il filtro e ottenere il primo indice dall'array risultante?

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

Sommario:

• Per trovare il primo elemento in un array che corrisponde a una condizione booleana possiamo usare il ES6 find()
• find()si trova su in Array.prototypemodo che possa essere utilizzato su ogni array.
• find()accetta una richiamata quando booleanviene verificata una condizione. La funzione restituisce il valore (non l'indice!)

Esempio:

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

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

console.log(found);   //  56

Dovrebbe essere chiaro a questo punto che JavaScript non offre tale soluzione in modo nativo; ecco le due derivate più vicine, la prima più utile:

1. Array.prototype.some(fn)offre il comportamento desiderato di fermarsi quando una condizione è soddisfatta, ma restituisce solo se un elemento è presente; non è difficile applicare qualche trucco, come la soluzione offerta dalla risposta di Bergi .

2. Array.prototype.filter(fn)[0]è un ottimo one-liner ma è il meno efficiente, perché butti via gli N - 1elementi solo per ottenere ciò di cui hai bisogno.

I metodi di ricerca tradizionali in JavaScript sono caratterizzati dalla restituzione dell'indice dell'elemento trovato invece dell'elemento stesso o -1. Ciò evita di dover scegliere un valore di ritorno dal dominio di tutti i tipi possibili; un indice può essere solo un numero e i valori negativi non sono validi.

Entrambe le soluzioni sopra non supportano nemmeno la ricerca offset, quindi ho deciso di scrivere questo:

(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

Se stai usando underscore.jspuoi usare le sue funzioni finde indexOfper ottenere esattamente quello che vuoi:

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

Documentazione:

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

A partire da ES 2015, Array.prototype.find()fornisce questa funzionalità esatta.

Per i browser che non supportano questa funzione, Mozilla Developer Network ha fornito un polyfill (incollato di seguito):

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 () fa proprio questo, maggiori informazioni: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find

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

Ho tratto ispirazione da più fonti su Internet per ricavare la soluzione di seguito. Volevo prendere in considerazione sia alcuni valori predefiniti sia fornire un modo per confrontare ogni voce per un approccio generico che questo risolve.

Utilizzo: (dando valore "Secondo")

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

Implementazione:

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

Non esiste una funzione incorporata in Javascript per eseguire questa ricerca.

Se stai usando jQuery potresti fare un file jQuery.inArray(element,array).

Un modo meno elegante che mostrerà throwtutti i messaggi di errore giusti (basati su Array.prototype.filter) ma smetterà di iterare sul primo risultato è

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

Allora gli esempi sono

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

Funziona terminando filterusando throw.