¿Cómo puedo encontrar el número más grande contenido en una matriz de JavaScript?

Tengo un simple objeto de matriz de JavaScript que contiene algunos números.

[267, 306, 108]

¿Hay una función que encuentre el número más grande en esta matriz?

Resig al rescate:

Array.max = function( array ){
    return Math.max.apply( Math, array );
};

Advertencia : dado que el número máximo de argumentos es tan bajo como 65535 en algunas máquinas virtuales , use un bucle for si no está seguro de que la matriz sea tan pequeña.

Puede usar la función de aplicación para llamar a Math.max :

var array = [267, 306, 108];
var largest = Math.max.apply(Math, array); // 306

¿Cómo funciona?

El aplicar función de se usa para llamar a otra función, con un contexto y argumentos dados, proporcionados como una matriz. Las funciones min y max pueden tomar una cantidad arbitraria de argumentos de entrada: Math.max (val1, val2, ..., valN)

Entonces si llamamos:

Math.min.apply(Math, [1,2,3,4]);

La función de aplicación ejecutará:

Math.min(1,2,3,4);

Tenga en cuenta que el primer parámetro, el contexto, no es importante para estas funciones, ya que son estáticas, funcionarán independientemente de lo que se pase como contexto.

La sintaxis más fácil, con el nuevo operador de propagación :

var arr = [1, 2, 3];
var max = Math.max(...arr);

Fuente: Mozilla MDN

No soy un experto en JS, pero quería ver cómo se comparan estos métodos, así que esta fue una buena práctica para mí. No sé si esta es técnicamente la forma correcta de probar estos, pero simplemente los ejecuté uno tras otro, como puede ver en mi código.

Ordenar y obtener el valor 0 es, con mucho, el peor método (y modifica el orden de su matriz, lo que puede no ser deseable). Para los demás, la diferencia es insignificante a menos que esté hablando de millones de índices.

Resultados promedio de cinco ejecuciones con una matriz de números aleatorios de 100,000 índices:

• reducir tomó 4.0392 ms para ejecutarse
• Math.max.apply tardó 3.3742 ms en ejecutarse
• ordenar y obtener el valor 0 tardó 67.4724 ms en ejecutarse
• Math.max dentro de reduce () tardó 6.5804ms en ejecutarse
• La función findmax personalizada tardó 1.6102ms en ejecutarse

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)

Descubrí que para matrices más grandes (~ 100k elementos), en realidad vale la pena simplemente iterar la matriz con un forbucle humilde , con un rendimiento ~ 30% mejor que 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;
}

Resultados de referencia

Puede ordenar la matriz en orden descendente y obtener el primer elemento:

[267, 306, 108].sort(function(a,b){return b-a;})[0]

Qué tal esto:

var arr = [1,2,3,4];

var largest = arr.reduce(function(x,y){
       return (x > y) ? x : y;
});

console.log(largest);

¿ Qué tal usar Array.reduce ?

[0,1,2,3,4].reduce(function(previousValue, currentValue){
  return Math.max(previousValue,currentValue);
});

Casi todas las respuestas usan lo Math.max.apply()que es agradable y elegante pero tiene limitaciones.

Los argumentos de la función se colocan en la pila que tiene una desventaja: un límite. Entonces, si su matriz es más grande que el límite, fallará conRangeError: Maximum call stack size exceeded.

Para encontrar un tamaño de pila de llamadas, utilicé este código:

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

Resultó ser el más grande en FireFox en mi máquina: 591519 . Esto significa que si su matriz contiene más de 591519 elementos, Math.max.apply()dará como resultado RangeError .

La mejor solución para este problema es la forma iterativa (crédito: 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];
}

He escrito sobre esta pregunta en mi blog aquí .

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

Encontrar el valor máximo y mínimo de manera fácil y manual. Este código es mucho más rápido que Math.max.apply; He intentado hasta 1000k números en matriz.

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

Para encontrar el número más grande en una matriz que solo necesita usar Math.max(...arrayName);, funciona así:

let myArr = [1, 2, 3, 4, 5, 6];
console.log(Math.max(...myArr));

Para obtener más información sobre Math.max: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

Sí, por supuesto, existe: Math.max.apply(null,[23,45,67,-45]) y el resultado vuelve 67;

Un trazador de líneas simple

[].sort().pop()

No hay que olvidar que la envoltura se puede hacer con Function.prototype.bind, que le da un "todo-nativa" función .

var aMax = Math.max.apply.bind(Math.max, Math);
aMax([1, 2, 3, 4, 5]); // 5

También puede extender Arraypara tener esta función y hacerla parte de cada matriz.

Array.prototype.max = function(){return Math.max.apply( Math, this )};
myArray = [1,2,3];

console.log( myArray.max() );

También puedes usar forEach :

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

¡Usar Array.prototype.reduce()es genial!

[267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val)

donde acc = acumulador y val = valor actual ;

var a = [267, 306, 108].reduce((acc,val)=> (acc>val)?acc:val);

console.log(a);

Puedes probar esto,

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

Acabo de comenzar con JS pero creo que este método sería bueno:

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

Encuentra el número más grande en una matriz multidimensional

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;

Ejecuta esto:

Array.prototype.max = function(){
    return Math.max.apply( Math, this );
};

Y ahora intenta [3,10,2].max()devoluciones10

Encuentre el valor máximo y mínimo con el método de burbuja

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

Prueba esto

function largestNum(arr) {
  var currentLongest = arr[0]

  for (var i=0; i< arr.length; i++){
    if (arr[i] > currentLongest){
      currentLongest = arr[i]
    }
  }

  return currentLongest
}

Según el comentario de @ Quasimondo , que parece haberse perdido en gran medida, el siguiente parece tener el mejor rendimiento como se muestra aquí: https://jsperf.com/finding-maximum-element-in-an-array . Tenga en cuenta que, aunque para el conjunto de la pregunta, el rendimiento puede no tener un efecto significativo, para el rendimiento de conjuntos grandes se vuelve más importante, y nuevamente, como se señaló, el uso Math.max()ni siquiera funciona si la longitud del conjunto es superior a 65535. Consulte también esta respuesta .

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

Un enfoque recursivo sobre cómo hacerlo utilizando operadores ternarios

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

for/ofSolución de un bucle:

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