Array.prototype.filter()

filter() erstellt ein neues Array, das alle Elemente enthält, die den Test, der in der angegebenen Callback Function implementiert ist, bestehen.

Syntax

var new_array = arr.filter(callback[, thisArg])

Parameter

callback
Eine Funktion, um jedes Element des Arrays zu testen. Die Funktion wird aufgerufen mit den Argumenten  (element, index, array). true zurückgeben, um das Element zu behalten, ansonsten false.
thisArg
Optional. Wert, der als this innerhalb der Funktion genutzt wird.

Rückgabewert

Ein neues Array mit den Elementen, die den Test bestanden haben.

Beschreibung

filter() ruft die angegebene callback function jeweils für jedes Element im Array auf und erstellt ein neues Array mit allen Elementen, für die die callback function true oder einen Wert, der True impliziert zurückgibt. callback wird nur für Indizes aufgerufen, die einen Wert zugewiesen haben; es wird nicht für Indizes aufgerufen, die gelöscht wurden oder deren Werte niemals zugewiesen wurden. Array Elemente, die den Test nicht bestehen werden übersprungen und nicht im neuen Array angelegt.

callback wird mit folgenden drei Argumenten aufgerufen:

  1. Der Wert des Elements
  2. Der Index des Elements
  3. Das Array Objekt, für das die Funktion aufgerufen wird

Wird ein thisArg Parameter für filter() angegeben, so wird dieser innerhalb des Aufrufs von callback als Wert für this verwendet. Ansonsten wird undefined als Wert für this innerhalb von callback verwendet. Der Wert von this innerhalb von callback  folgt den Regeln, wie this innerhalb von Funktionen zu sehen ist.

filter() verändert nicht das Array, für das diese Funktion aufgerufen wird.

Die Elemente, die von filter() verarbeitet werden werden vor dem ersten Aufruf von callback bestimmt. Für Elemente, die nach dem Aufruf von filter() zum Array hinzugefügt werden, wird callback nicht aufgerufen. Werden bestehende Elemente des Arrays verändert, wird dennoch der Wert an callback übergeben, der beim Aufruf von filter() gesetzt war; Elemente, die gelöscht  wurden, werden nicht betrachtet.

Beispiele

Beispiel: Alle kleinen Werte herausfiltern

Das folgende Beispiel nutzt filter() um ein gefiltertes Array zu erstellen, aus dem alle Element mit Werten kleiner 10 entfernt sind.

function isBigEnough(value) {
  return value >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

Beispiel: Filtern von ungültigen Werten aus JSON

Das folgende Beispiel nutzt filter() um ein gefiltertes json von allen Elementen mit numerischer id , ungleich null, zu erstellen.

var arr = [
  { id: 15 },
  { id: -1 },
  { id: 0 },
  { id: 3 },
  { id: 12.2 },
  { },
  { id: null },
  { id: NaN },
  { id: 'undefined' }
];

var invalidEntries = 0;

function filterByID(obj) {
  if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) {
    return true;
  } else {
    invalidEntries++;
    return false;
  }
}

var arrByID = arr.filter(filterByID);

console.log('Filtered Array\n', arrByID); 
// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }]

console.log('Number of Invalid Entries = ', invalidEntries); 
// Number of Invalid Entries = 4 

Polyfill

filter() wurde dem ECMA-262 Standard in der fünften Edition hinzugefügt; deswegen kann es sein, dass es nicht in allen Standards implementiert ist. Durch Hinzufügen des folgenden Codes am Anfang eines Skripts ist die Verwendung von filter() auch in ECMA-262 Implementationen, die diese Funktion nicht nativ bereitstellen, möglich. Dieser Algorithmus ist exakt der, der in ECMA-262, 5th edition spezifiziert ist, unter der Annahme, dass fn.call den original Wert von Function.prototype.call() auswertet, und dass Array.prototype.push() seinen ursprünglichen Wert hat.

if (!Array.prototype.filter) {
  Array.prototype.filter = function(fun/*, thisArg*/) {
    'use strict';

    if (this === void 0 || this === null) {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== 'function') {
      throw new TypeError();
    }

    var res = [];
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++) {
      if (i in t) {
        var val = t[i];

        // NOTE: Technically this should Object.defineProperty at
        //       the next index, as push can be affected by
        //       properties on Object.prototype and Array.prototype.
        //       But that method's new, and collisions should be
        //       rare, so use the more-compatible alternative.
        if (fun.call(thisArg, val, i, t)) {
          res.push(val);
        }
      }
    }

    return res;
  };
}

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Array.prototype.filter' in dieser Spezifikation.
Standard Initiale Definition. Implemented in JavaScript 1.6.
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Array.prototype.filter' in dieser Spezifikation.
Standard  
ECMAScript 2017 Draft (ECMA-262)
Die Definition von 'Array.prototype.filter' in dieser Spezifikation.
Entwurf  

Browser Kompatibilität

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Ja) 1.5 (1.8) 9 (Ja) (Ja)
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Ja) (Ja) 1.0 (1.8) (Ja) (Ja) (Ja)

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

 Mitwirkende an dieser Seite: schlagi123, midnightmare, oliver-j, occcy
 Zuletzt aktualisiert von: schlagi123,