duplicados - Eliminar elementos con Array.map en JavaScript

map filter javascript

Question

Me gustaría filtrar una matriz de elementos utilizando la función map() . Aquí hay un fragmento de código:

var filteredItems = items.map(function(item)
{
if( ...some condition... )
{
return item;
}
});

El problema es que los elementos filtrados todavía usan espacio en la matriz y me gustaría eliminarlos por completo.

¿Alguna idea?

EDITAR: Gracias, me olvidé de filter() , lo que quería es en realidad un filter() luego un map() .

EDIT2: Gracias por señalar que map() y filter() no están implementados en todos los navegadores, aunque mi código específico no estaba destinado a ejecutarse en un navegador.

Answer 1

Coloco esta respuesta aquí porque los polifills compartidos en esta página son abismales

function reduce(f, y, xs, context) {
var acc = y;
for (var i = 0, len = xs.length; i < len; i++)
acc = f.call(context, acc, xs[i], i, xs);
return acc;
}
function reduce1(f, xs, context) {
if (xs.length === 0)
throw Error(''cannot reduce empty array without initial value'');
else
return reduce(f, xs[0], xs.slice(1), context);
}
function map(f, xs, context) {
return reduce(function(acc, x, i) {
return acc.concat([
f.call(context, x, i, xs)
]);
}, [], xs);
}
function filter(f, xs, context) {
return reduce(function(acc, x, i) {
if (f.call(context, x, i, xs))
return acc.concat([x]);
else
return acc;
}, [], xs);
}

extender prototipos

if (Array.prototype.reduce === undefined) {
Array.prototype.reduce = function(f, initialValue, context) {
if (initialValue === undefined)
return reduce1(f, this, context);
else
return reduce(f, initialValue, this, context);
};
}
if (Array.prototype.map === undefined) {
Array.prototype.map = function(f, context) {
return map(f, this, context);
};
}
if (Array.prototype.filter === undefined) {
Array.prototype.filter = function(f, context) {
return filter(f, this, context);
};
}

Answer 2

Debe usar el método de filter lugar del mapa, a menos que desee mutar los elementos en la matriz, además del filtrado.

p.ej.

var filteredItems = items.filter(function(item)
{
return ...some condition...;
});

[Editar: Por supuesto, siempre sourceArray.filter(...).map(...) hacer sourceArray.filter(...).map(...) para filtrar y mutar]

Answer 3

En realidad, la respuesta aceptada te está fallando. ¿De verdad quieres usar reducir, a la:

http://elijahmanor.com/reducing-filter-and-map-down-to-reduce/

Pero, así que no solo pongo un enlace, aquí está la versión corta.

Le das reducir un argumento que es una función (generalmente anónima).

Esa función anónima toma dos parámetros: uno (como las funciones anónimas pasadas a map / filter / forEach) es el iteratee para ser operado. Hay otro argumento para la función anónima pasada para reducir, sin embargo, que esas funciones no aceptan, y ese es el valor que se transmitirá entre las llamadas a funciones, a menudo referido como la nota .

Tenga en cuenta que aunque Array.filter () toma solo un argumento (una función), Array.reduce () también toma un segundo argumento importante (aunque opcional): un valor inicial para ''memo'' que se pasará a esa función anónima como su primer argumento, y posteriormente puede ser mutado y transmitido entre llamadas a funciones. (Si no se proporciona, entonces ''memo'' en la primera llamada de función anónima será por defecto el primer iteratee, y el argumento ''iteratee'' será en realidad el segundo valor en el array)

En nuestro caso, vamos a pasar una matriz vacía para comenzar, y luego elegir si inyectar nuestra iteración en nuestra matriz o no en función de nuestra función: este es el proceso de filtrado.

Finalmente, devolveremos nuestra ''matriz en progreso'' en cada llamada de función anónima, y ​​reduceremos ese valor de retorno y lo pasaremos como un argumento (llamado memo) a su próxima llamada de función.

Esto permite que el filtro y el mapa sucedan en una iteración, reduciendo a la mitad nuestro número de iteraciones requeridas. :)

Para una explicación más completa, consulte MDN o el enlace de arriba. :)

Ejemplo básico de una llamada Reducir:

let array = [1,2,3];
const initialMemo = [];
array = array.reduce((memo, iteratee) => {
// if condition is our filter
if (iteratee > 1) {
// what happens inside the filter is the map
memo.push(iteratee * 2);
}
// this return value will be passed in as the ''memo'' argument
// to the next call of this function, and this function will have
// every element passed into it at some point.
return memo;
}, initialMemo)
console.log(array) // [4,6], equivalent to [(2 * 2), (3 * 2)]

versión más sucinta

[1,2,3].reduce((memo, value) => value > 1 ? memo.concat(value * 2) : memo, [])

Tenga en cuenta que la primera iteración no fue mayor que uno, por lo que se filtró. También tenga en cuenta la nota inicial, nombrada solo para aclarar su existencia y llamar la atención sobre ella. Una vez más, se pasa como ''memo'' a la primera llamada de función anónima, y ​​luego el valor devuelto de la función anónima se pasa como el argumento ''memo'' a la siguiente función.

Otro ejemplo del caso de uso clásico para memo sería devolver el número más pequeño o más grande en una matriz. Ejemplo:

[7,4,1,99,57,2,1,100].reduce((memo, val) => memo > val ? memo : val)
// ^this would return the largest number in the list.

Un ejemplo de cómo escribir su propia función de reducción (esto a menudo ayuda a entender funciones como estas, me parece):

test_arr = [];
// we accept an anonymous function, and an optional ''initial memo'' value.
test_arr.my_reducer = function(reduceFunc, initialMemo) {
// if we passed in two arguments, then our first memo value
// will be whatever is in index zero. (Otherwise, it will
// be that second argument.)
const initialMemoIsIndexZero = arguments.length > 1;
// here we use that logic to set the memo value accordingly.
let memo = initialMemoIsIndexZero ? initialMemo : this[0];
// here we use that same boolean to decide whether the first
// value we pass in as iteratee is either the first or second
// element
const initialIteratee = initialMemoIsIndexZero ? 1 : 0;
for (var i = initialIteratee; i < this.length; i++) {
// memo is either the argument passed in above, or the
// first item in the list. initialIteratee is either the
// first item in the list, or the second item in the list.
memo = reduceFunc(memo, this[i]);
}
// after we''ve compressed the array into a single value,
// we return it.
return memo;
}

No probé a fondo esa implementación, y simplemente la escribí fuera de mi cabeza, pero en mis dos casos de prueba básicos parecía funcionar. La implementación real permite el acceso a cosas como el índice, por ejemplo, pero espero que esto lo ayude a obtener una idea sencilla de lo esencial.

Answer 4

Eso no es lo que hace el mapa. Realmente quieres Array.filter . O si realmente desea eliminar los elementos de la lista original, tendrá que hacerlo imperativamente con un ciclo for.

Answer 5

Sin embargo, debe tener en cuenta que Array.filter no es compatible con todos los navegadores, por lo que debe Array.filter prototipo:

//This prototype is provided by the Mozilla foundation and
//is distributed under the MIT license.
//http://www.ibiblio.org/pub/Linux/LICENSES/mit.license
if (!Array.prototype.filter)
{
Array.prototype.filter = function(fun /*, thisp*/)
{
var len = this.length;
if (typeof fun != "function")
throw new TypeError();
var res = new Array();
var thisp = arguments[1];
for (var i = 0; i < len; i++)
{
if (i in this)
{
var val = this[i]; // in case fun mutates this
if (fun.call(thisp, val, i, this))
res.push(val);
}
}
return res;
};
}

Y al hacerlo, puede prototipar cualquier método que pueda necesitar.

Answer 6

var arr = [1,2,''xxx'',''yyy'']
arr = arr.filter(function(e){ return e != ''xxx'' });
arr // [1, 2, "yyy"]