¿Cómo encontrar el índice de todas las apariciones del elemento en la matriz?

Estoy tratando de encontrar el índice de todas las instancias de un elemento, digamos, "Nano", en una matriz de JavaScript.

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

Probé jQuery.inArray , o de manera similar, .indexOf () , pero sólo di el índice de la última instancia del elemento, es decir, 5 en este caso.

¿Cómo lo obtengo para todas las instancias?

El .indexOf()método tiene un segundo parámetro opcional que especifica el índice desde el que comenzar la búsqueda, por lo que puede llamarlo en un bucle para encontrar todas las instancias de un valor particular:

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

Realmente no deja en claro cómo desea usar los índices, por lo que mi función los devuelve como una matriz (o devuelve una matriz vacía si no se encuentra el valor), pero podría hacer algo más con los valores de índice individuales dentro del bucle.

ACTUALIZACIÓN: según el comentario de VisioN, un bucle for simple haría el mismo trabajo de manera más eficiente, y es más fácil de entender y, por lo tanto, más fácil de mantener:

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

Otra solución alternativa es utilizar 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: Verifique la compatibilidad del navegador para conocer el reducemétodo y use polyfill si es necesario.

Otro enfoque que usa Array.prototype.map () y Array.prototype.filter () :

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

Manera más sencilla con estilo 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); // []

Puede escribir una solución legible simple para esto usando mapy filter:

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

EDITAR: Si no necesita ser compatible con IE / Edge (o está transpilando su código), ES2019 nos dio flatMap , que le permite hacer esto en una sola línea:

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

Nota: MDN proporciona un método que utiliza un bucle 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);
}

No diría que es mejor que otras respuestas. Solo interesante.

Solo quiero actualizar con otro método sencillo.

También puede utilizar el método 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)

Esto funcionó para mí:

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 para compartir otro método, puede usar generadores de funciones para lograr el resultado también:

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

Podemos usar Stack e insertar "i" en la pila cada vez que encontremos la condición "arr [i] == value"

Mira esto:

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]

Puedes usar 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;
};

}

Úselo así:

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

result: [0, 3, 7]

findIndexrecupera solo el primer índice que coincide con la salida de devolución de llamada. Puede implementar la suya propia findIndexesextendiendo Array y luego convirtiendo sus matrices en la nueva estructura.

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 tiene la intención de usar guión bajo / lodash, puede hacer

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]