Programmation Ruby/Méthodes

En programmation objet, les méthodes sont les fonctions appartenant à une classe. En réalité, elles sont des messages envoyé à un objet.

Programmation Ruby

Introduction et installation

• Introduction
• Installation
• Premiers essais

Syntaxe et types

• Syntaxe, Portée, Types
• Expressions de contrôle et boucles
• Types standards
• Conteneurs

Programmation orientée objet

• Les classes
• Les méthodes
• Les accesseurs
• Héritage
• Les exceptions
• Les mixins
• Les modules

Utiliser Ruby

• La bibliothèque standard (stdlib)
• Ruby et le texte non structuré
• Programmation concurrente
• Programmation distribuée
• Persistance des données
• Bases de données et ORM
• Ruby et le Web
• Programmation Ruby/Manipuler des fichiers
• Ruby et les services
• Des interfaces graphiques avec Ruby
• Réflexion
• Exemples de code

Pour les programmeurs...

• Pour les programmeurs Java
• Pour les programmeurs Python
• Pour les programmeurs PHP

Outils autour du langage

• Interactive Ruby Shell
• Le débuggueur
• Le profileur
• Les tests unitaires
• La documentation
• Le packaging (gems)
• Rake
• Étendre Ruby
• Les différentes implémentations du langage

Références

• Mots Réservés
• Variables globales prédéfinies
• Caractères d'échappements
• Webographie

En Ruby, elles sont définies de la façon suivante :

def <nom de la méthode> (*arguments,&bloc)
  <bloc de code de la méthode>
end

Les arguments

Les arguments de la méthode forment une liste de références d'objets.

Ils peuvent être fournis de façon unique ou en liste via :

def mamethode(param1, *reste)
  "mon param1 : #{param1}" << "et le #{reste.join(', ')}" unless reste.empty?
end
mamethode("toto")	»	"mon param1 : toto"
mamethode("toto", "titi")	»	"mon param1 : toto et titi"
mamethode "toto", "titi", "tutu"	»	"mon param1 : toto et titi, tutu"

Les blocs liés

Une méthode Ruby peut recevoir en paramètre la référence à un bloc de code tel que :

def donnezmoiducode(param)
  if block_given?
    yield(param)
  else
    param
  end
end
donnezmoiducode("j'ai faim !")	»	"j'ai faim !"
donnezmoiducode("J'ai faim !") { |s| s = "miam !"') }  # => "miam !"

Si en dernier paramètre de méthode, en prototype, on trouve une déclaration explicite avec une esperluette, alors le bloc est converti en objet Proc et cet objet entre dans la liste de paramètres de la méthode :

class BoiteACalculs
  def initialize(nom, &bloc)
    @nom, @bloc = nom, bloc
  end
  def application(valeur)
    "#{valeur} #{@nom}  = #{ @bloc.call(valeur) }"
  end
end
calcul = BoiteACalculs.new("Fois deux ") { |val| val * 2 }
calcul. application(10)	 #=>	"10 Fois deux = 20"
calcul. application(20)	#=>	"20 Fois deux = 40"

le constructeur initialize

La méthode initialize, par exemple, est la méthode appelée lorsqu'une instance est créée via la méthode new :

class Point
  def initialize ( x, y )
    @x = x
    @y = y
  end
  def coords
    puts "x : #{@x}"
    puts "y : #{@y}"
  end
end

Ici la méthode initialize définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction new.

Si par exemple on initialise un objet comme suit :

p = Point.new(2,3)
# -> @x = 2 et @y = 3

Valeurs par défaut

On peut en Ruby donner des valeurs par défaut aux arguments des méthodes.

class Parle
  def initialize ( nom = "vous" )
    @qui = nom
  end
  def bonjour
    puts "Bonjour #{@qui}"
  end
end

Si l'on appelle la méthode sans argument, la valeur par défaut est assigné à la variable d'instance @qui

dit = Parle.new
dit.bonjour
#                    => Bonjour vous

Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut :

dit2 = Parle.new("Roger")
dit2.bonjour
#                    => Bonjour Roger