Wie findet man das erste Element eines Arrays, das einer booleschen Bedingung in JavaScript entspricht?

Question

Ich frage mich, ob es eine bekannte, integrierte/elegante Weise, das erste Element eines JS-Arrays zu finden, die eine bestimmte Bedingung übereinstimmt. Ein C#-Äquivalent würde sein Liste.Finden .

Bisher habe ich eine solche Zweifunktionskombination verwendet:

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

Und dann kann ich sie benutzen:

var result = someArray.findFirst(isNotNullNorUndefined);

Da es aber auch so viele funktionale Array-Methoden in ECMAScript Vielleicht gibt es ja schon so etwas? Ich kann mir vorstellen, dass viele Leute so etwas ständig implementieren müssen...

Answer 1

Ich habe mich von mehreren Quellen im Internet inspirieren lassen, um die folgende Lösung zu finden. Wollte zu berücksichtigen, sowohl einige Standardwert und eine Möglichkeit, jeden Eintrag für einen generischen Ansatz zu vergleichen, die dies löst bieten.

Verwendung: (mit dem Wert "Sekunde")

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

Umsetzung:

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

Answer 2

      const employees = [
        {id: 1, name: 'Alice', country: 'Canada'},
        {id: 2, name: 'Bob', country: 'Belgium'},
        {id: 3, name: 'Carl', country: 'Canada'},
        {id: 4, name: 'Dean', country: 'Germany'},
      ];

      //  filter with 1 condition
      const filtered = employees.filter(employee => {
        return employee.country === 'Canada';
      });
      //  [{id: 1, name: 'Alice', country: 'Canada'},
      //     {id: 3, name: 'Carl', 'country: 'Canada'}]
      console.log(filtered);

      //  filter with 2 conditions
      const filtered2 = employees.filter(employee => {
        return employee.country === 'Canada' && employee.id === 3;
      });

      //  [{id: 3, name: 'Carl', country: 'Canada'}]
      console.log('filtered2: ', filtered2);

      const employee = employees.find(obj => {
    return obj.country === 'Canada';
  });

  //  {id: 1, name: 'Alice', country: 'Canada'}
  console.log(employee);

Answer 3

Ein weniger eleganter Weg, der throw alle richtigen Fehlermeldungen (basierend auf Array.prototype.filter ), stoppt aber die Iteration, wenn das erste Ergebnis

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

Dann sind Beispiele

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

Es funktioniert durch die Beendigung filter durch die Verwendung von throw .

Answer 4

Es gibt keine eingebaute Funktion in Javascript, um diese Suche durchzuführen.

Wenn Sie jQuery verwenden, können Sie eine jQuery.inArray(element,array) .