web-dev-qa-db-fra.com

Comment trier correctement un tableau d'entiers

Essayer d'obtenir la valeur la plus haute et la plus basse d'un tableau dont je sais qu'il ne contiendra que des entiers semble être plus difficile que je ne le pensais.

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

Je m'attendrais à ce que cela montre 99, 104, 140000. Au lieu de cela, il affiche 104, 140000, 99. Il semble donc que le genre traite les valeurs sous forme de chaînes.

Existe-t-il un moyen d'obtenir que la fonction de tri effectue un tri sur une valeur entière?

javascriptarrayssortingnumbers
731
peirix

Par défaut, la méthode de tri trie les éléments par ordre alphabétique. Pour trier numériquement, ajoutez une nouvelle méthode qui gère les tris numériques (sortNumber, montré ci-dessous) -

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

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

console.log(numArray);

Dans ES6, vous pouvez simplifier cela avec les fonctions de flèche:

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

En partant de toutes les réponses ci-dessus, elles peuvent également être réalisées en une seule ligne, comme ceci:

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
165
MarzSocks

array.sort effectue un tri lexicographique par défaut. Pour un tri numérique, fournissez votre propre fonction. Voici un exemple simple:

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

numArray.sort(compareNumbers);

Notez également que le tri fonctionne "en place", il n'y a pas besoin de cession.

70
Paul Dixon

Cette réponse est équivalente à certaines des réponses existantes, mais ECMAScript 6 fonctions de flèche fournit une syntaxe beaucoup plus compacte nous permettant de définir une fonction de tri en ligne sans sacrifier la lisibilité:

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

Il est supporté dans la plupart des navigateurs actuels .

38
jjjjs

Je suis surpris que tout le monde recommande de passer une fonction de comparaison à sort(), ce qui ralentit le tri!

Pour trier les nombres, créez simplement tout type TypedArray :

var numArray = new Uint32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)
21
dy_

La raison pour laquelle la fonction de tri se comporte tellement bizarre

De la documentation :

[...] le tableau est trié en fonction de la valeur du point de code Unicode de chaque caractère, en fonction de la conversion de chaîne de chaque élément.

Si vous imprimez le valeurs de points Unicode du tableau, il sera clair.

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

Cela retourne: "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)

Maintenant, comme 140000 et 104 ont renvoyé les mêmes valeurs (49), le premier index est coupé et une nouvelle vérification est effectuée:

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 nous trions cela, alors nous aurons:

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

alors 104 vient avant 140000.

Le résultat final sera donc:

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

104, 140000, 99

Conclusion:

sort() effectue le tri en ne regardant que le premier index des nombres. sort() ne se soucie pas de savoir si un nombre entier est supérieur à un autre, il compare la valeur de l'unicode des chiffres, et s'il y a deux valeurs égales de Unicode, il vérifie s'il y a un prochain chiffre et le compare comme suit: bien.

Pour trier correctement, vous devez passer une fonction de comparaison à sort() comme expliqué ici .

17
Black

Je suis d'accord avec aks, cependant au lieu d'utiliser

return a - b;

Tu devrais utiliser

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

En JavaScript, le comportement par défaut de la méthode sort () consiste à trier les valeurs d'un tableau par ordre alphabétique.

Pour trier par numéro, vous devez définir une fonction de tri numérique (ce qui est très facile):

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

numArray = numArray.sort(sortNumber);
10
user130076

Dans le nouveau monde ES6, il est beaucoup plus facile de faire une sorte

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

C'est tout ce dont vous avez besoin :)

9
Chait

Array.prototype.sort () est la méthode de tri des tableaux, mais il y a quelques problèmes à prendre en compte.

L'ordre de tri est par défaut lexicographique et non numérique, quels que soient les types de valeurs du tableau. Même si le tableau contient tous des nombres, toutes les valeurs seront converties en chaîne et triées lexicographiquement.

Nous devrions donc avoir besoin de personnaliser les méthodes sort () et reverse () comme ci-dessous.

RL référée

Pour trier les nombres à l'intérieur du tableau 

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

Pour inverser des nombres à l'intérieur du tableau 

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

RL référée

8
Merbin Joe

La question a déjà été répondue, le moyen le plus court consiste à utiliser la méthode sort(). Mais si vous cherchez plus de façons de trier votre tableau de nombres et que vous aimez aussi les cycles, vérifiez les points suivants:

tri par insertion

Ascendant: 

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

Décroissant: 

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

type de sélection:

Ascendant: 

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

Décroissant: 

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

S'amuser

5
Commercial Suicide

La fonction "numériquement" ci-dessous sert à trier un tableau de nombres numériquement dans de nombreux cas lorsqu'elle est fournie comme fonction de rappel:

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

array.sort(numerically);

Mais dans de rares cas où le tableau contient des nombres très grands et négatifs, une erreur de débordement peut survenir car le résultat de a-b est inférieur au nombre le plus petit que JavaScript peut gérer.

Donc, une meilleure façon d’écrire numériquement une fonction est la suivante:

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}
4
leet101

pour gérer undefined, null et NaN: Null se comporte comme 0, NaN et undefined va se terminer.

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]
2
Ali Khosro

Essayez ce code comme ci-dessous

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

Pour un tableau d'éléments normal uniquement:

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]**

Pour un tableau d'objets:

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}]**
2
Umesh

Essayez ce code:

HTML:

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

Code 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>
1
Sunny S.M
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)
1
Vardaman PK

Mise à jour! Faites défiler vers le bas de la réponse pour smartSort additif de prop qui donne encore plus de plaisir!
Trie les tableaux de n'importe quoi !

Ma forme préférée personnelle de cette fonction autorise un paramètre pour Ascending ou Descending:

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

Utilisation aussi simple que:

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

Ou Exemple d'extrait de code ici!

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

Amusez-vous encore plus avec une méthode de tri qui trie un tableau contenant plusieurs éléments! Ne couvre pas actuellement "associative" (aka, les clés de chaîne), mais couvre tous les types de valeur! Non seulement il va trier les multiples valeurs asc ou desc en conséquence, mais il va également maintenir constante la "position" de "groupes" de valeurs. En d'autres termes; Les ints sont toujours les premiers, puis viennent les chaînes, puis les tableaux (oui, je fais cela en plusieurs dimensions!), puis Objets (non filtré, élément, date), et enfin indéfinis et nuls!

"Pourquoi?" tu demandes. Pourquoi pas!

Maintenant vient en 2 saveurs! Le premier nécessite des navigateurs plus récents car il utilise Object.defineProperty pour ajouter la méthode à l'objet Array.protoype. Cela facilite l'utilisation naturelle , telle que: myArray.smartSort('a'). Si vous souhaitez implémenter des navigateurs plus anciens ou si vous n'aimez tout simplement pas modifier les objets natifs, faites défiler jusqu'à Méthode uniquement version.

/* 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')

L'utilisation est simple! Commencez par créer un tableau dingue comme:

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

Ensuite, il suffit de le trier!

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

Méthode uniquement

Identique à la précédente, à l'exception d'une méthode simple!

/* 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 */

Utilisation:

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

méthode jsFiddle smartSort (Array, "asc | desc")

1
SpYk3HH

Voici la solution déjà proposée et acceptée en tant que méthode sur le prototype Array:

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};
0
Error404

Voici ma fonction de tableau de tri dans la bibliothèque 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]
0
firestoke