Ruby - Métodos

Los métodos de Ruby son muy similares a las funciones de cualquier otro lenguaje de programación. Los métodos de Ruby se utilizan para agrupar una o más declaraciones repetibles en una sola unidad.

Los nombres de los métodos deben comenzar con una letra minúscula. Si comienza el nombre de un método con una letra mayúscula, Ruby podría pensar que es una constante y, por lo tanto, puede analizar la llamada incorrectamente.

Los métodos deben definirse antes de llamarlos, de lo contrario Ruby generará una excepción para la invocación de métodos no definidos.

Sintaxis

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

Entonces, puede definir un método simple de la siguiente manera:

def method_name 
   expr..
end

Puede representar un método que acepta parámetros como este:

def method_name (var1, var2)
   expr..
end

Puede establecer valores predeterminados para los parámetros, que se utilizarán si se llama al método sin pasar los parámetros requeridos:

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

Siempre que llame al método simple, escriba solo el nombre del método de la siguiente manera:

method_name

Sin embargo, cuando llama a un método con parámetros, escribe el nombre del método junto con los parámetros, como:

method_name 25, 30

El inconveniente más importante de usar métodos con parámetros es que necesita recordar el número de parámetros cada vez que llama a dichos métodos. Por ejemplo, si un método acepta tres parámetros y solo pasa dos, Ruby muestra un error.

Ejemplo

#!/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

Esto producirá el siguiente resultado:

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

Valores devueltos de métodos

Cada método en Ruby devuelve un valor por defecto. Este valor devuelto será el valor de la última declaración. Por ejemplo

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

Este método, cuando se llama, devolverá la última variable declarada k .

Declaración de devolución de Ruby

La declaración de retorno en ruby ​​se usa para devolver uno o más valores de un método Ruby.

Sintaxis

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

Si se dan más de dos expresiones, la matriz que contiene estos valores será el valor de retorno. Si no se proporciona ninguna expresión, el valor devuelto será nulo.

Ejemplo

return

OR

return 12

OR

return 1,2,3

Eche un vistazo a este ejemplo:

#!/usr/bin/ruby

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

Esto producirá el siguiente resultado:

100
200
300

Número variable de parámetros

Suponga que declara un método que toma dos parámetros, siempre que llame a este método, debe pasar dos parámetros junto con él.

Sin embargo, Ruby le permite declarar métodos que funcionan con un número variable de parámetros. Examinemos una muestra de esto:

#!/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"

En este código, ha declarado una muestra de método que acepta una prueba de parámetro. Sin embargo, este parámetro es un parámetro variable. Esto significa que este parámetro puede aceptar cualquier número de variables. Entonces, el código anterior producirá el siguiente resultado:

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

Métodos de clase

Cuando un método se define fuera de la definición de clase, el método se marca como privado de forma predeterminada. Por otro lado, los métodos definidos en la definición de clase están marcados como públicos por defecto. La visibilidad predeterminada y la marca privada de los métodos se pueden cambiar por público o privado del Módulo.

Siempre que desee acceder a un método de una clase, primero debe crear una instancia de la clase. Luego, usando el objeto, puede acceder a cualquier miembro de la clase.

Ruby te ofrece una forma de acceder a un método sin instanciar una clase. Veamos cómo se declara y se accede a un método de clase:

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Vea cómo se declara el método return_date. Se declara con el nombre de la clase seguido de un punto, seguido del nombre del método. Puede acceder a este método de clase directamente de la siguiente manera:

Accounts.return_date

Para acceder a este método, no es necesario crear objetos de la clase Cuentas.

Declaración de alias de Ruby

Esto le da alias a métodos o variables globales. Los alias no se pueden definir dentro del cuerpo del método. El alias del método mantiene la definición actual del método, incluso cuando se anulan los métodos.

Está prohibido hacer alias para las variables globales numeradas ($ 1, $ 2, ...). Anular las variables globales integradas puede causar problemas graves.

Sintaxis

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

Ejemplo

alias foo bar
alias $MATCH $&

Aquí hemos definido foo alias para bar, y $ MATCH es un alias para $ &

Declaración de Ruby undef

Esto cancela la definición del método. Un indef no puede aparecer en el cuerpo del método.

Mediante el uso de undef y alias , la interfaz de la clase se puede modificar independientemente de la superclase, pero tenga en cuenta que los programas pueden romperse por la llamada al método interno a self.

Sintaxis

undef method-name

Ejemplo

Para anular la definición de un método llamado bar, haga lo siguiente:

undef bar