Come trovare l'indice di tutte le occorrenze dell'elemento nell'array?

Sto cercando di trovare l'indice di tutte le istanze di un elemento, ad esempio "Nano", in un array JavaScript.

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

Ho provato jQuery.inArray , o in modo simile, .indexOf () , ma ha fornito solo l'indice dell'ultima istanza dell'elemento, cioè 5 in questo caso.

Come lo ottengo per tutte le istanze?

Il .indexOf()metodo ha un secondo parametro opzionale che specifica l'indice da cui iniziare la ricerca, quindi puoi chiamarlo in un ciclo per trovare tutte le istanze di un particolare valore:

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");

Non è davvero chiaro come si desidera utilizzare gli indici, quindi la mia funzione li restituisce come un array (o restituisce un array vuoto se il valore non viene trovato), ma potresti fare qualcos'altro con i singoli valori dell'indice all'interno del ciclo.

AGGIORNAMENTO: come da commento di VisioN, un semplice ciclo for otterrebbe lo stesso lavoro svolto in modo più efficiente ed è più facile da capire e quindi più facile da mantenere:

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

Un'altra soluzione alternativa è utilizzare 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: verificare la compatibilità del browser per il reducemetodo e utilizzare polyfill se necessario.

Un altro approccio che utilizza Array.prototype.map () e Array.prototype.filter () :

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

Modo più semplice con lo stile 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); // []

Puoi scrivere una semplice soluzione leggibile a questo utilizzando sia mape filter:

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

EDIT: Se non hai bisogno di supportare IE / Edge (o stai traspilando il tuo codice), ES2019 ci ha fornito flatMap , che ti consente di farlo in una semplice riga :

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

Nota: MDN fornisce un metodo utilizzando un ciclo 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);
}

Non direi che sia migliore di altre risposte. Semplicemente interessante.

Voglio solo aggiornare con un altro metodo semplice.

Puoi anche usare forEach metodo.

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)

Questo ha funzionato per me:

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]

Solo per condividere un altro metodo, puoi usare anche i generatori di funzioni per ottenere il risultato:

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'));

Possiamo usare Stack e inserire "i" nello stack ogni volta che incontriamo la condizione "arr [i] == value"

Controllare questo:

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]

Puoi usare 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;
};

}

Usalo in questo modo:

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

result: [0, 3, 7]

findIndexrecupera solo il primo indice che corrisponde all'output di callback. Puoi implementarne uno tuo findIndexesestendendo Array, quindi eseguendo il casting degli array nella nuova struttura.

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'))
)

Se intendi usare il carattere di sottolineatura / lodash, potresti farlo

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]