Antworten:
Array.max = function( array ){
return Math.max.apply( Math, array );
};
Warnung : Da die maximale Anzahl von Argumenten auf einigen VMs nur 65535 beträgt , verwenden Sie eine for-Schleife, wenn Sie nicht sicher sind, ob das Array so klein ist.
apply
Anrufs dies sehr leicht auswaschen.
RangeError: Maximum call stack size exceeded.
Mit der Apply- Funktion können Sie Math.max aufrufen :
var array = [267, 306, 108];
var largest = Math.max.apply(Math, array); // 306
Wie es funktioniert?
Die Apply- Funktion wird verwendet, um eine andere Funktion mit einem bestimmten Kontext und Argumenten aufzurufen, die als Array bereitgestellt werden. Die Funktionen min und max können eine beliebige Anzahl von Eingabeargumenten annehmen: Math.max (val1, val2, ..., valN)
Also, wenn wir anrufen:
Math.min.apply(Math, [1,2,3,4]);
Die Apply-Funktion wird ausgeführt:
Math.min(1,2,3,4);
Beachten Sie, dass der erste Parameter, der Kontext, für diese Funktionen nicht wichtig ist, da sie statisch sind und unabhängig davon funktionieren, was als Kontext übergeben wird.
Die einfachste Syntax mit dem neuen Spread-Operator :
var arr = [1, 2, 3];
var max = Math.max(...arr);
Quelle: Mozilla MDN
Ich bin kein JS-Experte, aber ich wollte sehen, wie sich diese Methoden stapeln, daher war dies eine gute Praxis für mich. Ich weiß nicht, ob dies technisch der richtige Weg ist, um diese zu testen, aber ich habe sie einfach direkt nacheinander ausgeführt, wie Sie in meinem Code sehen können.
Das Sortieren und Abrufen des 0. Werts ist bei weitem die schlechteste Methode (und ändert die Reihenfolge Ihres Arrays, was möglicherweise nicht wünschenswert ist). Für die anderen ist der Unterschied vernachlässigbar, es sei denn, Sie sprechen von Millionen von Indizes.
Durchschnittliche Ergebnisse von fünf Läufen mit einem 100.000-Index-Array von Zufallszahlen:
var performance = window.performance
function findmax(array)
{
var max = 0,
a = array.length,
counter
for (counter=0;counter<a;counter++)
{
if (array[counter] > max)
{
max = array[counter]
}
}
return max
}
function findBiggestNumber(num) {
var counts = []
var i
for (i = 0; i < num; i++) {
counts.push(Math.random())
}
var a, b
a = performance.now()
var biggest = counts.reduce(function(highest, count){
return highest > count ? highest : count
}, 0)
b = performance.now()
console.log('reduce took ' + (b - a) + ' ms to run')
a = performance.now()
var biggest2 = Math.max.apply(Math, counts)
b = performance.now()
console.log('Math.max.apply took ' + (b - a) + ' ms to run')
a = performance.now()
var biggest3 = counts.sort(function(a,b){return b-a;})[0]
b = performance.now()
console.log('sorting and getting the 0th value took ' + (b - a) + ' ms to run')
a = performance.now()
var biggest4 = counts.reduce(function(highest, count){
return Math.max(highest,count)
}, 0)
b = performance.now()
console.log('Math.max within reduce() took ' + (b - a) + ' ms to run')
a = performance.now()
var biggest5 = findmax(counts)
b = performance.now()
console.log('custom findmax function took ' + (b - a) + ' ms to run')
console.log(biggest + '-' + biggest2 + '-' + biggest3 + '-' + biggest4 + '-' + biggest5)
}
findBiggestNumber(1E5)
jsperf tests
für die oben genannten gemacht
Ich habe festgestellt, dass es sich für größere Arrays (~ 100.000 Elemente) tatsächlich lohnt, das Array einfach mit einer bescheidenen for
Schleife zu iterieren und eine um ~ 30% bessere Leistung zu erzielen als Math.max.apply()
:
function mymax(a)
{
var m = -Infinity, i = 0, n = a.length;
for (; i != n; ++i) {
if (a[i] > m) {
m = a[i];
}
}
return m;
}
Sie können das Array in absteigender Reihenfolge sortieren und das erste Element erhalten:
[267, 306, 108].sort(function(a,b){return b-a;})[0]
sort(function(a,b){return b-a;})
[...].sort().pop()
Wie wäre es damit:
var arr = [1,2,3,4];
var largest = arr.reduce(function(x,y){
return (x > y) ? x : y;
});
console.log(largest);
Wie wäre es mit Array.reduce ?
[0,1,2,3,4].reduce(function(previousValue, currentValue){
return Math.max(previousValue,currentValue);
});
-Infinity
.
Fast alle Antworten verwenden, Math.max.apply()
was nett und gut ist, aber Einschränkungen hat.
Funktionsargumente werden auf einen Stapel gelegt, der einen Nachteil hat - eine Grenze. Wenn Ihr Array also größer als das Limit ist, schlägt es mit fehlRangeError: Maximum call stack size exceeded.
Um eine Call-Stack-Größe zu finden, habe ich diesen Code verwendet:
var ar = [];
for (var i = 1; i < 100*99999; i++) {
ar.push(1);
try {
var max = Math.max.apply(Math, ar);
} catch(e) {
console.log('Limit reached: '+i+' error is: '+e);
break;
}
}
Es erwies sich unter FireFox auf meinem Computer als das größte - 591519 . Wenn Ihr Array mehr als 591519 Elemente enthält, Math.max.apply()
führt dies zu RangeError .
Die beste Lösung für dieses Problem ist der iterative Weg (Kredit: https://developer.mozilla.org/ ):
max = -Infinity, min = +Infinity;
for (var i = 0; i < numbers.length; i++) {
if (numbers[i] > max)
max = numbers[i];
if (numbers[i] < min)
min = numbers[i];
}
Ich habe über diese Frage in meinem Blog hier geschrieben .
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max
const inputArray = [ 1, 3, 4, 9, 16, 2, 20, 18];
const maxNumber = Math.max(...inputArray);
console.log(maxNumber);
Das einfache und manuelle Finden von Max- und Min-Werten. Dieser Code ist viel schneller als Math.max.apply
; Ich habe bis zu 1000k Zahlen im Array ausprobiert.
function findmax(array)
{
var max = 0;
var a = array.length;
for (counter=0;counter<a;counter++)
{
if (array[counter] > max)
{
max = array[counter];
}
}
return max;
}
function findmin(array)
{
var min = array[0];
var a = array.length;
for (counter=0;counter<a;counter++)
{
if (array[counter] < min)
{
min = array[counter];
}
}
return min;
}
findmax()
gibt das falsche Ergebnis aus, wenn das Array nur negative Zahlen enthält; findmin()
gibt das falsche Ergebnis für ein leeres Array aus.
Um die größte Anzahl in einem Array zu finden, die Sie nur verwenden müssen Math.max(...arrayName);
, funktioniert dies folgendermaßen:
let myArr = [1, 2, 3, 4, 5, 6];
console.log(Math.max(...myArr));
Weitere Informationen finden Sie unter Math.max
:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max
Ja, natürlich gibt es: Math.max.apply(null,[23,45,67,-45])
und das Ergebnis kehrt zurück 67
;
Einfacher Einzeiler
[].sort().pop()
Sie können Array
diese Funktion auch erweitern und zu einem Teil jedes Arrays machen.
Array.prototype.max = function(){return Math.max.apply( Math, this )};
myArray = [1,2,3];
console.log( myArray.max() );
Sie können auch forEach verwenden :
var maximum = Number.MIN_SAFE_INTEGER;
var array = [-3, -2, 217, 9, -8, 46];
array.forEach(function(value){
if(value > maximum) {
maximum = value;
}
});
console.log(maximum); // 217
Verwenden - Array.prototype.reduce()
ist cool!
[267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val)
wobei acc = Akkumulator und val = aktueller Wert ;
var a = [267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val);
console.log(a);
Sie können dies versuchen,
var arr = [267,306,108];
var largestNum = 0;
for(i=0;i<arr.length;i++) {
if(arr[i]>largest){
var largest = arr[i];
}
}
console.log(largest);
Ich habe gerade mit JS angefangen, aber ich denke, diese Methode wäre gut:
var array = [34, 23, 57, 983, 198];<br>
var score = 0;
for(var i = 0; i = array.length; i++) {
if(array[ i ] > score) {
score = array[i];
}
}
array
nur negative Zahlen enthalten sind.
var max = [];
for(var i=0; arr.length>i; i++ ){
var arra = arr[i];
var largest = Math.max.apply(Math, arra);
max.push(largest);
}
return max;
var tmax = Math.max.apply(Math, max)
oder noch besser einen Verschluss einer Schleifenfunktion hinzufügen, z. B. in stackoverflow.com/a/54980012/7438857 . Mit dieser Änderung wird besser auf eine separate Frage geantwortet, wie Sie "die größte Zahl in einem mehrdimensionalen Array finden" oder unter stackoverflow.com/questions/32616910/… . WIP: jsfiddle.net/jamesray/3cLu9for/8 .
Finden Sie den Max- und Min-Wert mit Bubble Sort
var arr = [267, 306, 108];
for(i=0, k=0; i<arr.length; i++) {
for(j=0; j<i; j++) {
if(arr[i]>arr[j]) {
k = arr[i];
arr[i] = arr[j];
arr[j] = k;
}
}
}
console.log('largest Number: '+ arr[0]);
console.log('Smallest Number: '+ arr[arr.length-1]);
Gemäß dem Kommentar von @ Quasimondo , der anscheinend weitgehend übersehen wurde, scheint das Folgende die beste Leistung zu haben, wie hier gezeigt: https://jsperf.com/finding-maximum-element-in-an-array . Beachten Sie, dass die Leistung für das betreffende Array möglicherweise keinen signifikanten Effekt hat, bei großen Arrays jedoch die Leistung an Bedeutung gewinnt. Wie bereits erwähnt , Math.max()
funktioniert die Verwendung nicht einmal, wenn die Array-Länge mehr als 65535 beträgt. Siehe auch diese Antwort .
function largestNum(arr) {
var d = data;
var m = d[d.length - 1];
for (var i = d.length - 1; --i > -1;) {
if (d[i] > m) m = d[i];
}
return m;
}
Ein rekursiver Ansatz zur Verwendung ternärer Operatoren
const findMax = (arr, max, i) => arr.length === i ? max :
findMax(arr, arr[i] > max ? arr[i] : max, ++i)
const arr = [5, 34, 2, 1, 6, 7, 9, 3];
const max = findMax(arr, arr[0], 0)
console.log(max);
One- for/of
Loop-Lösung:
const numbers = [2, 4, 6, 8, 80, 56, 10];
const findMax = (...numbers) => {
let currentMax = numbers[0]; // 2
for (const number of numbers) {
if (number > currentMax) {
console.log(number, currentMax);
currentMax = number;
}
}
console.log('Largest ', currentMax);
return currentMax;
};
findMax(...numbers);
Math.max(...[267, 306, 108]);