Suppression d'éléments avec Array.map en JavaScript

Question

J'aimerais filtrer un tableau d'éléments en utilisant la fonction map() fonction. Voici un extrait de code :

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

Le problème est que les éléments filtrés utilisent encore de l'espace dans le tableau et j'aimerais les supprimer complètement.

Une idée ?

EDIT : Merci, j'avais oublié filter() Ce que je voulais, c'est en fait un filter() puis un map() .

EDIT2 : Merci de l'avoir signalé map() y filter() ne sont pas implémentés dans tous les navigateurs, bien que mon code spécifique ne soit pas destiné à être exécuté dans un navigateur.

Answer 1

TLDR : Utiliser map (retour undefined le cas échéant) et entonces filter .

---

Tout d'abord, je pense qu'une fonction map + filter est utile car vous ne voulez pas répéter un calcul dans les deux. Swift appelait à l'origine cette fonction flatMap mais l'a ensuite renommé en compactMap .

Par exemple, si nous ne disposons pas d'un compactMap nous pourrions nous retrouver avec computation défini deux fois :

  let array = [1, 2, 3, 4, 5, 6, 7, 8];
  let mapped = array
  .filter(x => {
    let computation = x / 2 + 1;
    let isIncluded = computation % 2 === 0;
    return isIncluded;
  })
  .map(x => {
    let computation = x / 2 + 1;
    return `${x} is included because ${computation} is even`
  })

  // Output: [2 is included because 2 is even, 6 is included because 4 is even]

Así compactMap serait utile pour réduire la duplication du code.

Une façon très simple de faire quelque chose de similaire à compactMap est de :

1. Carte sur les valeurs réelles ou undefined .
2. Filtrer tous les undefined valeurs.

Cela suppose bien sûr que vous n'ayez jamais besoin de renvoyer des valeurs indéfinies dans le cadre de votre fonction de carte originale.

Ejemplo:

  let array = [1, 2, 3, 4, 5, 6, 7, 8];
  let mapped = array
  .map(x => {
    let computation = x / 2 + 1;
    let isIncluded = computation % 2 === 0;
    if (isIncluded) {
      return `${x} is included because ${computation} is even`
    } else {
      return undefined
    }
  })
  .filter(x => typeof x !== "undefined")

Answer 2

L'instruction suivante nettoie l'objet à l'aide de la fonction map.

var arraytoclean = [{v:65, toberemoved:"gronf"}, {v:12, toberemoved:null}, {v:4}];
arraytoclean.map((x,i)=>x.toberemoved=undefined);
console.dir(arraytoclean);

Answer 3

Je viens d'écrire une intersection de tableaux qui gère correctement les doublons.

https://gist.github.com/gkucmierz/8ee04544fa842411f7553ef66ac2fcf0

// array intersection that correctly handles also duplicates

const intersection = (a1, a2) => {
  const cnt = new Map();
  a2.map(el => cnt[el] = el in cnt ? cnt[el] + 1 : 1);
  return a1.filter(el => el in cnt && 0 < cnt[el]--);
};

const l = console.log;
l(intersection('1234'.split``, '3456'.split``)); // [ '3', '4' ]
l(intersection('12344'.split``, '3456'.split``)); // [ '3', '4' ]
l(intersection('1234'.split``, '33456'.split``)); // [ '3', '4' ]
l(intersection('12334'.split``, '33456'.split``)); // [ '3', '3', '4' ]

Answer 4

Vous pouvez d'abord utiliser la carte et, avec le chaînage, vous pouvez utiliser le filtre.

state.map(item => {
            if(item.id === action.item.id){   
                    return {
                        id : action.item.id,
                        name : item.name,
                        price: item.price,
                        quantity : item.quantity-1
                    }

            }else{
                return item;
            }
        }).filter(item => {
            if(item.quantity <= 0){
                return false;
            }else{
                return true;
            }
        });