★ wanayoo — archive 1999 https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/sortNouvelle recherche | Portail wanayoo

Notice: Some MDN email addresses and hashed passwords were temporarily posted on a publicly accessible server. http://blog.mozilla.org/security/2014/08/01/mdn-database-disclosure/

Vos résultats de recherche

    Array.prototype.sort()

    Résumé

    La méthode sort() trie les éléments d'un tableau, en place, et renvoie le tableau. Le tri n'est pas forcément stable. Le tri s'effectue par défaut selon les points de code Unicode de la chaine de caractères.

    Syntaxe

    arr.sort([fontionComparaison])

    Paramètres

    fonctionComparaison
    Spécifie une fonction définissant l'ordre de tri. Si absente, le tableau est trié selon la valeur de point de code Unicode de chaque caractère, d'après la conversion en chaine de caractères de chaque élément.

    Description

    Si le paramètre fonctionComparaison n'est pas fourni, les éléments sont triés en les convertissant en chaines de caractères et en comparant ces chaines selon l'ordre des points de code Unicode. Par exemple, "Cerise" arrive avant "banane". Dans un tri numérique, 9 arrive avant 80, mais comme ces nombres sont convertis en chaines de caractères, "80" arrive avant "9" dans un tri Unicode.

    var fruit = ["pommes", "bananes", "Cerises"];
    fruit.sort(); // ["Cerises", "bananes", "pommes"];
    
    var scores = [1, 2, 10, 21]; 
    scores.sort(); // [1, 10, 2, 21]
    
    var choses = ["mot", "Mot", "1 Mot", "2 Mots"];
    choses.sort(); // ["1 Mot", "2 Mots", "Mot", "mot"] 
    // En Unicode, les nombres arrivent avant les majuscules, qui elles-même arrivent avant les minuscules.

    Si le paramètre fonctionComparaison est fourni, les éléments du tableau sont triés selon la valeur de retour de la fonction de comparaison. Si a et b sont deux éléments à comparer, alors :

    • Si fonctionComparaison(a, b) est inférieur à 0, trie a avec un indice inférieur à b.
    • Si fonctionComparaison(a, b) renvoie 0, laisse a et b inchangés l'un par rapport à l'autre, mais triés par rapport à tous les autres éléments. Note : la norme ECMAScript ne garantit pas ce comportement, par conséquent tous les navigateurs (par exemple les versions de Mozilla antérieures à 2003) ne respectent pas ceci.
    • Si fonctionComparaison(a, b) est supérieur à 0, trie b avec un indice inférieur à a.
    • fonctionComparaison(a, b) doit toujours renvoyer à partir de la même paire d'arguments. S'il y a des inconsistances dans les résultats, alors le trie renverra undefined.

    Donc, la fonction de comparaison a la forme suivante :

    function compare(a, b) {
      if (a est inférieur à b selon les critères de tri)
         return -1;
      if (a est supérieur à b selon les critères de tri)
         return 1;
      // a doit être égal à b
      return 0;
    }
    

    Pour comparer des nombres plutôt que des chaînes, la fonction de comparaison peut simplement soustraire b à a :

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

    L'usage des function expressions (et des closures)  est très pratique avec la méthode sort() :

    var nombres = [4, 2, 5, 1, 3];
    nombres.sort(function(a, b) {
        return a - b;
    });
    print(nombres);
    

    Les objets peuvent être triés d'après les valeurs d'une de leurs propriétés.

    var items = [
      { name: "Edward", value: 21 },
      { name: "Sharpe", value: 37 },
      { name: "And", value: 45 },
      { name: "The", value: -12 },
      { name: "Magnetic" },
      { name: "Zeros", value: 37 }
    ];
    items.sort(function (a, b) {
        if (a.name > b.name)
          return 1;
        if (a.name < b.name)
          return -1;
        // a doit être égale à b
        return 0;
    });

    Différences d'implémentation

    Certaines implémentations de JavaScript utilisent un tri stable : l'ordre partiel de a et b ne change pas si a et b sont égaux. Si l'indice de a était inférieur à celui de b avant le tri, il le sera toujours après, quels que soient les mouvements de a et b dus au tri.

    Le tri est stable dans SpiderMonkey et tous les navigateurs basés sur Mozilla à partir de Gecko 1.9 (voir le bug 224128).

    Le comportement de la méthode sort() a changé entre JavaScript 1.1 et JavaScript 1.2.

    En JavaScript 1.1, sur certaines plateformes, la méthode sort ne fonctionnait pas. Le tri fonctionne sur toutes les plateformes à partir de JavaScript 1.2.

    En JavaScript 1.2, cette méthode ne convertit plus les éléments non définis (undefined) en null ; elle les place en fin de tableau. Par exemple, supposons que vous ayez ce script :

    var a = [];
    a[0] = "araignée";
    a[5] = "zèbre";
    
    // suppose qu'une fonction print est définie
    function writeArray(x) {
      for (i = 0; i < x.length; i++) {
        print(x[i]);
        if (i < x.length-1)
          print(", ");
      }
    }
    
    writeArray(a);
    a.sort();
    print("\n");
    writeArray(a);
    

    En JavaScript 1.1, cette fonction affichait :

    araignée, null, null, null, null, zèbre
    araignée, null, null, null, null, zèbre
    

    En JavaScript 1.2, elle affichera :

    araignée, undefined, undefined, undefined, undefined, zèbre
    araignée, zèbre, undefined, undefined, undefined, undefined
    

    Exemples

    Création, affichage et tri d'un tableau

    L'exemple qui suit crée quatre tableaux et affiche le tableau original, puis les tableaux triés. Les tableaux numériques sont triés d'abord sans, puis avec une fonction de comparaison.

    var stringArray = ["Bosse", "Bleue", "Béluga"];
    var numericStringArray = ["80", "9", "700"];
    var numberArray = [40, 1, 5, 200];
    var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
    
    function compareNombres(a, b) {
      return a - b;
    }
    
    // suppose qu'une fonction print function a été définie
    print("Chaînes : " + stringArray.join() +"\n");
    print("Triées : " + stringArray.sort() +"\n\n");
    
    print("Nombres : " + numberArray.join() +"\n");
    print("Triés sans fonction de comparaison : " + numberArray.sort() +"\n");
    print("Triés avec compareNombres : " + numberArray.sort(compareNombres) +"\n\n");
    
    print("Chaînes numériques : " + numericStringArray.join() +"\n");
    print("Triées sans fonction de comparaison : " + numericStringArray.sort() +"\n");
    print("Triées avec compareNombres : " + numericStringArray.sort(compareNombres) +"\n\n");
    
    print("Nombres et chaînes numériques : " + mixedNumericArray.join() +"\n");
    print("Triés sans fonction de comparaison : " + mixedNumericArray.sort() +"\n");
    print("Triés avec compareNombres : " + mixedNumericArray.sort(compareNombres) +"\n\n");
    

    Cet exemple produit la sortie suivante. Comme on peut le voir, lorsqu'on utilise la fonction de comparaison, les nombres sont triés correctement qu'ils soient des nombres ou des chaînes numériques.

    Chaînes : Bosse,Bleue,Béluga
    Triées : Bleue,Bosse,Béluga
    
    Nombres : 40,1,5,200
    Triés sans fonction de comparaison : 1,200,40,5
    Triés avec compareNombres : 1,5,40,200
    
    Chaînes numériques : 80,9,700
    Triées sans fonction de comparaison : 700,80,9
    Triées avec compareNombres : 9,80,700
    
    Nombres et chaînes numériques : 80,9,700,40,1,5,200
    Triés sans fonction de comparaison : 1,200,40,5,700,80,9
    Triés avec compareNombres : 1,5,9,40,80,200,700
    

    Trier des caractères non-ASCII

    Pour des chaines de caractères contenant des caractères non ASCII, c'est à dire des chaines de caractères contenant par exemple des accents (é, è, a, ä, etc.) : utilisez String.localeCompare. Cette fonction peut comparer ces caractères afin qu'ils apparaissent dans le bon ordre.

    var items = ["réservé", "premier", "cliché", "communiqué", "café" ,"adieu"];
    items.sort(function (a, b) {
        return a.localeCompare(b);
    });
    
    // items is [ 'adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé' ]

    Spécifications

    Spécification Statut Commentaire
    ECMAScript Language Specification 6th Edition (ECMA-262) Draft  
    ECMAScript Language Specification 5.1th Edition (ECMA-262) Standard  
    ECMAScript 1re Édition Standard Première définition.

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support de base 1.0 1.0 (1.7 ou moins) 5.5 (Oui) (Oui)
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support de base (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)

    Voir également

    Étiquettes et contributeurs liés au document

    Contributeurs ayant participé à cette page : BenoitL, teoli, Goofy, tregagnon, Jeremie
    Dernière mise à jour par : teoli,