J'essaie d'écrire une fonction, qui accepte un tableau de tableaux comme argument et de filtrer ce tableau sous certaines conditions. J'expliquerai cette condition plus tard. Par exemple, j'ai un tel tableau:

 const arr = [
  [1, 1, 20],
  [2, 1, 15],
  [3, 1.5, 15],
  [4, 1, 15],
  [5, 1, 20],
  [6, 1.5, 15],
  [7, 1, 25],
  [8, 1, 15],
  [9, 0, 15],
  [10, 0, 15],
  [11, 0, 15],
]

Et la condition. Je veux le filtrer par la valeur de la troisième colonne, mais seulement si c'est au moins trois dans une séquence. La fonction doit accepter deux arguments (ou plus si nécessaire): valeur et tableau Donc par exemple

 const filterByValue = (array, val) => { //definition 
     return filtredArr
   }

Const newArr = filterByValue (array, 15) et maintenant newArr doit être égal à:

 [
   [2, 1, 15],
   [3, 1.5, 15],
   [4, 1, 15],
   [8, 1, 15],
   [9, 0, 15],
   [10, 0, 15],
   [11, 0, 15],
 ]

Pour l'instant je n'ai fait que:

const filterByValue = (arr, value) => {
      const newArr = arr.filter((elem, index) => elem[2] === value)
      return newArr
  }

Mais cette fonction renvoie

  [
     [2, 1, 15],
     [3, 1.5, 15],
     [4, 1, 15],
     [6, 1.5, 15],
     [8, 1, 15],
     [9, 0, 15],
     [10, 0, 15],
     [11, 0, 15],
  ]

Il ne devrait pas y avoir [6,1.5,15]. Je n'ai aucune idée de comment il pourrait être fait pour ne renvoyer que des fragments d'un tableau contenant au moins trois tableaux internes d'affilée. Peut-être que l'un de vous en a une idée?

Modifier plus d'explications

Cette séquence signifie pour moi que je veux seulement afficher les tableaux internes qui contiennent une valeur définie dans la troisième valeur (argument de valeur dans une fonction), mais qu'ils ont également des tableaux internes qui se suivent (au moins trois). Supposons que la fonction accepte arr (premier tableau de mon article) et value = 15. Le premier tableau interne contient 20 comme troisième valeur, donc il tombe. Le deuxième est correct, le troisième aussi et le quatrième aussi - et devrait revenir dans cette situation 2,3,4 conseil interne (car ils suivent trois successivement). Ensuite, la cinquième valeur est 20, la sixième valeur est 15, mais la prochaine (septième) valeur 25 à nouveau, donc la fonction ne doit pas prendre en compte la sixième table (car elle n'est pas suivie par au moins deux tables qui ont la valeur 15 ). Dans le tableau 8,9,10,11, nous avons la valeur 15, et ce sont quatre tableaux (c'est-à-dire au moins trois). Par conséquent, la fonction doit renvoyer un tableau contenant les tables suivantes 2,3,4 et 8,9,10,11. Le sixième tableau contient la valeur 15, mais pas suivi de deux autres qui auraient également cette valeur. Le résultat attendu est le deuxième tableau de mon message.

2
barteg 2 juin 2020 à 11:38

3 réponses

Meilleure réponse
const filterByValue = (arr,value) => {
    let newArray = [];
    let cache = [];
    arr.forEach(elem => {
        if (elem[2] === value) {
            cache.push(elem);
        } else {
            if (cache.length >= 3) {
                newArray = newArray.concat(cache);
            }
            cache = [];
        }
    });
    if (cache.length >= 3) {
        newArray = newArray.concat(cache);
    }
    return newArray;
}
3
Jan van de Loo 2 juin 2020 à 09:01

Vous pouvez utiliser .filter() ici.

const arr = [
[1,1,20],
[2,1,15],
[3,1.5,15],
[4,1,15],
[5,1,20],
[6,1.5,15],
[7,1,25],
[8,1,15],
[9,0,15],
[10,0,15],
[11,0,15],
]

function filterByArray(array, input){
   let result = [];
   for(let i = 0; i < array.length; i++){
   if(array[i + 2] === undefined){
      if(array[i + 1] === undefined){
         if(array[i] === undefined){
            break;
         }else{
            if(array[i][2] == input){
               result.push(array[i])
            }
            break;
         }
      }else{
         if(array[i + 1][2] == input){
               result.push(array[i])
            }
      }
   }
      if((array[i][2] + array[i+1][2] + array[i+2][2]) == input * 3){
         result.push(array[i]);
         result.push(array[i+1])
         result.push(array[i+2]);
         i +=2;
      }
   }
   return result;
}

let result = filterByArray(arr, 15);

console.log(result);
-1
Ifaruki 2 juin 2020 à 09:07

Vous pouvez prendre une clôture sur un index et vérifier si les valeurs sont dans une séquence de trois.

const
    array = [[1, 1, 20], [2, 1, 15], [3, 1.5, 15], [4, 1, 15], [5, 1, 20], [6, 1.5, 15], [7, 1, 25], [8, 1, 15], [9, 0, 15], [10, 0, 15], [11, 0, 15]],
    value = 15,
    result = array.filter(
        (index => ({ 2: v }, i, a) => {
            if (v !== value) return false;
            if (index === i || a[i + 1][2] === value && a[i + 2][2] === value) {
                index = i + 1;
                return true;
            }
        })
        (-1)
    );

console.log(result);
2
Nina Scholz 2 juin 2020 à 09:01