| layout | page |
|---|---|
| title | Ruby per chi conosce altri linguaggi |
| lang | it |
La prima volta che darai un’occhiata a del codice scritto in Ruby, ti farà venire in mente altri linguaggi di programmazione che hai già usato. Questo non è un caso: molti aspetti sintattici risulteranno familiari a coloro che conoscono Perl, Python e Java (tra gli altri), quindi se hai già usato uno di questi linguaggi, imparare Ruby sarà facilissimo. {: .summary}
Questo documento contiene due sezioni principali: la prima descrive che cosa gli utenti che conoscono altri linguaggi possono aspettarsi quando proveranno Ruby, mentre la seconda entra un po’ di più nel dettaglio sulle caratteristiche di Ruby e sul come si possano paragonare a quanto ti è già familiare.
In questa sezione sono descritte brevemente alcune caratteristiche particolari di Ruby.
Due caratteristiche che si discostano da quello che puoi aver già visto
in altri linguaggi sono i “blocchi” e gli iteratori. Invece di iterare
su un indice (come in C, C++, o Java pre-1.5), o su una lista (come il
for (@a) {...} di Perl o il for i in aList: ... di Python),
con Ruby vedrai spesso costrutti come:
{% highlight ruby %} una_lista.each do |questo_elemento|
end {% endhighlight %}
Per maggiori informazioni su each e simili (collect, find,
inject, sort, ecc.) vedi ri Enumerable
(e poi ri Enumerable#nome_funzione).
Non c’è differenza tra un’espressione e uno statement: ogni cosa ha un valore, anche se tale valore è nullo (nil):
{% highlight ruby %} x = 10 y = 11 z = if x < y true else false end z # => true {% endhighlight %}
Molti neofiti di Ruby hannno difficoltà a capire cosa sono i simboli
(Symbols) e a che cosa servono. I simboli possono essere intesi, di
fatto, come degli identificatori usati per riferirsi ad altri oggetti.
Per capire la differenza, prova a scrivere le espressioni seguenti in
irb:
{% highlight irb %} irb(main):001:0> :pippo.object_id == :pippo.object_id => true irb(main):002:0> "pippo".object_id == "pippo".object_id => false irb(main):003:0> {% endhighlight %}
Il metodo object_id ritorna l’identità di un’oggetto. Se due oggetti
hanno la stessa object_id allora sono di fatto la stessa cosa (puntano
entrambi al medesimo oggetto in memoria).
Come puoi vedere, una volta usato un simbolo, qualsiasi altro simbolo
con lo stesso nome si riferirà allo stesso oggetto in memoria, e ognuno
di questi simboli ritornerà quindi la medesima object_id.
Diamo un’occhiata più da vicino alle stringhe (“pippo”) nella seconda
espressione: ognuna delle due stringhe ha una propria object_id, cioè
mappa un oggetto diverso in memoria. Ciò non avviene con simboli con lo
stesso nome, che puntano sempre al medesimo oggetto. Se sei indeciso se
usare una stringa o un simbolo, pensa a cosa è più importante a seconda
del caso: l’identità di un’oggetto (per esempio una chiave di una Hash)
o il contenuto (“pippo”, nell’esempio precedente).
Questa frase non è un’iperbole: anche classi e numeri interi sono oggetti, puoi fare con loro le stesse cose che puoi fare con qualsiasi altro oggetto:
{% highlight ruby %}
MyClass = Class.new do attr_accessor :instance_var end {% endhighlight %}
Le costanti non sono realmente “costanti”. Se modifichi una costante che è già stata inizializzata, questo causerà un messaggio di errore, ma non interromperà l’esecuzione del programma. Tuttavia questo non vuol dire che tu debba per forza ridefinire delle costanti!
Ruby usa delle specifiche convenzioni sui nomi dei suoi elementi:
- Se un’identificatore inizia con una maiuscola è una costante.
- Se inizia con il simbolo del dollaro (
$) è una variabile globale. - Se inizia con
@è una variabile di istanza. - Se inizia con
@@è una variabile di classe.
Tuttavia i metodi possono avere un’iniziale maiuscola, anche se questo può causare confusione, come nell’esempio seguente:
{% highlight ruby %} Costante = 10 def Costante 11 end {% endhighlight %}
In questo modo, Costante è 10, ma Costante() è 11.
Come in Python, dalla versione 2.0 di Ruby è possibile definire metodi con parametri nominali:
{% highlight ruby %} def consegna(da: 'A', a: nil, via: 'mail') "Invio da #{da} a #{a} via #{via}." end
consegna(a: 'B')
consegna(via: 'Pony Express', da: 'B', a: 'A')
{% endhighlight %}
In Ruby ogni cosa eccetto nil e false è interpretato come true, mentre in C, Python e molti altri linguaggi, 0 e magari anche altri valori sono interpretati come false.
Diamo un’occhiata al seguente codice in Python (questo esempio si applica anche ad altri linguaggi):
{% highlight python %}
if 0: print("0 è true") else: print("0 è false") {% endhighlight %}
Questo stamperà “0 è false”, mentre l’equivalente in Ruby:
{% highlight ruby %}
if 0 puts "0 è true" else puts "0 è false" end {% endhighlight %}
Stampa “0 è true”.
Nel seguente codice Ruby:
{% highlight ruby %} class MiaClass private def un_metodo; true; end def un_altro_metodo; false; end end {% endhighlight %}
Ci si potrebbe aspettare che un_altro_metodo sia pubblico, ma non è
così: il modificatore di accesso private continua fino alla fine dello
scope, o fino a quando un altro modificatore di accesso venga
specificato.
I metodi sono pubblici di default:
{% highlight ruby %} class MyClass
def un_metodo; true; end
private
def un_altro_metodo; false; end end {% endhighlight %}
public, private e protected sono, di fatto, dei metodi, e come tali
accettano anche dei parametri. Per modificare la visibilità di un solo metodo,
per esempio, è sufficiente passare un simbolo a tale metodo come parametro di
un modificatore di accesso per cambiarne la visibilità.
In Java, public significa che un determinato metodo è accessibile da
tutti. protected vuol dire invece che solamente le istanze della
classe o delle sue classi derivate e classi nello stesso package possono
accedere al metodo, e private implica che nessuno tranne le istanze
della medesima classe ha accesso al metodo.
Ruby differisce leggermente: public vuol dire sempre pubblico, ma
private implica che i metodi sono accessibili solo quando non sono
chiamati con un ricevente esplicito, solamente self può essere
usato come ricevente per una chiamata ad un metodo pubblico.
protected è il più inusuale dei tre. Un metodo protetto può essere chiamato
da un’istanza della classe o delle sue derivate, ma anche con un’altra istanza
come receiver. Per chiarificare meglio il concetto, consideriamo questo
semplice esempio adattato dalle Ruby Language FAQ:
{% highlight ruby %} class Test
def identifier 99 end
def ==(other) identifier == other.identifier end end
t1 = Test.new # => #Test:0x34ab50 t2 = Test.new # => #Test:0x342784 t1 == t2 # => true
class Test protected :identifier end
t1 == t2 # => true
class Test private :identifier end
t1 == t2
{% endhighlight %}
In Ruby, tutte le classi sono “aperte”. Questo vuol dire che puoi aggiungere
metodi e variabili e cambiarle in qualsiasi momento, e questo vale anche per
classi interne, come Integer o anche Object, il “genitore” di tutti gli
oggetti. Ruby on Rails, per esempio, definisce una serie di metodi per fare
operazioni temporali con oggetti Integer:
{% highlight ruby %} class Integer def hours self * 3600 # numero di secondi in un'ora end alias hour hours end
Time.mktime(2006, 01, 01) + 14.hours # => Sun Jan 01 14:00:00 {% endhighlight %}
In Ruby, i nomi dei metodi possono terminare con punti esclamativi o
interrogativi. Per convenzione, metodi che rappresentano delle risposte
a delle domande (es. Array#empty? ritorna true se il
ricevente è vuoto) finiscono con un punto interrogativo, mentre metodi
potenzialmente “pericolosi” (modificano il ricevente o i gli argomenti,
exit! ecc.) finiscono, sempre per convenzione, con un punto
esclamativo.
Non tutti i metodi che cambiano i propri argomenti finiscono con un
punto esclamativo, però. Questo è il caso di Array#replace che
sostituisce il contenuto di un array con il contenuto di un altro array,
semplicemente perchè non avrebbe molto senso avere un metodo come questo
che non modifica il ricevente.
I metodi singleton sono dei metodi ad hoc per singoli oggetti, e sono pertanto definibili sull’oggetto per il quale sono stati definiti.
{% highlight ruby %} class Automobile def ispeziona "Macchina a buon mercato" end end
porsche = Automobile.new porsche.ispeziona # => Macchina a buon mercato def porsche.ispeziona "Macchina costosa" end
porsche.ispeziona # => Macchina costosa
altra_auto = Automobile.new altra_auto.ispeziona # => Macchina a buon mercato {% endhighlight %}
Ruby non si arrende se non riesce a trovare un metodo che risponde ad un
particolare messaggio, e chiama il metodo method_missing con il nome
del metodo non trovato e i relativi argomenti. Di default,
method_missing causa un’eccezione NameError, ma è possibile ridefinirlo
a seconda delle esigenze di una particolare applicazione, e così fanno
molte librerie. Ecco un esempio:
{% highlight ruby %}
def method_missing(id, *argomenti) puts "Il metodo #{id} è inesistente - è stato chiamato con " + "i seguenti argomenti: #{argomenti.join(", ")}" end
__ :a, :b, 10
{% endhighlight %}
Questo esempio stampa i dettagli della chiamata, ma è possibile gestire il messaggio nel modo più appropriato, a seconda delle proprie esigenze.
Una chiamata ad un metodo è, di fatto, un messaggio per un altro oggetto:
{% highlight ruby %}
1 + 2
1.+(2)
1.send "+", 2 {% endhighlight %}
I blocchi (ma chiamiamoli pure closure), sono usati moltissimo nella
libreria standard. Per chiamare un blocco, è possibile usare yield
oppure rendere il blocco un oggetto Proc aggiungendo un argomento
speciale, così:
{% highlight ruby %} def blocco(&il_blocco)
il_blocco # ritorna il blocco end sommatore = blocco { |a, b| a + b }
sommatore.class # => Proc {% endhighlight %}
È possibile anche creare dei blocchi fuori da chiamate a metodi,
semplicemente chiamando Proc.new con un blocco o chiamando il metodo
lambda.
Allo stesso modo, anche i metodi sono pur sempre oggetti:
{% highlight ruby %} method(:puts).call "puts è un oggetto!"
{% endhighlight %}
Molti degli operatori sono solamente dello “zucchero sintattico” (con alcune regole di precendenza però) per delle chiamate a dei metodi. È possibile, per esempio, ridefinire il metodo “+” della classe Integer:
{% highlight ruby %} class Integer
def +(other) self - other end end {% endhighlight %}
Non c’è nemmeno bisogno di usare operator+, come in C++.
È possibile anche definire un modo di accedere a uno specifico
elemento come in un array, definendo i metodi [] e []=, mentre per
definire metodi unari + e – (pensa a +1 e -2, ad esempio), bisogna
definire, rispettivamente, i metodi +@ e -@.
I seguenti operatori però non sono zucchero sintattico: non sono metodi e non possono essere ridefiniti:
{% highlight ruby %} =, .., ..., not, &&, and, ||, or, :: {% endhighlight %}
Inoltre, +=, *= ecc. sono solo abbreviazioni di
var = var + other_var, var = var * other_var, ecc. e quindi
non possono essere ridefiniti.
Quando sei pronto per imparare di più su Ruby, dai un’occhiata alla sezione Documentazione.