À l'aide de Javascript avec Underscore.js pour Trier l'autre sens

Je suis à l'aide de Javascript sort (avec Underscore.js):

_.sortBy(["Bob", "Mary", "Alice"], function (name) {return name})
> ["Alice", "Bob", "Mary"]

Je voudrais le tableau à retourner dans l'autre sens. Comment dois-je faire?

["Marie", "Bob", "Alice"]

Je ne veux pas inverser après c'est triée - je veux qu'il soit créé de l'autre manière autour de la première fois.

Grâce.

Vous vous rendez compte que, finalement, c'est peut-être plus rapide pour trier le tableau normalement, et ensuite appeler reverse()?
Tri puis inverser serait également beaucoup plus lisible que les autres options.

InformationsquelleAutor Harry | 2012-01-02

34

Je voudrais juste faire ce trait de Soulignement sous le capot: utiliser le Tableau#tri méthode.
```
["Bob", "Mary", "Alice"].sort(function (a, b) {
    if (a < b) return 1;
    if (b < a) return -1;
    return 0;
});
```
Ou si vous ne voulez pas que le tableau d'origine modifié, le clone d'abord:
```
_.clone(["Bob", "Mary", "Alice"]).sort(...)
```
- il a travaillé pour moi quand j'ai renversé le moins que des signes d'une plus grande
InformationsquelleAutor Felix Loether
79

Au lieu de les jeter underscorejs loin, je serais plutôt de l'utiliser conjointement avec Array.inverse d'utiliser le meilleur des deux.
```
_.sortBy(["Bob", "Mary", "Alice"], function (name) {return name})
 .reverse()
```
- Aussi, au lieu de la fonction(nom) {return name} vous pouvez simplement utiliser le trait de soulignement de l' _.l'identité de la fonction: _.sortBy(["Bob", "Marie", "Marley", "Alice"], _.d'identité).reverse()
- Je n'appellerais pas cela plus élégant car la .reverse() appel ajoute un autre cycle dans le tableau. C'est donc en fait de moins en moins efficace que de simplement le tri dans le sens inverse que Felix a suggéré.
- "Il est plus facile de faire du bon code rapide que de faire de rapide code est bon." (Attribuent ce phénomène à certains Gourou, je ne me souviens pas qui a dit cela avant) C'est plus "élégant", si la vitesse est ce qui est nécessaire de tri par défaut est peut être suffisant, mais si la vitesse est la principale préoccupation JS n'est pas la manière la plus rapide de la technologie autour de.
- C'est le genre de spectacle deux fois la boucle. 1ère itération. _.sortBy(["Bob", "Mary", "Alice"], function (name) {return name}) 2ème itération .reverse() Mieux à gérer au sein de l' _sortBy
- Keep it simple!!!
InformationsquelleAutor h--n
0

Évidemment, vous ne devriez pas faire cela, car il est plus raisonnable de les trier, puis d'inverser les résultats, mais si vous voulez vraiment pour trier dans l'ordre inverse à l'intérieur de la fonction de tri, vous pourriez faire quelque chose comme ça...
```
_.sortBy(["Bob", "Mary", "Alice"], function (a) {
    //split each string into single characters
    //... then swap for inverse character from unicode range
    //... and glue the characters back together into an inversely sortable string
    return _.map(a.split(''), function(i){
        return String.fromCharCode(65536 - i.charCodeAt(0));
    }).join('');
});
```
... également intéressant de noter que le trait de soulignement est subtilement différent de javascript natif de tri qui a une petite croix plate-forme de problème au sujet de l'uniforme de l'ordre de tri...

Si compareFunction(a, b) renvoie 0, laisser a et b inchangées par rapport à l'autre, mais triés à l'égard de tous les différents éléments. Note: le standard ECMAscript ne garantit pas ce comportement, et donc pas tous les navigateurs (par exemple, Mozilla versions datant d'au moins 2003) le respect de cette. Tableau.le prototype.sort()

Trait de soulignement est .sortBy états de documentation:

Retourne un (stable) triés copie de la liste. _.sortBy

En au lieu de retourner 0 pour conserver les éléments dans l'ordre, il renvoie l'index de la gauche, moins l'index de la droite.
```
_.sortBy = function(obj, iteratee, context) {
  iteratee = cb(iteratee, context);
  return _.pluck(_.map(obj, function(value, index, list) {
    return {
      value: value,
      index: index,
      criteria: iteratee(value, index, list)
    };
  }).sort(function(left, right) {
    var a = left.criteria;
    var b = right.criteria;
    if (a !== b) {
      if (a > b || a === void 0) return 1;
      if (a < b || b === void 0) return -1;
    }
    return left.index - right.index;
  }), 'value');
};
```
InformationsquelleAutor Billy Moon
0

Vous pouvez le faire avec un 1 liner dans l'ES6, il suffit de changer le > selon la direction que vous souhaitez.

.sort() est pris en charge depuis IE6 et vous venez de passer une fonction qui retourne 1 ou -1;
```
["Bob", "Mary", "Alice].sort((a, b) => a > b ? 1 : -1);
```
InformationsquelleAutor Fasani

Vous devez vous connecter pour publier un commentaire.