ordinamento di una matrice ruby ​​di oggetti con un attributo che potrebbe essere nil

Question

Ho una matrice di oggetti che ho bisogno di ordinare da un attributo di posizione che potrebbe essere un intero o nullo, e ho bisogno degli oggetti che hanno la posizione nil essere alla fine della serie. Ora, posso forzare la posizione a restituire un valore piuttosto che nil in modo che l'array.sort non abbia esito negativo, ma se uso 0 come predefinito, mette gli oggetti in cima all'ordinamento. Qual è il modo migliore per fare questo genere? dovrei semplicemente impostare i valori nulli su un numero incredibilmente alto che è quasi sempre garantito alla fine? o c'è un altro modo in cui potrei causare il metodo array.sort per mettere gli oggetti nil degli attributi alla fine dell'array? il codice è simile al seguente:

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 

ora, se faccio la cosa 'altra' come 1000000000, allora è più probabile intenzione di metterli alla fine della matrice, ma non mi piace questa soluzione in quanto è arbitraria

Answer 1

ne dite in Child definizione <=> basarsi su category.position se category esiste, e gli elementi di ordinamento senza una category come sempre maggiore di quelli con 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 

Poi nel Parent si può chiamare children.sort.

Answer 2

non ho fatto Ruby in un po ', ma si potrebbe dividere il nulla-checking dal ordinamento (e solo consentire Bambino # posizione per tornare null):

def sorted_children 
    children.reject{|c| c.position.nil?}.sort_by(&:position) + 
    children.select{|c| c.position.nil?} 
end 

Certo non è il più soluzione efficiente, ma non ha numeri magici.

Answer 3

Per essere onesti, non ho molta familiarità con Ruby, quindi prendi questo più come idea di algoritmo piuttosto che come codice uno ... e riscrivi l'operatore?: Come qualsiasi cosa Ruby abbia che è più pulito.

Non puoi semplicemente verificare la presenza di zero nel confronto:

class Parent 
    def sorted_children 
    children.sort{|a,b|(a and b) ? a <=> b : (a ? -1 : 1) } 
    end 
end 

A cura di utilizzare il codice di Glenra, che implementa la stessa cosa come la mia, ma in un più piccolo (e probabilmente più facile da leggere) quantità di codice .

Answer 4

Vorrei semplicemente modificare il tipo per mettere gli elementi nil per ultimo. Prova qualcosa di simile.

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] 

che dice: se a e b sono entrambi non-nil ordinarli normalmente, ma se uno di loro è pari a zero, restituire uno stato che ordina che uno più grande.

Answer 5

mi occupo di questo genere di cose come questa:

children.sort_by {|child| [child.position ? 0 : 1,child.position || 0]} 

Answer 6

Si può fare questo senza sostituire l'operatore astronave attraverso la definizione di un nuovo metodo di confronto.

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 

Il metodo sort può prendere un blocco, in modo da poter quindi ordinare utilizzando questo nuovo metodo: "? .nil"

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