배열에서 요소의 모든 발생에 대한 인덱스를 찾는 방법은?

배열에서 요소의 모든 발생에 대한 인덱스를 찾는 방법은?

저는 자바스크립트 배열에서 "나노"와 같은 요소의 모든 인스턴스의 인덱스를 찾으려고 합니다.

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

저는 jQuery.inArray, 또는 유사하게 .indexOf()를 시도했지만 요소의 마지막 인스턴스 인덱스, 즉 이 경우 5만 제공했습니다.

모든 인스턴스에 대해 어떻게 얻습니까?

메서드에는 검색을 시작할 인덱스를 지정하는 선택적인 두 번째 매개 변수가 있으므로 루프에서 해당 매개 변수를 호출하여 특정 값의 모든 인스턴스를 찾을 수 있습니다.

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

인덱스를 어떻게 사용할지 명확하게 하지 않아서, 제 함수는 인덱스를 배열로 반환하지만(값이 발견되지 않으면 빈 배열로 반환합니다), 루프 내의 개별 인덱스 값으로 다른 작업을 수행할 수도 있습니다.

업데이트: VisioN의 의견에 따르면, 간단한 루프를 사용하면 동일한 작업을 보다 효율적으로 수행할 수 있으며, 이해하기 쉬우며, 따라서 유지보수가 보다 용이합니다.

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

또 다른 대안은 다음을 사용하는 것입니다.

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

N.B: 브라우저 호환성 확인reduce방법을 사용하고 필요한 경우 폴리필을 사용합니다.

Array.prototype.map()과 Array.prototype을 사용하는 또 다른 접근 방식입니다.필터 ():

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

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); // []

두 가지 방법을 모두 사용하여 간단하게 읽을 수 있는 해결책을 작성할 수 있습니다.map그리고.filter:

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

---

편집: IE/Edge를 지원할 필요가 없거나 코드를 변환하는 경우 ES2019에서 플랫맵을 제공했는데, 이를 통해 간단한 One-liner로 작업할 수 있습니다.

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

나는 단지 다른 쉬운 방법으로 업데이트하고 싶습니다.

각 방법에 사용할 수도 있습니다.

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

var result = [];

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

참고: MDN은 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);
}

그것이 다른 대답들보다 더 낫다고 말하지는 않을 것입니다.흥미롭네요.

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

효과가 있었습니다.

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]

다른 방법을 공유하기 위해서는 함수 생성기를 사용하여 다음과 같은 결과를 얻을 수 있습니다.

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

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

=> [0, 2]

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

다음과 같이 사용합니다.

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

result: [0, 3, 7]

스택을 사용하여 "arr[i]==value" 조건이 발생할 때마다 "i"를 스택에 밀어 넣을 수 있습니다.

확인할 내용:

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(); 
    }
}

두 매개 변수가 모두 배열로 전달된 경우

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

findIndex()도 유용합니다.

var cars = ['Nano', 'Volvo', 'BMW', 'Nano', 'VW', 'Nano'];

const indexes = [];
const searchedItem = 'NaNo';

cars.findIndex((value, index) => {
  if (value.toLowerCase() === searchedItem.toLowerCase()) {
    indexes.push(index);
  }
});

console.log(indexes); //[ 0, 3, 5 ]

보너스:

이 사용자 지정 솔루션은Object.entries()그리고.forEach()

var cars = ['Nano', 'Volvo', 'BMW', 'Nano', 'VW', 'Nano'];

const indexes = [];
const searchableItem = 'Nano';

Object.entries(cars).forEach((item, index) => {
  if (item[1].toLowerCase() === searchableItem.toLowerCase())
    indexes.push(index);
});

console.log(indexes);

참고: 모든 테스트를 실행하지 않았습니다.

findIndex는 콜백 출력과 일치하는 첫 번째 인덱스만 검색합니다.당신은 당신만의 것을 구현할 수 있습니다.findIndexesArray를 확장한 다음, 당신의 배열을 새로운 구조에 캐스팅함.

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

언급URL : https://stackoverflow.com/questions/20798477/how-to-find-the-indexes-of-all-occurrences-of-an-element-in-array