Ce code renvoie le tableau correct mais je triche à l'intérieur de la fonction arrayFilter. En utilisant matchItem[0] et matchItem[1], je suis en train de coder en dur l'utilisation de seulement 2 éléments de filtre. S'il y en a moins de 2, le test échouera et s'il y en a plus de 2, les éléments supplémentaires ne seront pas filtrés.

function destroyer(arr) {
  // Remove all the values
  var destroyerArgsAmount = arguments.length;
  var matchArr = arguments[0];       
  var newArr = [];

  var matchItems = []; 
  for(i = 1; i < destroyerArgsAmount; i++) {
    matchItems.push(arr[i]);
  }

  function arrayFilter(val) {
    if(val != matchItems[0] && val != matchItems[1]) {
      return true;
    }
  }
  arr = matchArr.filter(arrayFilter);      
  return arr;
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

Pourquoi une boucle for ne fonctionne-t-elle pas dans cette situation?

for(i = 0; i < matchItems.length; i++) {      
      if(matchItems[i] != value) {
        return value;
      }

Cette boucle ne fonctionne pas lorsqu'elle est placée dans la fonction arrayFilter

Quelqu'un peut-il m'expliquer pourquoi et ensuite me mettre sur la bonne voie pour savoir comment procéder? Je pense que ce sera une chose importante à maîtriser car il existe de nombreuses méthodes employées de cette façon comme: filtre, carte, forEach et bien d'autres que je ne connais pas encore.

2
Dominofoe 22 juil. 2015 à 22:26

3 réponses

Meilleure réponse

Utilisez indexOf et retournez le résultat

function arrayFilter(val) {
   return matchItems.indexOf(val) === -1;
}

Je pense que vous cherchez peut-être quelque chose de plus comme ça

function destroyer() {
    var args     = [].slice.call(arguments),
        matchArr = args.shift();

    return matchArr.filter(function(item) {
        return args.every(function(item2) {
            return item !== item2;
        });
    });
}

VIOLON

1
adeneo 22 juil. 2015 à 19:51

Je ne suis pas exactement sûr des résultats que vous essayez d'obtenir car vous ne l'avez pas expliqué, mais je suppose que votre fonction essaie de filter tous les arguments passés après le premier argument {{X1 }}. Comme ça:

function destroyer (arr) {
  // You can use slice to grab all arguments after the first index in arguments
  var args = Array.prototype.slice.call(arguments, 1);

  return arr.filter(function (item) {
    // filter anything not found in the arguments list
    // indexOf will return -1 if not found
    return args.indexOf(item) < 0;
  });
}
4
jungy 22 juil. 2015 à 19:51

Vous semblez avoir besoin d'un moyen de vérifier si une valeur se trouve dans un tableau.

Comme mentionné par @adeneo, si val est une valeur primitive (chaîne, nombre, etc.) ou un objet qui doit être comparé par référence, la solution est aussi simple que

matchItems.indexOf(val) 

Qui renvoie un nombre positif (l'index) si val est l'un des éléments de matchItems et -1 sinon.


Si votre cas d'utilisation est légèrement plus compliqué, par exemple si matchItems contient des objets et que vous souhaitez voir si un objet avec une propriété particulière s'y trouve, vous pouvez utiliser Array.prototype.some:

var found = matchItems.some(function(item){
  return item === val; // use the apropriate comparison here
});

Votre code complet serait:

function destroyer(arr) {
  var matchItems = Array.prototype.slice.call(arguments, 1);
  return arr.filter(function(a) {
    return !matchItems.some(function(b){
      return a === b;
    });
  });
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);
3
Tibos 22 juil. 2015 à 19:50