Ruby - Metodi

I metodi Ruby sono molto simili alle funzioni di qualsiasi altro linguaggio di programmazione. I metodi Ruby vengono utilizzati per raggruppare una o più istruzioni ripetibili in una singola unità.

I nomi dei metodi dovrebbero iniziare con una lettera minuscola. Se inizi un nome di metodo con una lettera maiuscola, Ruby potrebbe pensare che sia una costante e quindi può analizzare la chiamata in modo errato.

I metodi dovrebbero essere definiti prima di chiamarli, altrimenti Ruby solleverà un'eccezione per invocare metodi non definiti.

Sintassi

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

Quindi, puoi definire un metodo semplice come segue:

def method_name 
   expr..
end

Puoi rappresentare un metodo che accetta parametri come questo:

def method_name (var1, var2)
   expr..
end

È possibile impostare valori predefiniti per i parametri, che verranno utilizzati se il metodo viene chiamato senza passare i parametri richiesti -

def method_name (var1 = value1, var2 = value2)
   expr..
end

Ogni volta che chiami il metodo semplice, scrivi solo il nome del metodo come segue:

method_name

Tuttavia, quando chiami un metodo con parametri, scrivi il nome del metodo insieme ai parametri, come -

method_name 25, 30

Lo svantaggio più importante dell'utilizzo di metodi con parametri è che è necessario ricordare il numero di parametri ogni volta che si chiamano tali metodi. Ad esempio, se un metodo accetta tre parametri e ne passi solo due, Ruby visualizza un errore.

Esempio

#!/usr/bin/ruby

def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

Questo produrrà il seguente risultato:

The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl

Valori restituiti dai metodi

Ogni metodo in Ruby restituisce un valore per impostazione predefinita. Questo valore restituito sarà il valore dell'ultima istruzione. Ad esempio:

def test
   i = 100
   j = 10
   k = 0
end

Questo metodo, quando chiamato, restituirà l'ultima variabile dichiarata k .

Dichiarazione di ritorno di Ruby

L' istruzione return in ruby ​​viene utilizzata per restituire uno o più valori da un metodo Ruby.

Sintassi

return [expr[`,' expr...]]

Se vengono fornite più di due espressioni, la matrice contenente questi valori sarà il valore restituito. Se non viene fornita alcuna espressione, nil sarà il valore restituito.

Esempio

return

OR

return 12

OR

return 1,2,3

Dai un'occhiata a questo esempio:

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

Questo produrrà il seguente risultato:

100
200
300

Numero variabile di parametri

Supponi di dichiarare un metodo che accetta due parametri, ogni volta che chiami questo metodo, devi passare due parametri insieme ad esso.

Tuttavia, Ruby ti consente di dichiarare metodi che funzionano con un numero variabile di parametri. Esaminiamo un esempio di questo:

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

In questo codice, hai dichiarato un esempio di metodo che accetta un test di parametro. Tuttavia, questo parametro è un parametro variabile. Ciò significa che questo parametro può contenere un numero qualsiasi di variabili. Quindi, il codice sopra produrrà il seguente risultato:

The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA

Metodi di classe

Quando un metodo viene definito al di fuori della definizione della classe, il metodo viene contrassegnato come privato per impostazione predefinita. D'altra parte, i metodi definiti nella definizione della classe sono contrassegnati come pubblici per impostazione predefinita. La visibilità predefinita e il marchio privato dei metodi possono essere modificati da pubblico o privato del modulo.

Ogni volta che vuoi accedere a un metodo di una classe, devi prima creare un'istanza della classe. Quindi, utilizzando l'oggetto, puoi accedere a qualsiasi membro della classe.

Ruby ti dà un modo per accedere a un metodo senza istanziare una classe. Vediamo come viene dichiarato e utilizzato un metodo di classe:

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Guarda come viene dichiarato il metodo return_date. Viene dichiarato con il nome della classe seguito da un punto, seguito dal nome del metodo. È possibile accedere direttamente a questo metodo di classe come segue:

Accounts.return_date

Per accedere a questo metodo, non è necessario creare oggetti della classe Account.

Istruzione alias Ruby

Questo fornisce alias per metodi o variabili globali. Gli alias non possono essere definiti all'interno del corpo del metodo. L'alias del metodo mantiene la definizione corrente del metodo, anche quando i metodi vengono sovrascritti.

È vietato creare alias per le variabili globali numerate ($ 1, $ 2, ...). L'override delle variabili globali incorporate può causare seri problemi.

Sintassi

alias method-name method-name
alias global-variable-name global-variable-name

Esempio

alias foo bar
alias $MATCH $&

Qui abbiamo definito l'alias foo per bar e $ MATCH è un alias per $ &

Ruby undef Statement

Ciò annulla la definizione del metodo. Un undef non può apparire nel corpo del metodo.

Utilizzando undef e alias , l'interfaccia della classe può essere modificata indipendentemente dalla superclasse, ma si noti che potrebbero essere programmi danneggiati dalla chiamata del metodo interno a self.

Sintassi

undef method-name

Esempio

Per annullare la definizione di un metodo chiamato bar, procedi come segue:

undef bar