javascript - reorder - Cómo ordenar una matriz de enteros correctamente

reorder array javascript

Question

Tratar de obtener el valor más alto y más bajo de una matriz que sé que contendrá solo enteros parece ser más difícil de lo que pensé.

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)

Espero que esto muestre 99, 104, 140000 . En su lugar, muestra 104, 140000, 99 . Así que parece que el ordenamiento es manejar los valores como cadenas.

¿Hay alguna manera de hacer que la función de ordenación se ordene realmente en valores enteros?

Answer 1

¡Actualizar! ¡Desplácese hasta el final de la respuesta para el smartSort para accesorios smartSort que le da aún más diversión!
Clasifica matrices de cualquier cosa !

Mi forma favorita personal de esta función permite un parámetro para Ascendente o Descendente:

function intArraySort(c, a) {
    function d(a, b) { return b - a; }
    "string" == typeof a && a.toLowerCase();
    switch (a) {
        default: return c.sort(function(a, b) { return a - b; });
        case 1:
                case "d":
                case "dc":
                case "desc":
                return c.sort(d)
    }
};

Uso tan simple como:

var ara = function getArray() {
        var a = Math.floor(Math.random()*50)+1, b = [];
        for (i=0;i<=a;i++) b.push(Math.floor(Math.random()*50)+1);
        return b;
    }();

//    Ascending
intArraySort(ara);
console.log(ara);

//    Descending
intArraySort(ara, 1);
console.log(ara);

//    Ascending
intArraySort(ara, ''a'');
console.log(ara);

//    Descending
intArraySort(ara, ''dc'');
console.log(ara);

//    Ascending
intArraySort(ara, ''asc'');
console.log(ara);

jsFiddle

O ejemplo de fragmento de código aquí!

function intArraySort(c, a) {
 function d(a, b) { return b - a }
 "string" == typeof a && a.toLowerCase();
 switch (a) {
  default: return c.sort(function(a, b) { return a - b });
  case 1:
  case "d":
  case "dc":
  case "desc":
  return c.sort(d)
 }
};

function tableExample() {
 var d = function() {
   var a = Math.floor(50 * Math.random()) + 1,
    b = [];
   for (i = 0; i <= a; i++) b.push(Math.floor(50 * Math.random()) + 1);
   return b
  },
  a = function(a) {
   var b = $("<tr/>"),
    c = $("<th/>").prependTo(b);
   $("<td/>", {
    text: intArraySort(d(), a).join(", ")
   }).appendTo(b);
   switch (a) {
    case 1:
    case "d":
    case "dc":
    case "desc":
     c.addClass("desc").text("Descending");
     break;
    default:
     c.addClass("asc").text("Ascending")
   }
   return b
  };
 return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1))
};

tableExample();

table { border-collapse: collapse; }
th, td { border: 1px solid; padding: .25em .5em; vertical-align: top; }
.asc { color: red; }
.desc { color: blue }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table><tbody></tbody></table>

.smartSort (''asc'' | ''desc'')

¡Ahora diviértase aún más con un método de clasificación que ordena una matriz llena de elementos múltiples! Actualmente no cubre "asociativo" (también conocido como teclas de cadena), ¡pero sí cubre todo tipo de valor! No solo ordenará los múltiples valores asc o desc consecuencia, sino que también mantendrá la "posición" constante de "grupos" de valores. En otras palabras; Los ints siempre son primero, luego vienen las cadenas, luego las matrices (sí, ¡estoy haciendo esto multidimensional!), luego los objetos (sin filtrar, elemento, fecha) y, finalmente, ¡indefinidos y nulos!

"¿Por qué?" usted pregunta. ¡Por qué no!

¡Ahora viene en 2 sabores! El primero de los cuales requiere navegadores más nuevos, ya que utiliza Object.defineProperty para agregar el método al objeto Array.protoype . Esto permite una facilidad de uso natural , como: myArray.smartSort(''a'') . Si necesita implementar para navegadores más antiguos, o simplemente no le gusta modificar los objetos nativos, desplácese hacia abajo a la versión Solo Método .

/* begin */
/* KEY NOTE! Requires EcmaScript 5.1 (not compatible with older browsers) */
;;(function(){if(Object.defineProperty&&!Array.prototype.smartSort){var h=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a>b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("a");b instanceof Array&&b.smartSort("a");if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("a"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("a"),a.id==e[0]?1:-1;e=[a.tagName, b.tagName].smartSort("a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("a"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d"); return a[d].tagName==c[0]?1:-1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]>g[1]},k=function(a,b){if(null== a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("d");b instanceof Array&&b.smartSort("d");if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("d"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("d"),a.id==e[0]?-1:1;e=[a.tagName,b.tagName].smartSort("d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("d"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1;if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]};Object.defineProperty(Array.prototype,"smartSort",{value:function(){return arguments&& (!arguments.length||1==arguments.length&&/^a([sc]{2})?$|^d([esc]{3})?$/i.test(arguments[0]))?this.sort(!arguments.length||/^a([sc]{2})?$/i.test(arguments[0])?h:k):this.sort()}})}})();
/* end */

jsFiddle Array.prototype.smartSort (''asc | desc'')

¡El uso es simple! Primero haz una serie de locos como:

window.z = [ ''one'', undefined, $(''<span />''), ''two'', null, 2, $(''<div />'', { id: ''Thing'' }), $(''<div />''), 4, $(''<header />'') ];
z.push(new Date(''1/01/2011''));
z.push(''three'');
z.push(undefined);
z.push([ ''one'', ''three'', ''four'' ]);
z.push([ ''one'', ''three'', ''five'' ]);
z.push({ a: ''a'', b: ''b'' });
z.push({ name: ''bob'', value: ''bill'' });
z.push(new Date());
z.push({ john: ''jill'', jack: ''june'' });
z.push([ ''abc'', ''def'', [ ''abc'', ''def'', ''cba'' ], [ ''cba'', ''def'', ''bca'' ], ''cba'' ]);
z.push([ ''cba'', ''def'', ''bca'' ]);
z.push({ a: ''a'', b: ''b'', c: ''c'' });
z.push({ a: ''a'', b: ''b'', c: ''d'' });

Entonces simplemente ordénalo!

z.smartSort(''asc''); // Ascending
z.smartSort(''desc''); // Descending

Solo método

Igual que el anterior, excepto como un simple método!

/* begin */
/* KEY NOTE! Method `smartSort` is appended to native `window` for global use. If you''d prefer a more local scope, simple change `window.smartSort` to `var smartSort` and place inside your class/method */
window.smartSort=function(){if(arguments){var a,b,c;for(c in arguments)arguments[c]instanceof Array&&(a=arguments[c],void 0==b&&(b="a")),"string"==typeof arguments[c]&&(b=/^a([sc]{2})?$/i.test(arguments[c])?"a":"d");if(a instanceof Array)return a.sort("a"==b?smartSort.asc:smartSort.desc)}return this.sort()};smartSort.asc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a> b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.asc);b instanceof Array&&b.sort(smartSort.asc);if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c], b[c]],"a"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"a"),a.id==e[0]?1:-1;e=smartSort([a.tagName,b.tagName],"a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g), "a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"a"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"a");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1; if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==c[0]?1:-1}g=[a,b].sort();return g[0]>g[1]};smartSort.desc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)? 1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.desc);b instanceof Array&&b.sort(smartSort.desc);if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c],b[c]],"d"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]], b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"d"),a.id==e[0]?-1:1;e=smartSort([a.tagName,b.tagName],"d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g),"a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&& b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"d"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1; if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]}
/* end */

Utilizar:

z = smartSort(z, ''asc''); // Ascending
z = smartSort(z, ''desc''); // Descending

Método jsFiddle smartSort (Array, "asc | desc")

Answer 2

La razón por la cual la función de ordenación se comporta tan rara

De la documentation :

[...] la matriz se clasifica de acuerdo con el valor del punto de código Unicode de cada carácter, de acuerdo con la conversión de cadena de cada elemento.

Si imprime los documentation de documentation de la matriz, entonces se aclarará.

console.log("140000".charCodeAt(0));
console.log("104".charCodeAt(0));
console.log("99".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

Esto devuelve: "49, 49, 57".

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

Ahora, debido a que 140000 y 104 devolvieron los mismos valores (49), corta el primer índice y vuelve a verificar:

console.log("40000".charCodeAt(0));
console.log("04".charCodeAt(0));

//Note that we only look at the first index of the number "charCodeAt(  0  )"

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

Si ordenamos esto, entonces obtendremos:

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

entonces 104 viene antes de 140000.

Entonces el resultado final será:

var numArray = [140000, 104, 99];
numArray = numArray.sort();
console.log(numArray)

104, 140000, 99

Conclusión:

sort() hace la clasificación solo mirando el primer índice de los números. sort() no le importa si un número entero es más grande que otro, compara el valor del Unicode de los dígitos, y si hay dos valores de Unicode iguales, entonces verifica si hay un próximo dígito y lo compara también.

Para ordenar correctamente, debe pasar una función de comparación para sort() como se explica here .

Answer 3

Aquí está mi función de ordenamiento en la biblioteca de utils:

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let''s test a string array
var arr = [''bbc'', ''chrome'', ''aux'', ''ext'', ''dog''];
utils.sortArray(arr);
console.log(arr);
>>> ["aux", "bbc", "chrome", "dog", "ext", remove: function]

# Let''s test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]

Answer 4

Array.prototype.sort () es el método de ir a clasificar matrices, pero hay algunos problemas que debemos tener en cuenta.

El orden de clasificación es por defecto lexicográfico y no numérico independientemente de los tipos de valores en la matriz. Incluso si la matriz es todos los números, todos los valores se convertirán en cadenas y se ordenarán lexicográficamente.

Entonces, ¿deberíamos personalizar el método sort () y reverse () como se muestra a continuación?

URL referida

Para ordenar números dentro de la matriz

numArray.sort(function(a, b)
{
    return a - b;
});

Para invertir números dentro de la matriz.

numArray.sort(function(a, b)
{
    return b - a;
});

URL referida

Answer 5

Basándose en todas las respuestas anteriores, también se pueden hacer en una línea como esta:

var numArray = [140000, 104, 99];

// ES5
numArray = numArray.sort(function (a, b) {  return a - b;  });

// ES2015
numArray = numArray.sort((a, b) => a - b);

//outputs: 99, 104, 140000

Answer 6

En JavaScript, el comportamiento predeterminado del método sort () es ordenar los valores en una matriz alfabéticamente.

Para ordenar por número, debe definir una función de clasificación numérica (que es muy fácil):

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);

Answer 7

Esta respuesta es equivalente a algunas de las respuestas existentes, pero las funciones de flecha ECMAScript 6 proporcionan una sintaxis mucho más compacta que nos permite definir una función de ordenación en línea sin sacrificar la legibilidad:

numArray = numArray.sort((a, b) => a - b);

Es compatible con la mayoría de los navegadores de hoy .

Answer 8

Estoy de acuerdo con aks, sin embargo en lugar de usar

return a - b;

Deberías usar

return a > b ? 1 : a < b ? -1 : 0;

Answer 9

Intente este código como abajo

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));

Answer 10

La pregunta ya ha sido respondida, la forma más corta es usar el método sort() . Pero si está buscando más formas de ordenar su variedad de números y también le gustan los ciclos, verifique lo siguiente

Tipo de inserción

Ascendente

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

Descendente

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length; i++) {
    var target = numArray[i];
    for (var j = i - 1; j >= 0 && (numArray[j] < target); j--) {
        numArray[j+1] = numArray[j];
    }
    numArray[j+1] = target
}
console.log(numArray);

Tipo de selección:

Ascendente

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] < numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

Descendente

var numArray = [140000, 104, 99];
for (var i = 0; i < numArray.length - 1; i++) {
    var min = i;
    for (var j = i + 1; j < numArray.length; j++) {
        if (numArray[j] > numArray[min]) {
            min = j;
        }
    }
    if (min != i) {
        var target = numArray[i];
        numArray[i] = numArray[min];
        numArray[min] = target;
    }
}
console.log(numArray);

Que te diviertas

Answer 11

Para una matriz normal de valores de elementos solamente:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
**output : [1, 2, 2, 24, 64, 545, 676]**

var array2 = ["v","a",545,676,64,2,"24"]
**output: ["a", "v", 2, "24", 64, 545, 676]**

Para una matriz de objetos:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

**output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]**

Answer 12

Por defecto, el método de clasificación ordena los elementos alfabéticamente. Para ordenar numéricamente solo agregue un nuevo método que maneje las ordenaciones numéricas (sortNumber, mostrado abajo) -

function sortNumber(a,b) {
    return a - b;
}

var numArray = [140000, 104, 99];
numArray.sort(sortNumber);
alert(numArray.join(","));

EDITAR: utilizando las funciones de flecha ES6:

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

Answer 13

Prueba este código:

HTML:

<div id="demo"></div>

Código de JavaScript:

<script>
    (function(){
        var points = [40, 100, 1, 5, 25, 10];
        document.getElementById("demo").innerHTML = points;
        points.sort(function(a, b){return a-b});
        document.getElementById("demo").innerHTML = points;
    })();
</script>

Answer 14

para manejar undefined, null, y NaN: Null se comporta como 0, NaN y undefined van a su fin.

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]

Answer 15

array.sort realiza una ordenación lexicográfica por defecto, para una ordenación numérica, proporciona su propia función. Aquí hay un ejemplo simple:

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

También tenga en cuenta que la clasificación funciona "en el lugar", no hay necesidad de la asignación.