Comment trouver l'index de toutes les occurrences d'élément dans le tableau?

J'essaie de trouver l'index de toutes les instances d'un élément, disons "Nano", dans un tableau JavaScript.

var Cars = ["Nano", "Volvo", "BMW", "Nano", "VW", "Nano"];

J'ai essayé jQuery.inArray , ou de manière similaire, .indexOf () , mais il n'a donné que l'index de la dernière instance de l'élément, soit 5 dans ce cas.

Comment puis-je l'obtenir pour toutes les instances?

La .indexOf()méthode a un deuxième paramètre facultatif qui spécifie l'index à partir duquel commencer la recherche, vous pouvez donc l'appeler dans une boucle pour trouver toutes les instances d'une valeur particulière:

function getAllIndexes(arr, val) {
    var indexes = [], i = -1;
    while ((i = arr.indexOf(val, i+1)) != -1){
        indexes.push(i);
    }
    return indexes;
}

var indexes = getAllIndexes(Cars, "Nano");

Vous n'indiquez pas vraiment comment vous voulez utiliser les index, donc ma fonction les renvoie sous forme de tableau (ou renvoie un tableau vide si la valeur n'est pas trouvée), mais vous pouvez faire autre chose avec les valeurs d'index individuelles à l'intérieur de la boucle.

MISE À JOUR: Selon le commentaire de VisioN, une simple boucle for ferait le même travail plus efficacement, et il est plus facile à comprendre et donc plus facile à maintenir:

function getAllIndexes(arr, val) {
    var indexes = [], i;
    for(i = 0; i < arr.length; i++)
        if (arr[i] === val)
            indexes.push(i);
    return indexes;
}

Une autre solution alternative consiste à utiliser Array.prototype.reduce():

["Nano","Volvo","BMW","Nano","VW","Nano"].reduce(function(a, e, i) {
    if (e === 'Nano')
        a.push(i);
    return a;
}, []);   // [0, 3, 5]

NB: Vérifiez la compatibilité du navigateur pour la reduceméthode et utilisez polyfill si nécessaire.

Une autre approche utilisant Array.prototype.map () et Array.prototype.filter () :

var indices = array.map((e, i) => e === value ? i : '').filter(String)

Une manière plus simple avec le style es6.

const indexOfAll = (arr, val) => arr.reduce((acc, el, i) => (el === val ? [...acc, i] : acc), []);


//Examples:
var cars = ["Nano", "Volvo", "BMW", "Nano", "VW", "Nano"];
indexOfAll(cars, "Nano"); //[0, 3, 5]
indexOfAll([1, 2, 3, 1, 2, 3], 1); // [0,3]
indexOfAll([1, 2, 3], 4); // []

Vous pouvez écrire une solution simple et lisible à cela en utilisant à la fois mapet filter:

const nanoIndexes = Cars
  .map((car, i) => car === 'Nano' ? i : -1)
  .filter(index => index !== -1);

EDIT: Si vous n'avez pas besoin de prendre en charge IE / Edge (ou si vous transpilez votre code), ES2019 nous a donné flatMap , qui vous permet de le faire en une seule ligne:

const nanoIndexes = Cars.flatMap((car, i) => car === 'Nano' ? i : []);

Remarque: MDN donne une méthode utilisant une boucle while :

var indices = [];
var array = ['a', 'b', 'a', 'c', 'a', 'd'];
var element = 'a';
var idx = array.indexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}

Je ne dirais pas que c'est mieux que d'autres réponses. Juste intéressant.

Je veux juste mettre à jour avec une autre méthode simple.

Vous pouvez également utiliser la méthode forEach.

var Cars = ["Nano", "Volvo", "BMW", "Nano", "VW", "Nano"];

var result = [];

Cars.forEach((car, index) => car === 'Nano' ? result.push(index) : null)

const indexes = cars
    .map((car, i) => car === "Nano" ? i : null)
    .filter(i => i !== null)

Cela a fonctionné pour moi:

let array1 = [5, 12, 8, 130, 44, 12, 45, 12, 56];
let numToFind = 12
let indexesOf12 = [] // the number whose occurrence in the array we want to find

array1.forEach(function(elem, index, array) {
    if (elem === numToFind) {indexesOf12.push(index)}
    return indexesOf12
})

console.log(indexesOf12) // outputs [1, 5, 7]

Juste pour partager une autre méthode, vous pouvez également utiliser des générateurs de fonctions pour obtenir le résultat:

function findAllIndexOf(target, needle) {
  return [].concat(...(function*(){
    for (var i = 0; i < target.length; i++) if (target[i] === needle) yield [i];
  })());
}

var target = "hellooooo";
var target2 = ['w','o',1,3,'l','o'];

console.log(findAllIndexOf(target, 'o'));
console.log(findAllIndexOf(target2, 'o'));

Nous pouvons utiliser Stack et pousser "i" dans la pile chaque fois que nous rencontrons la condition "arr [i] == value"

Vérifie ça:

static void getindex(int arr[], int value)
{
    Stack<Integer>st= new Stack<Integer>();
    int n= arr.length;
    for(int i=n-1; i>=0 ;i--)
    {
        if(arr[i]==value)
        {
            st.push(i);
        }
    }   
    while(!st.isEmpty())
    {
        System.out.println(st.peek()+" ");
        st.pop(); 
    }
}

["a", "b", "a", "b"]
   .map((val, index) => ({ val, index }))
   .filter(({val, index}) => val === "a")
   .map(({val, index}) => index)

=> [0, 2]

Vous pouvez utiliser Polyfill

if (!Array.prototype.filterIndex) {
Array.prototype.filterIndex = function (func, thisArg) {

    'use strict';
    if (!((typeof func === 'Function' || typeof func === 'function') && this))
        throw new TypeError();

    let len = this.length >>> 0,
        res = new Array(len), // preallocate array
        t = this, c = 0, i = -1;

    let kValue;
    if (thisArg === undefined) {
        while (++i !== len) {
            // checks to see if the key was set
            if (i in this) {
                kValue = t[i]; // in case t is changed in callback
                if (func(t[i], i, t)) {
                    res[c++] = i;
                }
            }
        }
    }
    else {
        while (++i !== len) {
            // checks to see if the key was set
            if (i in this) {
                kValue = t[i];
                if (func.call(thisArg, t[i], i, t)) {
                    res[c++] = i;
                }
            }
        }
    }

    res.length = c; // shrink down array to proper size
    return res;
};

}

Utilisez-le comme ceci:

[2,23,1,2,3,4,52,2].filterIndex(element => element === 2)

result: [0, 3, 7]

findIndexrécupère uniquement le premier index qui correspond à la sortie de rappel. Vous pouvez implémenter le vôtre findIndexesen étendant Array, puis en convertissant vos tableaux dans la nouvelle structure.

class EnhancedArray extends Array {
  findIndexes(where) {
    return this.reduce((a, e, i) => (where(e, i) ? a.concat(i) : a), []);
  }
}
   /*----Working with simple data structure (array of numbers) ---*/

//existing array
let myArray = [1, 3, 5, 5, 4, 5];

//cast it :
myArray = new EnhancedArray(...myArray);

//run
console.log(
   myArray.findIndexes((e) => e===5)
)
/*----Working with Array of complex items structure-*/

let arr = [{name: 'Ahmed'}, {name: 'Rami'}, {name: 'Abdennour'}];

arr= new EnhancedArray(...arr);


console.log(
  arr.findIndexes((o) => o.name.startsWith('A'))
)

Si vous avez l'intention d'utiliser un trait de soulignement / lodash, vous pouvez faire

var Cars = ["Nano", "Volvo", "BMW", "Nano", "VW", "Nano"];

_.chain(Cars).map((v, i)=> [i, v === "Nano"]).filter(v=>v[1]).map(v=>v[0]).value()

[0, 3, 5]