Cómo paso un parámetro adicional a la función de devolución de llamada en Javascript.método filter ()?

El segundo parámetro de filter establecerá este dentro de la devolución de llamada.

arr.filter(callback[, thisArg])

Así que podrías hacer algo como:

function startsWith(element) {
    return element.indexOf(this) === 0;
}
addressBook.filter(startsWith, wordToCompare);

function startsWith(element, wordToCompare) {
    return element.indexOf(wordToCompare) === 0;
}

// ...
var word = "SOMETHING";

addressBook.filter(function(element){
    return startsWith(element, word);
});

Para aquellos que buscan una alternativa a ES6 usando funciones de flecha, puede hacer lo siguiente.

let startsWith = wordToCompare => (element, index, array) => {
  return element.indexOf(wordToCompare) === 0;
}

// where word would be your argument
let result = addressBook.filter(startsWith("word"));

La versión actualizada usando incluye :

const startsWith = wordToCompare => (element, index, array) => {
  return element.includes(wordToCompare);
}

Puede usar la función arrow dentro de un filtro, así:

result = addressBook.filter(element => element.indexOf(wordToCompare) === 0);

Funciones de flecha en MDN

Una expresión de función arrow tiene una sintaxis más corta en comparación con las expresiones de función y enlaza léxicamente el valor this (no enlaza su propio this, arguments, super o new).objetivo). Las funciones de flecha son siempre anónimas. Estas expresiones de función son las más adecuadas para funciones no metodológicas y no se pueden utilizar como constructores.

Para cualquiera que se pregunte por qué su función de flecha gorda está ignorando [, thisArg], por ejemplo, por qué

["DOG", "CAT", "DOG"].filter(animal => animal === this, "DOG") devuelve []

Es porque this dentro de esas funciones de flecha están enlazadas cuando se crea la función y se establecen al valor de this en el ámbito abarcador más amplio, por lo que el argumento thisArg se ignora. Conseguí alrededor de esto bastante fácilmente declarando una nueva variable en un ámbito padre:

let bestPet = "DOG"; ["DOG", "CAT", "DOG"].filter(animal => animal === bestPet); => ["DOG", "DOG"]

Aquí hay un enlace a algunas lecturas más: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#No_separate_this

Basado en la respuesta de oddRaven y https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Lo hice de 2 maneras diferentes . 1) usando la manera de la función . 2) usando la manera en línea .

//Here  is sample codes : 

var templateList   = [
{ name: "name1", index: 1, dimension: 1 }  ,
{ name: "name2", index: 2, dimension: 1 }  ,
{ name: "name3", index: 3, dimension: 2 }  ];


//Method 1) using function : 

function getDimension1(obj) {
                if (obj.dimension === 1) // This is hardcoded . 
                    return true;
                else return false;
            } 

var tl = templateList.filter(getDimension1); // it will return 2 results. 1st and 2nd objects. 
console.log(tl) ;

//Method 2) using inline way 
var tl3 = templateList.filter(element => element.index === 1 || element.dimension === 2  ); 
// it will return 1st and 3rd objects 
console.log(tl3) ;

Hay una manera fácil de usar la función de filtro, acceder a todos los parámetros, y no complicarlo demasiado.

A menos que la devolución de llamada thisArg esté establecida en otro filtro de ámbito no crea su propio ámbito, y podemos acceder a parámetros dentro del ámbito actual. Podemos establecer 'this' para definir un ámbito diferente con el fin de acceder a otros valores si es necesario, pero por defecto se establece en el ámbito desde el que se llama. Puede ver que se usa para alcances angulares en este stack .

Usar indexOf es derrotar el propósito del filtro y agregar más sobrecarga. Filtro ya está pasando por la matriz, así que ¿por qué necesitamos iterar a través de él de nuevo? En cambio, podemos hacer que sea una simple función pura.

Aquí hay un escenario de caso de uso dentro de un método de clase React donde el estado tiene un array llamado items , y usando filter podemos verificar el estado existente:

checkList = (item) => {  // we can access this param and globals within filter
  var result = this.state.filter(value => value === item); // returns array of matching items

  result.length ? return `${item} exists` : this.setState({
    items: items.push(item) // bad practice, but to keep it light
  });
}