Metodi esplici, impliciti e definiti dall'utente in Ruby
Nel corso di questa guida abbiamo sottolineato più volte come Ruby sia un linguaggio orientato agli oggetti; un oggetto ha un nome univo che lo identifica all'interno di un'applicazione, ad esso sono associati dei metodi e questi metodi possono essere di tipo differente.
Vi sono alcuni metodi, come per esempio "puts" e "gets" di cui abbiamo parlato in precedenza, per i quali non sempre facile identificare gli oggetti a cui fanno riferimento.
Il metodo "main", anche di questo abbiamo già parlato, è considerato un "metodo implicito" in quanto per decisione dello stesso esecutore fa riferimento a qualsiasi oggetto presente nell'applicazione.
A questo punto è necessario poter utilizzare uno strumento che ci consenta di identificare l'oggetto corrente, cioè quello a cui è associato il metodo che desideriamo utilizzare.
Fortunatamente Ruby ci mette a disposizione questo strumento sotto forma di una variabile speciale denominata self; essa potrà essere richiamata attraverso una semplice istruzione:
puts selfNel momento in cui un programma viene eseguito è possibile identificare un solo oggetto accessibile al programma in esecuzione (perchè solo uno "esiste" per l'esecutore); naturalmente, se non è stato richiamato o definito alcun altro metodo, l'esecuzione di "self" restituirà semplicemente "main", il metodo di default.
I metodi nativi in Ruby sono veramente tanti, eppure è possibile anche introdurne di nuovi sulla base delle esigenze dell'utente; vediamo questo semplice esempio:
# definizione di un metodo
# metodo e parametri
def saluto(nome)
# istruzioni
puts 'Buongiorno ' + nome + '!'
# valore di ritorno
return 'Come va?'
# chiusura del blocco di definizione
end
# chiamata al metodo
puts(saluto('Max'))
=begin
La chimata al metodo stampa:
Buongiorno Max!
Come va?
=end
def è l'istruzione che ci permette di definire un metodo; ad essa segue il nome del metodo e tra parentesi i parametri che dovranno essere utilizzati dal metodo; prima della chiusura del blocco sarà possibile indicare le istuzioni che il metodo dovrà compiere e un eventuale valore di ritorno introdotto dal costrutto return.A questo punto, per richiamare il metodo creato sarà sufficiente passargli un valore per il parametro indicato.
Chi conosce PHP avrà sicuramente notato come il meccanismo sia molto simile a quello utilizzato nella definizione delle funzioni.
Nella creazione di un metodo l'utente ha la possibilità di definire anche dei valori di default da associare ai parametri argomento del metodo; vediamo un semplice esempio:
=begin
definizione di un metodo
con valori di default
=end
# metodo e parametri
def a(par1='Cane', par2='Gatto', par3='Topo')
#istruzioni
"#{par1}, #{par2} e #{par3}."
# chiusura del blocco di definizione
end
# chiamata al metodo
puts a
# stampa: Cane, Gatto e Topo
Da notare l'uso del costrutto "#{parametro}" (operatore di interpolazione) utilizzato per il passaggio delle variabili; quando i parametri sono espressi in questo modo essi devono essere racchiusi tra doppi apici, i singoli apici infatti non "esplodono" le variabili, cioè non ne permettono la stampa del relativo valore (anche qui una similitudine con PHP).
Vediamo ora un secondo esempio:
=begin
definizione di un metodo
senza valori di default
=end
# metodo e parametri
def b(* parametri)
# istruzioni
parametri.each do | vals|
puts vals
# chiusura del blocco di istruzioni
end
# chiusura del blocco di definizione
end
# passaggio di valori al metodo
b('Cane', 'Gatto', 'Topo')
# chiamata al metodo
b()
=begin
la chiamata al metodo stampa:
Cane
Gatto
Topo
=end
In questo secondo caso, i parametri da passare al metodo non sono stati definti a priori i parametri di default da passare al metodo, è stato possibile invece introdurli successivamente (al di fuori del blocco di definizione) grazie all'utilizzo del simbolo "*" che prende il significato di "qualsiasi parametro".
