Resumen

El método filter() crea un nuevo array con todos los elementos que cumplan la condición implementada por la función dada.

// La siguiente función realiza una comprobación y devuelve un valor booleano (verdadero/falso)
function esSuficientementeGrande(valor) {
  return valor >= 10;
}

// Aquellos valores del array para los cuales esSuficientementeGrande devuelva verdadero, serán almacenados en una array de salida, sin modificar el array inicial
var filtrado = [12, 5, 8, 130, 44].filter(esSuficientementeGrande);
// filtrado es el nuevo array: [12, 130, 44]

Sintaxis

arr.filter(callback[, thisArg])

Parámetros

callback
Función que comprueba cada elemento del array para ver si cumple la condición (también llamada predicado).  Retorna true si el elemento la cumple o en caso contrario retornará false. Este callback acepta hasta tres parámetros.
element
El elemento en sí que se está visitando.
index
El índice del elemento que se está visitando.
array
El propio arreglo que se está filtrando.
thisArg
Opcional. Usa el valor como this cuando es ejecutado el callback.

Retorno

Un nuevo arreglo con los elementos que cumplen la condición.

Descripción

filter llama a la función dada callback  para cada elemento del array , y construye un nuevo array con todos los valores para los cuales  callback retorna un valor verdadero. callback es invocada sólo para índices del arreglo que tengan asignado un valor. No es invocada para índices que hayan sido borrados o a los que no se les haya asignado algún valor. Los elementos del array que no cumplan la condición callback  simplemente los salta, y no son incluidos en el nuevo arreglo.

callback es invocada con tres argumentos:

  1. El valor de cada elemento
  2. El índice del elemento
  3. El objeto Array que se está recorriendo

Si un parametro thisArg es dado a filter(), este será pasado a callback cuando sea invocada, para usarlo como valor this.  De lo contrario , se pasará el valor undefined como valor this.  El valor this dentro del callback se determina conforme a las las normas habituales para determinar el this visto por una función.

filter() no hace mutar el array sobre el cual es llamado.

El rango de elementos procesados por filter() se establece antes de la primera invocación de  callback. Los elementos que se añadan al array después de que comience la llamada a filter() no serán visitados por callback. Si se modifica o elimina un elemento existente del array, cuando pase su valor a callback será el que tenga cuando filter() lo recorra; los elementos que son eliminados no son recorridos.

Ejemplo

Filtrando todos los valores pequeños

El siguiente ejemplo usa filter() para crear un arreglo filtrado que excluye todos los elementos con valores inferiores a 10.

function esSuficientementeGrande(elemento) {
  return elemento >= 10;
}
var filtrados = [12, 5, 8, 130, 44].filter(esSuficientementeGrande);
// filtrados es [12, 130, 44]

Filtrando entradas inválidas desde un JSON

El siguiente ejemplo emplea filter() para crear un json filtrado con todos lo elementos que tengan id numérico distinto de cero.

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

var entradasInvalidas = 0;
// Si el elemento tiene un atributo id, y su valor correspondiente es un numero
// Y no es el valor NaN, entonces es una entrada válida
function filtrarPorID(obj) {
  if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) {
    return true;
  } else {
    entradasInvalidas++;
    return false;
  }
}

var arrPorID = arr.filter(filtrarPorID);

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

console.log('Número de Entradas Invalidas = ', entradasInvalidas); 
// 4

Búsqueda en la matríz

El siguiente ejemplo emplea filter() para filtrar el contendio de un arreglo en función de un criterio de búsqueda.

var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];

/**
 * Filtra la matríz en función de un criterio de búsqueda (query)
 */
function filterItems(query) {
  return fruits.filter(function(el) {
      return el.toLowerCase().indexOf(query.toLowerCase()) > -1;
  })
}

console.log(filterItems('ap')); // ['apple', 'grapes']
console.log(filterItems('an')); // ['banana', 'mango', 'orange']

Implementación en ES2015

const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];

/**
 * Filtra la matríz en función de un criterio de búsqueda (query)
 */
const filterItems = query => {
  return fruits.filter(el =>
    el.toLowerCase().indexOf(query.toLowerCase()) > -1
  );
}

console.log(filterItems('ap')); // ['apple', 'grapes']
console.log(filterItems('an')); // ['banana', 'mango', 'orange']

Polyfill

filter() se añadió a la norma ECMA-262 en la 5ta edición; como tal puede no estar presente en todas las implementaciones de la norma. Puedes sobrellevarlo insertando el siguiente código al comienzo de su programa, para permitir el uso de filter() en implementaciones de ECMA-262 que no lo soporten de forma nativa. Este algoritmo es exactamente el especificado en ECMA-262, 5ta edición, supone que  fn.call evalua al valor original de Function.prototype.call, y que Array.prototype.push tiene su valor original.

if (!Array.prototype.filter)
  Array.prototype.filter = function(func, thisArg) {
    'use strict';
    if ( ! ((typeof func === 'Function') && this) )
        throw new TypeError();

    var len = this.length >>> 0,
        res = new Array(len), // preallocate array
        c = 0, i = -1;
    if (thisArg === undefined)
      while (++i !== len)
        // checks to see if the key was set
        if (i in this)
          if (func(t[i], i, t))
            res[c++] = t[i];
    else
      while (++i !== len)
        // checks to see if the key was set
        if (i in this)
          if (func.call(thisArg, t[i], i, t))
            res[c++] = t[i];

    res.length = c; // shrink down array to proper size
    return res;
  };

Especificaciones

 

Especificación Estado Comentario
ECMAScript 5.1 (ECMA-262)
La definición de 'Array.prototype.filter' en esta especificación.
Standard Definición Inicial. implementado en JavaScript 1.6.
ECMAScript 2015 (6th Edition, ECMA-262)
La definición de 'Array.prototype.filter' en esta especificación.
Standard  

Compatibilidad en navegadores

We're converting our compatibility data into a machine-readable JSON format. This compatibility table still uses the old format, because we haven't yet converted the data it contains. Find out how you can help!

Característica Chrome Firefox (Gecko) Internet Explorer Opera Safari
Soporte básico (Yes) 1.5 (1.8) 9 (Yes) (Yes)
Característica Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Soporte básico (Yes) (Yes) 1.0 (1.8) (Yes) (Yes) (Yes)

Vease también

Etiquetas y colaboradores del documento

 Última actualización por: robe007,