Ruby "ritorno a meno che zero" idioma

Question

Ho un metodo di puzzolente come:

def search_record(*args)  
    record = expensive_operation_1(foo) 
    return record unless record.nil? 

    record = expensive_operation_2(foo, bar) 
    return record unless record.nil? 

    record = expensive_operation_3(baz) 
    return record unless record.nil? 

    record = expensive_operation_4(foo, baz) 
    return record unless record.nil? 
end 

C'è un buon linguaggio rubino per "risultato ritorno della chiamata a meno che zero"?

Oppure devo semplicemente scrivere un metodo return_unless_nil(&blk)?

(Si noti che args sono diversi per ogni chiamata, quindi non posso semplicemente scorrere su di loro)

Answer 1

Non vi preoccupate circa la differenza tra nil e false qui? Se vi interessa solo se il valore di ritorno di ogni metodo è "falsy", allora questo è un modo piuttosto Rubyish di farlo:

def search_record(*args)  
    expensive_operation_1(foo)  || 
    expensive_operation_2(foo, bar) || 
    expensive_operation_3(baz)  || 
    expensive_operation_4(foo, baz) 
end 

Se si ha familiarità con questo idioma, si può spiegare così: Rubino , come la maggior parte delle lingue, "short circuits" o confronti, il che significa che se il primo operando restituisce "truey" non si preoccupa di valutare il secondo operando (cioè se expensive_operation_1 restituisce qualcosa di diverso nil o false, non sarà mai chiamata expensive_operation_2) , perché sa già che il risultato dell'operazione booleana è vero.

Un'altra cosa utile che fa Ruby è, invece di restituire true o false da operazioni booleane, restituisce solo l'ultimo operando che valuta. Quindi in questo caso se expensive_operation_1 restituisce nil, chiamerà quindi expensive_operation_2 e se restituisce un valore (che non è falsy), l'intera espressione valuterà solo quel valore.

Infine, possiamo collegare questi booleani cosicché, in effetti, restituirà il risultato del primo operando che non è falsato e non valuterà mai gli operandi successivi. Se tutti gli degli operandi vengono valutati in modo errato, restituirà l'operando finale (che sappiamo essere falsi e, nel tuo caso, probabilmente nil).

Answer 2

A complemento della risposta di Jordan: immaginiamo che queste funzioni possano restituire un valore booleano (improbabile per una funzione di ricerca, ma comunque) e || non funziona. Si potrebbe quindi utilizzare l'astrazione discusso here:

expensive_operation_1(foo).or_if(:nil?) do 
    expensive_operation_2(foo).or_if(:nil?) do 
    expensive_operation_3(foo).or_if(:nil?) do 
     expensive_operation_4(foo) 
    end 
    end 
end