number - numero maximo y minimo javascript

Encuentra el elemento min/max de un Array en JavaScript

Question

¿Cómo puedo obtener fácilmente el elemento mínimo o máximo de una matriz de JavaScript?

Ejemplo de Psuedocode:

let array = [100, 0, 50]

array.min() //=> 0
array.max() //=> 100

Answer 1

tl; dr

var max = Math.max(...arrayOfNumbers);

Documentación oficial de Math.max() MDN

La siguiente función usa Function.prototype.apply() para encontrar el elemento máximo en una matriz numérica. getMaxOfArray([1, 2, 3]) es equivalente a Math.max(1, 2, 3) , pero puede usar getMaxOfArray() en arreglos construidos programáticamente de cualquier tamaño.

function getMaxOfArray(numArray) {
    return Math.max.apply(null, numArray);
}

O con el nuevo operador de difusión , obtener el máximo de una matriz se vuelve mucho más fácil.

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

Answer 2

¿Qué tal aumentar el objeto Array incorporado para usar Math.max / Math.min en Math.min lugar?

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

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

Aquí hay un JSFiddle .

El aumento de las funciones integradas puede provocar colisiones con otras bibliotecas (algunos lo ven), por lo que puede sentirse más cómodo simplemente apply '' Math.xxx() a su matriz directamente:

var min = Math.min.apply(null, arr),
    max = Math.max.apply(null, arr);

Alternativamente, suponiendo que su navegador sea compatible con ECMAScript 6, puede usar el operador de propagación que funciona de manera similar al método de apply :

var min = Math.min( ...arr ),
    max = Math.max( ...arr );

Answer 3

Aquí hay una forma de obtener el valor máximo de una matriz de objetos. Cree una copia (con corte), luego ordene la copia en orden descendente y tome el primer elemento.

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

maxsort = myArray.slice(0).sort(function(a, b) { return b.ID - a.ID })[0].ID; 

Answer 4

Cosas simples, de verdad.

var arr = [10,20,30,40];
arr.max = function() { return  Math.max.apply(Math, this); }; //attach max funct
arr.min = function() { return  Math.min.apply(Math, this); }; //attach min funct

alert("min: " + arr.min() + " max: " + arr.max());

Answer 5

Dos formas son más cortas y fáciles:

let arr = [2, 6, 1, 0]

// Way 1:
let max = Math.max.apply(null, arr)

//Way 2:
let max = arr.reduce(function(a, b) {
    return Math.max(a, b);
});

Answer 6

El siguiente código funciona para mí:

var valueList = [10,4,17,9,3];
var maxValue = valueList.reduce(function(a, b) { return Math.max(a, b); });
var minValue = valueList.reduce(function(a, b) { return Math.min(a, b); });

Answer 7

Esto puede adaptarse a sus propósitos.

Array.prototype.min = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.min);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

Array.prototype.max = function(comparer) {

    if (this.length === 0) return null;
    if (this.length === 1) return this[0];

    comparer = (comparer || Math.max);

    var v = this[0];
    for (var i = 1; i < this.length; i++) {
        v = comparer(this[i], v);    
    }

    return v;
}

Answer 8

Iterar a través, siguiendo la pista a medida que avanza.

var min = null;
var max = null;
for (var i = 0, len = arr.length; i < len; ++i)
{
    var elem = arr[i];
    if (min === null || min > elem) min = elem;
    if (max === null || max < elem) max = elem;
}
alert( "min = " + min + ", max = " + max );

Esto dejará min / max null si no hay elementos en la matriz. Establecerá min y max en una pasada si la matriz tiene algún elemento.

También puede extender el Array con un método de range utilizando lo anterior para permitir la reutilización y mejorar la legibilidad. Vea un violín en funcionamiento en http://jsfiddle.net/9C9fU/

Array.prototype.range = function() {

    var min = null,
        max = null,
        i, len;

    for (i = 0, len = this.length; i < len; ++i)
    {
        var elem = this[i];
        if (min === null || min > elem) min = elem;
        if (max === null || max < elem) max = elem;
    }

    return { min: min, max: max }
};

Usado como

var arr = [3, 9, 22, -7, 44, 18, 7, 9, 15];

var range = arr.range();

console.log(range.min);
console.log(range.max);

Answer 9

La solución de ChaosPandion funciona si está utilizando un prototipo. Si no, considera esto:

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

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

Lo anterior devolverá NaN si un valor de matriz no es un número entero, por lo que debe compilar alguna funcionalidad para evitar eso. De lo contrario esto funcionará.

Answer 10

Lo haces extendiendo el tipo Array:

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

Impulsado desde here (por John Resig)

Answer 11

Me gusta el enfoque Reduc () de Linus , especialmente para matrices grandes. Pero mientras sepa que necesita tanto el mínimo como el máximo, ¿por qué iterar sobre el arreglo dos veces?

Array.prototype.minmax = function () {
  return this.reduce(function (p, v) {
    return [(p[0] < v ? p[0] : v), (p[1] > v ? p[1] : v)];
  }, [this[0], this[0]]);
}

Por supuesto, si prefiere el enfoque iterativo, también puede hacerlo:

Array.prototype.minmax = function () {
    var mn = this[0], mx = this[0];
    this.forEach(function (v) {
        if (v < mn) mn = v;
        if (v > mx) mx = v;
    });
    return [mn, mx];
};

Answer 12

Me sorprende que no se mencione la función de reducción.

var arr = [1, 10, 5, 11, 2]

var b = arr.reduce(function(previous,current){ 
                      return previous > current ? previous:current
                   });

b => 11
arr => [1, 10, 5, 11, 2]

Answer 13

Otros ya han dado algunas soluciones en las que aumentan el Array.prototype . Todo lo que quiero en esta respuesta es aclarar si debe ser Math.min.apply( Math, array ) o Math.min.apply( null, array ) . Entonces, ¿qué contexto se debe usar, Math o null ?

Al pasar null como un contexto para apply , entonces el contexto se establecerá de manera predeterminada al objeto global (el objeto de la window en el caso de los navegadores). Pasar el objeto Math como el contexto sería la solución correcta, pero tampoco perjudicará pasar null . Aquí hay un ejemplo cuando null puede causar problemas al decorar la función Math.max :

// decorate Math.max
(function (oldMax) {
    Math.max = function () {
        this.foo(); // call Math.foo, or at least that''s what we want

        return oldMax.apply(this, arguments);
    };
})(Math.max);

Math.foo = function () {
    print("foo");
};

Array.prototype.max = function() {
  return Math.max.apply(null, this); // <-- passing null as the context
};

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

print(max);

Lo anterior generará una excepción porque this.foo se evaluará como window.foo , que undefined está undefined . Si reemplazamos null con Math , las cosas funcionarán como se esperaba y la cadena "foo" se imprimirá en la pantalla (lo probé con Mozilla Rhino ).

Puede suponer que nadie ha decorado Math.max , así que pasar null funcionará sin problemas.

Answer 14

Para matrices grandes (~ 10 elementos), Math.min y Math.max procuran un RangeError (se excedió el tamaño máximo de pila de llamadas) en node.js.

Para matrices grandes, una solución rápida y sucia es:

Array.prototype.min = function() {
    var r = this[0];
    this.forEach(function(v,i,a){if (v<r) r=v;});
    return r;
};

Answer 15

Para matrices grandes (~ 10 elementos), Math.min y Math.max producen el siguiente error en Node.js.

RangeError: se excedió el tamaño máximo de pila de llamadas

Una solución más robusta es no agregar todos los elementos a la pila de llamadas, sino pasar una matriz:

function arrayMin(arr) {
  return arr.reduce(function (p, v) {
    return ( p < v ? p : v );
  });
}

function arrayMax(arr) {
  return arr.reduce(function (p, v) {
    return ( p > v ? p : v );
  });
}

Si le preocupa la velocidad, el siguiente código es ~ 3 veces más rápido que Math.max.apply está en mi computadora. Consulte http://jsperf.com/min-and-max-in-array/2 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (arr[len] < min) {
      min = arr[len];
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (arr[len] > max) {
      max = arr[len];
    }
  }
  return max;
};

Si sus arreglos contienen cadenas en lugar de números, también necesita forzarlos en números. El siguiente código lo hace, pero ralentiza el código hacia abajo ~ 10 veces en mi máquina. Consulte http://jsperf.com/min-and-max-in-array/3 .

function arrayMin(arr) {
  var len = arr.length, min = Infinity;
  while (len--) {
    if (Number(arr[len]) < min) {
      min = Number(arr[len]);
    }
  }
  return min;
};

function arrayMax(arr) {
  var len = arr.length, max = -Infinity;
  while (len--) {
    if (Number(arr[len]) > max) {
      max = Number(arr[len]);
    }
  }
  return max;
};

Answer 16

Pensé que compartiría mi solución simple y fácil de entender.

Para el min:

var arr = [3, 4, 12, 1, 0, 5];
var min = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] < min) {
    min = arr[k];
  }
}
console.log("Min is: " + min);

Y para el máximo:

var arr = [3, 4, 12, 1, 0, 5];
var max = arr[0];
for (var k = 1; k < arr.length; k++) {
  if (arr[k] > max) {
    max = arr[k];
  }
}
console.log("Max is: " + max);

Answer 17

Puedes usar la siguiente función en cualquier parte de tu proyecto:

function getMin(array){
    return Math.min.apply(Math,array);
}

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

Y luego puedes llamar a las funciones que pasan la matriz:

var myArray = [1,2,3,4,5,6,7];
var maximo = getMax(myArray); //return the highest number

Answer 18

Si eres un paranoico como yo sobre el uso de Math.max.apply (que podría causar errores cuando se dan matrices grandes de acuerdo con MDN ), prueba esto:

function arrayMax(array) {
  return array.reduce(function(a, b) {
    return Math.max(a, b);
  });
}

function arrayMin(array) {
  return array.reduce(function(a, b) {
    return Math.min(a, b);
  });
}

O, en ES6:

function arrayMax(array) {
  return array.reduce((a, b) => Math.max(a, b));
}

function arrayMin(array) {
  return array.reduce((a, b) => Math.min(a, b));
}

Las funciones anónimas son desafortunadamente necesarias (en lugar de usar Math.max.bind(Math) porque reduce no solo pasa a y b a su función, sino también a i y una referencia a la propia matriz, por lo que debemos asegurarnos de que no No intente llamar al max en esos también.

Answer 19

Si está utilizando el marco prototype.js , entonces este código funcionará bien:

arr.min();
arr.max();

Documentado aquí: Javascript prototype framework para max

Answer 20

Si usa la biblioteca sugar.js , puede escribir arr.min() y arr.max() como usted sugiera. También puede obtener valores mínimos y máximos de matrices no numéricas.

min (map, all = false) Devuelve el elemento en la matriz con el valor más bajo. el mapa puede ser una función que asigna el valor a verificar o una cadena que actúa como acceso directo. Si todo es verdadero, devolverá todos los valores mínimos en una matriz.

max (map, all = false) Devuelve el elemento en la matriz con el mayor valor. el mapa puede ser una función que asigna el valor a verificar o una cadena que actúa como acceso directo. Si todo es verdadero, devolverá todos los valores máximos en una matriz.

Ejemplos:

[1,2,3].min() == 1
[''fee'',''fo'',''fum''].min(''length'') == "fo"
[''fee'',''fo'',''fum''].min(''length'', true) == ["fo"]
[''fee'',''fo'',''fum''].min(function(n) { return n.length; }); == "fo"
[{a:3,a:2}].min(function(n) { return n[''a'']; }) == {"a":2}
[''fee'',''fo'',''fum''].max(''length'', true) == ["fee","fum"]

Las bibliotecas como Lo-Dash y underscore.js también proporcionan funciones mínimas y máximas similares:

Ejemplo de Lo-Dash:

_.max([4, 2, 8, 6]) == 8
var characters = [
  { ''name'': ''barney'', ''age'': 36 },
  { ''name'': ''fred'',   ''age'': 40 }
];
_.max(characters, function(chr) { return chr.age; }) == { ''name'': ''fred'', ''age'': 40 }

Answer 21

Tuve el mismo problema, necesitaba obtener los valores mínimo y máximo de una matriz y, para mi sorpresa, no había funciones integradas para las matrices. Después de leer mucho, decidí probar las soluciones "top 3" por mi cuenta:

1. solución discreta: un bucle FOR para verificar cada elemento de la matriz con el valor máximo y / o mínimo actual;
2. APLICAR solución: enviar la matriz a las funciones internas Math.max y / o Math.min usando apply (null, array);
3. Solución REDUCE: se realiza una comprobación recurrente de cada elemento de la matriz mediante la función reduce (función).

El código de prueba fue este:

function GetMaxDISCRETE(A)
{   var MaxX=A[0];

    for (var X=0;X<A.length;X++)
        if (MaxX<A[X])
            MaxX=A[X];

    return MaxX;
}

function GetMaxAPPLY(A)
{   return Math.max.apply(null,A);
}

function GetMaxREDUCE(A)
{   return A.reduce(function(p,c)
    {   return p>c?p:c;
    });
}

La matriz A se llenó con 100,000 números enteros aleatorios, cada función se ejecutó 10,000 veces en Mozilla Firefox 28.0 en una computadora Intel Pentium 4 2.99GHz con Windows Vista. Los tiempos están en segundos, recuperados por la función performance.now (). Los resultados fueron estos, con 3 dígitos fraccionarios y desviación estándar:

1. Solución discreta: media = 0.161s, sd = 0.078
2. APLICAR solución: media = 3.571s, sd = 0.487
3. Solución REDUCE: media = 0,350s, sd = 0,044

La solución REDUCE fue un 117% más lenta que la solución discreta. La solución APPLY fue la peor, 2,118% más lenta que la solución discreta. Además, como observó Peter, no funciona para arreglos grandes (alrededor de más de 1,000,000 de elementos).

Además, para completar las pruebas, probé este extenso código discreto:

var MaxX=A[0],MinX=A[0];

for (var X=0;X<A.length;X++)
{   if (MaxX<A[X])
        MaxX=A[X];
    if (MinX>A[X])
        MinX=A[X];
}

El tiempo: media = 0.218s, sd = 0.094

Entonces, es un 35% más lento que la solución discreta simple, pero recupera los valores máximos y mínimos a la vez (cualquier otra solución tomaría al menos el doble para recuperarlos). Una vez que el OP necesitara ambos valores, la solución discreta sería la mejor opción (incluso como dos funciones separadas, una para calcular el máximo y otra para calcular el mínimo, superarían a la segunda mejor opción, la solución REDUCE).

Answer 22

Una forma más de hacerlo:

var arrayMax = Function.prototype.apply.bind(Math.max, null);

Uso:

var max = arrayMax([2, 5, 1]);

Answer 23

Una solución simple para encontrar el valor mínimo sobre una Array de elementos es utilizar la función de prototipo de Array reduce :

A = [4,3,-9,-2,2,1];
A.reduce((min, val) => val < min ? val : min, A[0]); // returns -9

o usando la función Math.Min () incorporada de JavaScript (gracias @Tenflex):

A.reduce((min,val) => Math.min(min,val), A[0]);

Esto establece min a A[0] , y luego verifica si A[1]...A[n] si es estrictamente menor que el min actual. Si A[i] < min entonces min se actualiza a A[i] devolviendo este valor.

Answer 24

Usando Math.max() o Math.min()

Math.max(10, 20);   //  20
Math.min(-10, -20); // -20

La siguiente función usa Function.prototype.apply() para encontrar el elemento máximo en una matriz numérica. getMaxOfArray([1, 2, 3]) es equivalente a Math.max(1, 2, 3) , pero puede usar getMaxOfArray() en arreglos construidos programáticamente de cualquier tamaño.

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

O con el nuevo operador de difusión, obtener el máximo de una matriz se vuelve mucho más fácil.

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

Answer 25

Usando operador de propagación (ES6)

Math.max(...array);  // the same with "min" => Math.min(...array);

const array = [10, 2, 33, 4, 5];

console.log(
  Math.max(...array)
)

Answer 26

crear un objeto simple

var myArray = new Array();

myArray = [10,12,14,100];

var getMaxHeight = {
     hight : function( array ){ return Math.max.apply( Math, array );
}

getMaxHeight.hight(myArray);

Answer 27

https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Math/max

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

var arr = [100, 0, 50];
console.log(getMaxOfArray(arr))

esto funcionó para mí.

Answer 28

.apply se usa a menudo cuando la intención es invocar una función variadic con una lista de valores de argumento, por ejemplo,

La función Function.prototype.apply() devuelve el mayor de cero o más números.

Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20

El método Math.max() no le permite pasar en una matriz. Si tiene una lista de valores de los que necesita obtener el mayor, normalmente llamaría a esta función usando Function.prototype.apply() , por ejemplo

Math.max.apply(null, [10, 20]); // 20
Math.max.apply(null, [-10, -20]); // -10
Math.max.apply(null, [-10, 20]); // 20

Sin embargo, a partir del ECMAScript 6 puede utilizar el operador de propagación :

El operador de difusión permite que una expresión se expanda en lugares donde se esperan múltiples argumentos (para llamadas a funciones) o múltiples elementos (para literales de matriz).

Usando el operador de propagación, lo anterior se puede reescribir como tal:

Math.max(...[10, 20]); // 20
Math.max(...[-10, -20]); // -10
Math.max(...[-10, 20]); // 20

Al llamar a una función utilizando el operador variadic, incluso puede agregar valores adicionales, por ejemplo,

Math.max(...[10, 20], 50); // 50
Math.max(...[-10, -20], 50); // 50

Prima:

El operador de difusión le permite utilizar la sintaxis literal de la matriz para crear nuevas matrices en situaciones en las que en ES5 tendría que recurrir al código imperativo, utilizando una combinación de push , splice , etc.

let foo = [''b'', ''c''];
let bar = [''a'', ...foo, ''d'', ''e'']; // [''a'', ''b'', ''c'', ''d'', ''e'']

Answer 29

minHeight = Math.min.apply({},YourArray);
minKey    = getCertainKey(YourArray,minHeight);
maxHeight = Math.max.apply({},YourArray);
maxKey    = getCertainKey(YourArray,minHeight);
function getCertainKey(array,certainValue){
   for(var key in array){
      if (array[key]==certainValue)
         return key;
   }
} 

Answer 30

var max_of_array = Math.max.apply(Math, array);

Para una discusión completa vea: http://aaroncrane.co.uk/2008/11/javascript_max_api/