Ho letto il modulo Enumerable in Ruby e contiene alcuni metodi che seguono lo schema di
enum.foo(n) {|obj| block } → nil
enum.foo(n) → an_enumerator
Il che significa che sembrano restituire un iteratore quando incatenato e null'altro. Qual è il ragionamento alla base di questo approccio invece di restituire una sequenza? (Sto chiedendo ragionamenti generali per questo approccio, non necessariamente solo il suo uso in Ruby)
Quindi non sono sicuro delle differenze tra i due approcci in Ruby, ma in C # abbiamo la parola chiave yield (che può essere utilizzata solo quando si restituisce IEnumerable o IEnumerable (l'Enumerable generico). una chiusura sull'ambiente corrente che crea un enumeratore che utilizza tale chiusura È più facile dimostrarlo nel codice che parlarne.Ecco un generatore di Fibonapac con rendimento:
public IEnumerable<long> Fibonnaci()
{
long current, previous;
if(current==0)
yield return current++;
(for byte i=2;i<128;i++) //Fibonacci numbers grow big quickly.
{
long tmp=current+previous;
previous=current;
current=tmp;
yield return tmp;
}
}
Nota che non devo ricorrere alla ricorsione, semplicemente valuto il mio valore attuale e ritorno. Ora se voglio ottenere il numero x di Fibonaci, creo semplicemente una funzione in questo modo:
public long GetFibonacciNumber(byte count)
{
byte currentCount;
foreach(long value in Fibonacci())
{
if(++currentCount<count)
break;
return value;
}
}
Roba potente.