Ruby: perché fare mentre e fino a non tornare l'ultima riga che eseguono da una funzione?

Question

Mi aspetto un ciclo while per restituire l'ultima istruzione eseguita, ma una funzione non sembra restituirla.

(1) Questo sembra funzionare ..

[10] pry(main)> counter = 0 
=> 0 
[11] pry(main)> a = counter+=1 while counter < 10 
=> nil 
[12] pry(main)> a 
=> 10 

(2) Questo non funziona come mi aspettavo. Mi aspetto che 10 vengano restituiti e archiviati in b.

[19] pry(main)> def increment(terminal_value) 
[19] pry(main)* counter = 0 
[19] pry(main)* while counter < terminal_value 
[19] pry(main)*  counter+=1 
[19] pry(main)* end 
[19] pry(main)* end 
=> :increment 
[20] pry(main)> b = increment(10) 
=> nil 
[21] pry(main)> b 
=> nil 

Domande:

• Perché, in (1), fa nil ottenere tornato da l'istruzione di assegnazione?
• Perché non viene assegnato10?

Aggiornamento:

Come accennato @DaveNewton, in (1), ho pensato che stavo facendo:

a = (counter +=1 while counter < 10) 

ma in realtà stavo facendo:

(a = counter +=1) while counter < 10 

Answer 1

In entrambi i vostri esempi, il ciclo while resul ts come nil.

Da while loop:

Il risultato di un ciclo while è nil meno break viene utilizzata per fornire un valore.

Lo stesso per until:

Come un ciclo while il risultato di una until ciclo è nil meno break viene utilizzato. La risposta di

Answer 2

Tali integrazioni Yu Hao è la risposta alla domanda in cui si afferma this

Qualsiasi dichiarazione in Ruby restituisce il valore dell'ultima espressione valutata.

e seguendo questa logica, se si modifica il codice per (non dicendo che questo è buona pratica o condonare esso, solo un esempio):

def increment(terminal_value) 
    counter = 0 
    while counter < terminal_value 
     counter+=1 
    end 
    counter 
end 

b = increment(10) 

Sarà uscita 10.