Méthodes Ruby

Syntaxe

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

Donc, vous pouvez définir une méthode simple comme celle-ci :

def method_name 
   expr..
end

Vous pouvez définir une méthode qui accepte des paramètres comme celui-ci :

def method_name (var1, var2)
   expr..
end

Vous pouvez définir valeurs par défaut pour les paramètres, qui seront utilisées si les paramètres requis ne sont pas transmis lors de l'appel de la méthode :

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

Lorsque vous souhaitez appeler une méthode, utilisez simplement le nom de la méthode, comme indiqué ci-dessous :

method_name

Cependant, lorsque vous appelez une méthode avec des paramètres, vous devez également apporter les paramètres lors de l'écriture du nom de la méthode, par exemple :

method_name 25, 30

Le plus gros inconvénient de l'utilisation de méthodes avec des paramètres est lors de l'appel de la méthode Il faut se rappeler du nombre de paramètres. Par exemple, si vous transmettez uniquement deux paramètres à une méthode qui en accepte trois, Ruby affichera une erreur.

Instance

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test(a1="Ruby", a2="Perl")
   puts "编程语言为 #{a1}"
   puts "编程语言为 #{a2}"
end
test "C", "C++"
test

L'exemple ci-dessus exécutant le résultat de sortie est :

编程语言为 C
编程语言为 C++
编程语言为 Ruby
编程语言为 Perl

Valeur de retour de la méthode

Ruby Every La méthode renvoie une valeur par défaut. La valeur renvoyée est la valeur de la dernière instruction. Par exemple :

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

Lorsque cette méthode est appelée, la dernière variable déclarée k sera renvoyée. Instruction

Ruby return

L'instruction return dans Ruby est utilisée pour renvoyer une ou plusieurs valeurs d'une méthode Ruby.

Syntaxe

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

Si plus de deux expressions sont données, un tableau contenant ces valeurs sera la valeur de retour. Si aucune expression n’est donnée, nil sera la valeur de retour.

Exemple

return

或

return 12

或

return 1,2,3

Regardez l'exemple suivant :

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

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

Le résultat de sortie de l'exemple ci-dessus est :

100
200
300

Nombre variable de paramètres

Supposons que vous déclariez une méthode avec deux paramètres. Lorsque vous appelez la méthode, vous devez également transmettre deux paramètres.

Cependant, Ruby permet de déclarer des méthodes avec un nombre variable de paramètres. Regardons l'exemple suivant :

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def sample (*test)
   puts "参数个数为 #{test.length}"
   for i in 0...test.length
      puts "参数值为 #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

Dans ce code, vous avez déclaré un exemple de méthode qui accepte un paramètre test. Cependant, ce paramètre est un paramètre variable. Cela signifie que les paramètres peuvent prendre différents nombres de variables. Le résultat de sortie de l'exemple ci-dessus est :

参数个数为 3
参数值为 Zara
参数值为 6
参数值为 F
参数个数为 4
参数值为 Mac
参数值为 36
参数值为 M
参数值为 MCA

Méthode de classe

Lorsque la méthode est définie en dehors de la classe, la méthode est marquée privée par défaut. En revanche, si la méthode est définie dans une classe, elle est marquée publique par défaut. La visibilité par défaut des méthodes

et de la balise private peut être modifiée via le module public ou private du module.

Lorsque vous souhaitez accéder aux méthodes d'une classe, vous devez d'abord instancier la classe. Ensuite, en utilisant l'objet, vous pouvez accéder à n'importe quel membre de la classe.

Ruby fournit un moyen d'accéder aux méthodes sans instanciation. Voyons comment déclarer et accéder aux méthodes de classe :

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Nous savons déjà comment la méthode return_date est déclarée. Il est déclaré en faisant suivre le nom de la classe d'un point, suivi du nom de la méthode. Vous pouvez accéder directement à la méthode de classe comme suit :

Accounts.return_date

Pour accéder à cette méthode, vous n'avez pas besoin de créer un objet de classe Accounts.

Instruction Ruby alias

Cette instruction est utilisée pour alias une méthode ou une variable globale. Les alias ne peuvent pas être définis dans un corps de méthode. L'alias d'une méthode conserve la définition actuelle de la méthode même si la méthode est remplacée.

Les alias de variables globales numérotées ($1, $2,...) sont interdits. Le remplacement des variables globales intégrées peut entraîner de graves problèmes.

Syntaxe

alias 方法名 方法名
alias 全局变量 全局变量

Exemple

alias foo bar
alias $MATCH $&

Ici, nous avons défini un alias pour bar comme foo et un alias pour $& comme $MATCH.

Instruction Ruby undef

Cette instruction est utilisée pour annuler la définition d'une méthode. undef ne peut pas apparaître dans le corps de la méthode.

En utilisant undef et alias, l'interface d'une classe peut être modifiée indépendamment de la classe parent, mais veuillez noter que cela peut casser le programme lors de l'appel de méthodes en lui-même.

Syntaxe

undef 方法名

Exemple

L'exemple suivant annule la définition de méthode nommée bar :

undef bar