Restituisce l'indice del massimo valore in un array

Ho questo:

var arr = [0, 21, 22, 7];

Qual è il modo migliore per restituire l'indice del valore più alto in un'altra variabile?

Questo è probabilmente il modo migliore, poiché è affidabile e funziona su vecchi browser:

function indexOfMax(arr) {
    if (arr.length === 0) {
        return -1;
    }

    var max = arr[0];
    var maxIndex = 0;

    for (var i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            maxIndex = i;
            max = arr[i];
        }
    }

    return maxIndex;
}

C'è anche questo one-liner:

let i = arr.indexOf(Math.max(...arr));

Esegue il doppio del confronto necessario e genererà RangeErrorarray di grandi dimensioni. Attaccherei alla funzione.

In una riga e probabilmente più veloce di arr.indexOf(Math.max.apply(Math, arr)):

var a = [0, 21, 22, 7];
var indexOfMaxValue = a.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0);

document.write("indexOfMaxValue = " + indexOfMaxValue); // prints "indexOfMaxValue = 2"

Dove:

• iMax- il miglior indice finora (l'indice dell'elemento max finora, sulla prima iterazione iMax = 0perché il secondo argomento reduce()è 0, non possiamo omettere il secondo argomento reduce()nel nostro caso)
• x - l'elemento attualmente testato dall'array
• i - l'indice attualmente testato
• arr- il nostro array ( [0, 21, 22, 7])

Informazioni sul reduce()metodo (da "JavaScript: The Definitive Guide" di David Flanagan):

reduce () accetta due argomenti. La prima è la funzione che esegue l'operazione di riduzione. Il compito di questa funzione di riduzione è in qualche modo combinare o ridurre due valori in un singolo valore e restituire quel valore ridotto.

Le funzioni utilizzate con reduce () sono diverse dalle funzioni utilizzate con forEach () e map (). Il valore familiare, l'indice e i valori dell'array vengono passati come secondo, terzo e quarto argomento. Il primo argomento è il risultato accumulato della riduzione finora. Alla prima chiamata alla funzione, questo primo argomento è il valore iniziale passato come secondo argomento per ridurre (). Nelle chiamate successive, è il valore restituito dalla precedente chiamata della funzione.

Quando si richiama ridurre () senza alcun valore iniziale, utilizza il primo elemento dell'array come valore iniziale. Ciò significa che la prima chiamata alla funzione di riduzione avrà il primo e il secondo elemento dell'array come primo e secondo argomento.

Ecco un'altra soluzione, se si utilizza ES6 utilizzando l'operatore spread:

var arr = [0, 21, 22, 7];

const indexOfMaxValue = arr.indexOf(Math.max(...arr));

A meno che non mi sbagli, direi che è scrivere la tua funzione.

function findIndexOfGreatest(array) {
  var greatest;
  var indexOfGreatest;
  for (var i = 0; i < array.length; i++) {
    if (!greatest || array[i] > greatest) {
      greatest = array[i];
      indexOfGreatest = i;
    }
  }
  return indexOfGreatest;
}

Se stai utilizzando il trattino basso, puoi usare questo simpatico short one-liner:

_.indexOf(arr, _.max(arr))

Prima troverà il valore dell'elemento più grande nell'array, in questo caso 22. Quindi restituirà l'indice di dove 22 è all'interno dell'array, in questo caso 2.

Un'altra soluzione di max utilizzando reduce:

[1,2,5,0,4].reduce((a,b,i) => a[0] < b ? [b,i] : a, [Number.MIN_VALUE,-1])
//[5,2]

Questo ritorna [5e-324, -1]se l'array è vuoto. Se vuoi solo l'indice, metti [1]dopo.

Min via (Cambia in >e MAX_VALUE):

[1,2,5,0,4].reduce((a,b,i) => a[0] > b ? [b,i] : a, [Number.MAX_VALUE,-1])
//[0, 3]

EDIT: anni fa ho dato una risposta a questo che era grossolano, troppo specifico e troppo complicato. Quindi lo sto modificando. Preferisco le risposte funzionali sopra per il loro fattore pulito ma non per la loro leggibilità; ma se avessi più familiarità con JavaScript, mi potrebbero piacere anche per quello.

Pseudo codice:

Traccia l'indice che contiene il valore più grande. Supponiamo che inizialmente l'indice 0 sia il più grande. Confronta con l'indice corrente. Aggiorna l'indice con il valore più grande, se necessario.

Codice:

var mountains = [3, 1, 5, 9, 4];

function largestIndex(array){
  var counter = 1;
  var max = 0;

  for(counter; counter < array.length; counter++){
    if(array[max] < array[counter]){
        max = counter;
    }
  }
  return max;
}

console.log("index with largest value is: " +largestIndex(mountains));
// index with largest value is: 3

function findIndicesOf(haystack, needle)
{
    var indices = [];

    var j = 0;
    for (var i = 0; i < haystack.length; ++i) {
        if (haystack[i] == needle)
            indices[j++] = i;
    }
    return indices;
}

passare arrayda haystacke Math.max(...array)verso needle. Ciò fornirà tutti gli elementi massimi dell'array ed è più estensibile (ad esempio, è necessario trovare anche i valori minimi)

Se si crea una copia dell'array e la si ordina in ordine decrescente, il primo elemento della copia sarà il più grande. Di quanto puoi trovare il suo indice nella matrice originale.

var sorted = [...arr].sort((a,b) => b - a)
arr.indexOf(sorted[0])

La complessità temporale è O (n) per la copia, O (n * log (n)) per l'ordinamento e O (n) per indexOf.

Se devi farlo più velocemente, la risposta di Ry è O (n).

Una versione stabile di questa funzione è simile alla seguente:

// not defined for empty array
function max_index(elements) {
    var i = 1;
    var mi = 0;
    while (i < elements.length) {
        if (!(elements[i] < elements[mi]))
            mi = i;
        i += 1;
    }
    return mi;
}

Semplice

maxarr: function(){
let maxval = 0;
let maxindex = null;
for (i = 0; i < arr.length; i++){
if (arr[i] > maxval) {
maxval = arr[i];
maxindex = i;
}
}
}