Variabili Locali

Una variabile locale ha un nome che comincia cn una letera minuscola o con un carattere di underscore (_). Le variabili locali non hanno, come le variabili globali e di istanza, il valore nil prima dell'inizializzazione:

ruby> $foo
   nil
ruby> @foo
   nil
ruby> foo
ERR: (eval):1: undefined local variable or method `foo' for main(Object)

La mprima assegnazione ad una variabile locale funziona più o meno come una dichiarazione. Se vi riferite ad una variabile locale non inizializzata , l'interprete ruby pensa che si tratti di un entativo di invocare un metodo con quel nome ; da cui l'errore che vedete qui sopra.

Generalmente,la visibilità di una variabile locale è una tra

proc{ ... }
loop{ ... }
def ... end
class ... end
module ... end
l'intero programma (se non si applica nessuna delle precedenti)

Nel prossimo esempio, defined? È un operatore che verifica se un identificatore è stato definito. Eso restituisce una descrizione dell'identificatore se esso è definito, o nil altrimenti. Come potete vedere, la visibilità di bar è locale al ciclo; quando il ciclo finisce, la definizione di bar viene annullata .

ruby> foo = 44; print foo, ""; defined? foo
44
   "local-variable"
ruby> loop{bar=45; print bar, ""; break}; defined? bar
45
   nil

Gli oggetti di tipo porocedura che esistono nello stesso scope condividono le variabili locali che appartengono a quello scope. Qui, la variabile locale bar è condivisa tra main e gli oggetti procedura p1 e p2:

ruby> bar=0
   0
ruby> p1 = proc{|n| bar=n}
   #<Proc:0x8deb0>
ruby> p2 = proc{bar}
   #<Proc:0x8dce8>
ruby> p1.call(5)
   5
ruby> bar
   5
ruby> p2.call
   5

Notate che "bar=0" all'inizio non può essere omesso; quella assegnazionefa si che il campo di visibilità di bar comprenda p1 e p2. Altrimenti p1 e p2 finirebbero per avere ognuna la sua variabile locale bar, e la chiamata a p2 sarebbe risultata in un errore "undefined local variable or method" .

Una potente caratteristica degli oggetti procedura discende dalla loro capacità di esere passati come argomenti : le variabili locali rimangono valide quando essi vengono passati fuori dal loro scope originale .

ruby> def box
    |   contenuti = 15
    |   get = proc{contenuti}
    |   set = proc{|n| contenuti = n}
    |   return get, set
    | end
   nil
ruby> lettore, scrittore = box
   [#<Proc:0x40170fc0>, #<Proc:0x40170fac>]
ruby> lettore.call
   15
ruby> scrittore.call(2)
   2
ruby> lettore.call
   2

Ruby è particolarmente intelligente a proposito della visibilità. È evidente nel nostro esempio che la variabile contenuti è condivisa tra lettore e scrittore. Ma possiamo anche mettere su coppie multiple di lettori-scrittori usando box come definito qui sopra ; ogni coppia condivide una variabile contenuti ,e le coppie non interferiscono l'una con l'altra .

ruby> lettore_1, scrittore_1 = box
   [#<Proc:0x40172820>, #<Proc:0x4017280c>]
ruby> lettore_2,   scrittore_2 = box
   [#<Proc:0x40172668>, #<Proc:0x40172654>]
ruby> scrittore_1.call(99)
   99
ruby> lettore_1.call
   99
ruby> lettore_2.call
   15