le tri d'un rubis tableau d'objets par un attribut qui pourrait être nul

J'ai un tableau d'objets que j'ai besoin de trier par position d'attribut qui pourrait être un entier positif ou nul, et j'ai besoin de les objets qui ont le néant position d'être à la fin du tableau. Maintenant, je peux forcer la position de retourner de la valeur plutôt que le néant, de sorte que le tableau.le tri n'est pas en panne, mais si je utiliser 0 comme ce défaut, il met les objets à l'avant de la sorte. Quelle est la meilleure façon de faire ce genre? dois-je tout simplement définir le néant à des valeurs ridiculement grand nombre qui est "presque" toujours la garantie d'être à la fin? ou est-il un autre moyen que je pourrais causer le tableau.méthode de tri pour mettre le néant des objets d'attribut à la fin du tableau? le code ressemble à ceci:

class Parent
  def sorted_children
     children.sort{|a, b| a.position <=> b.position}
  end
end

class Child
  def position
    category ? category.position : #what should the else be??
  end
end

maintenant, si je fais le 'else' quelque chose comme 1000000000, alors il est plus probable va les mettre à la fin du tableau, mais je n'aime pas cette solution car il est arbitraire

InformationsquelleAutor Chris Drappier | 2009-04-30

15

Dans la Child définition <=> être basé sur category.position si category existe, les éléments de tri et sans category comme toujours plus que ceux avec un category?
```
class Child
  # Not strictly necessary, but will define other comparisons based on <=>
  include Comparable   
  def <=> other
    return 0 if !category && !other.category
    return 1 if !category
    return -1 if !other.category
    category.position <=> other.category.position
  end
end
```
Puis dans Parent vous pouvez les appeler children.sort.
- Je serais un peu douteux sur cette car elle limite votre capacité à trier sur autre chose sans être incohérent. Cela étant dit, si la position est naturelle ordre de tri pour les parents, c'est un montant raisonnable de sens de faire de cette façon.
- Si vous cochez la case modifier l'histoire, je l'avais initialement ajouté une mise en garde au sujet de quoi faire si vous avez besoin de les trier selon différents critères, mais il était confusion formulée et je ne pense pas qu'il a ajouté beaucoup. Fondamentalement, vous pouvez ajouter d'autres méthodes de comparaison qui sont le nom que vous voulez, et si vous avez besoin de trier sur eux, le faire dans un bloc comme l'exemple d'origine.
InformationsquelleAutor Brian Campbell
97

Je voudrais juste modifier le son de votre genre à mettre nil dernier. Essayez quelque chose comme ça.
```
foo = [nil, -3, 100, 4, 6, nil, 4, nil, 23]

foo.sort { |a,b| a && b ? a <=> b : a ? -1 : 1 }

=> [-3, 4, 4, 6, 23, 100, nil, nil, nil]
```
Qui dit que: si a et b sont à la fois non-nul de les trier normalement, mais si l'un d'eux est nul, le retour à un statut sortes que l'un des plus grands.
- Merci! Ce doit être la accepté de répondre.
- D'accord, ce devrait être la accepté de répondre. Si vous êtes heureux de compter sur truthy et falsy valeurs, vous pouvez obtenir une fraction plus courte: foo.sort { |a,b| a <=> b || (b && 1) || -1 }
- Je ne voulais pas remplacer la navette spatiale (!) opérateur sur l'ensemble de la maquette, juste dans une opération donnée, c'est donc beaucoup mieux pour mon besoin.
InformationsquelleAutor glenra
16

- Je traiter ces sortes de choses de ce genre:
```
 children.sort_by {|child| [child.position ? 0 : 1,child.position || 0]}
```
- Pouvez-vous expliquer cela un peu plus? Il semble que vous utilisez 0 comme un nombre magique quand la position est nul, ce qui peut ne pas être valide, car la position n'est pas définie à être supérieur à 0 (c'est une hypothèse raisonnable, mais n'est pas nécessairement le cas).
- Non, le 0 à la fin, c'est juste pour éviter d'appeler <=> sur le zéro. Le premier élément du tableau déjà assure que tous les nils viendra après toutes les positions valides. Le deuxième élément subsorts parmi les choses avec des positions. Vous pouvez mettre quelque chose là-bas pour subsort ceux avec nils, mais l'exemple n'appelez pas pour rien, donc j'ai simplement utilisé de 0. Il pourrait être 42 ou "wombat", il n'a pas d'importance.
- Ah, ok, la confusion était à cause de mon manque de Ruby connaissances. Suis-je bien comprendre que vous êtes en fait la création d'un tableau/liste de deux valeurs, 1 et la valeur si la valeur est nulle... ou 0 et la valeur si la valeur est non-nul... puis le tri à l'aide de la paire comme "la valeur de tri"? Chouette idée, c'était vraiment pas clair pour moi parce que je n'ai pas reconnu la syntaxe.
- Bon, je suis représentant de chaque enfant par deux éléments subarray: [0,position] si la position n'est pas nul, et [1,0] si la position est nulle. Ruby comparaison des tableaux compare les touches dans l'ordre, de sorte que tous les sous-réseaux qui commencent par 0 (le non-néant positions) trier d'abord, subsorted par position. Ensuite, tous les sous-tableaux à 1 (le néant positions). Techniquement, ces nils sont ensuite subsorted par ceux de "0", c'est pourquoi 0 peut être 42 ou "camembert" ou quoi que ce soit. Si vous aviez un autre des critères de subsort le nils, il faudrait y aller à la place. Ne peuvent pas quitter néant, parce qu'il ne dispose pas d'un <=> la méthode.
- Au moins en Ruby 1.9.3p327, nil <=> nil retourne 0. À l'aide de vaisseau spatial entre le néant et rien d'autre retourne généralement nulle, mais nulle et lui-même renvoie 0. En conséquence, [1, nil, 2] <=> [1, nil, 3] retourne -1. En conséquence, aussi longtemps que il ya une valeur plus tôt dans le tableau (c 0 / 1 pour les non-néant-néant) qui divise le néant, les valeurs de la non-néant valeurs, alors il devrait être sûr d'utiliser le néant.
InformationsquelleAutor glenn mcdonald
6

Pour être juste, je ne suis pas très familier avec Ruby, afin de prendre cela comme un algorithme idée plutôt qu'un code... et réécrire l' ?: opérateur de ce que Ruby a c'est plus propre.

Ne pouvez pas vous seulement de vérifier néant dans la comparaison:
```
class Parent
  def sorted_children
     children.sort{|a,b|( a and b ) ? a <=> b : ( a ? -1 : 1 ) }
  end
end
```
Modifiées à utiliser Glenra du code qui implémente la même chose que la mienne, mais dans une plus petite (et probablement plus facile à lire) quantité de code.

InformationsquelleAutor RHSeeger
1

Je n'ai pas fait de Rubis dans un moment, mais vous pouvez diviser le null-vérification de la tri (et juste permettre à l'Enfant#position pour retourner null):
```
def sorted_children
  children.reject{|c| c.position.nil?}.sort_by(&:position) +
    children.select{|c| c.position.nil?}
end
```
Certes ce n'est pas la solution la plus efficace, mais il n'a pas de numéros de magie.
- ".néant?" est superflue, puisque c.la position est vrai ssi c.la position n'est pas nul, mais vous pourriez la laisser dans pour des raisons de lisibilité. Je l'aime!
- Je pense que c'est vrai dans ce cas, puisque la "position" est probablement un certain nombre, mais depuis que Ruby a 2 "fausses" valeurs (néant et le faux), j'essaie de ne pas supposer que les non-nil signifie vrai. J'ai pris de l'mordu par l'avant. 🙂
InformationsquelleAutor Ken

Vous pouvez le faire sans écraser le vaisseau spatial de l'opérateur par la définition d'une nouvelle méthode de comparaison.

class Child
  include Comparable   
  def compare_by_category(other)
    return 0 if !category && !other.category
    return 1 if !category
    return -1 if !other.category
    category.position <=> other.category.position
  end
end

La sort méthode peut prendre un bloc, de sorte que vous pouvez les trier à l'aide de cette nouvelle méthode:

children.sort {|a,b| a.compare_by_category(b) }

merci BRO, utile +1

InformationsquelleAutor Chris O'Sullivan

La solution la plus simple pour moi est

def sorted_children(children)
  children.sort_by { |child| child.position || -1}
end

InformationsquelleAutor Dolev

Vous devez vous connecter pour publier un commentaire.