29 minutes par jour

Faire du Ruby quotidiennement, et par conséquent, poster quotidiennement, est le concept même du site. Autant c’est pour moi la meilleure façon d’apprendre petit à petit un langage de programmation, autant ce flux ininterrompu de savoir à accumuler ne doit pas empêcher au bout du compte de retenir toutes ces informations.

C’est pourquoi j’écris aujourd’hui un récapitulatif (le premier d’une série), pour, d’une part, prendre du recul, et d’autre part, permettre à vous et moi de consulter ultérieurement ces posts comme des mémo.

Syntaxe du code

Je ne l’avais pas notifié avant, mais je suis sûr que vous l’aurez compris par vous même :

• # : il s’agit d’un commentaire. Le code qu’il y a à la suite de la ligne n’est pas exécuté
• ? : c’est le résultat du code, l’output dans la console, lorsque vous lancez le programme.

Objets de base

En Ruby, tout est un objet.

String (chaîne de caractère)

puts "Hello!"
puts "J'ai #{11*2} ans."

Les doubles guillemets sont préférés aux simples guillements parce qu’ils offrent davantage de caractères d’échappement et parce qu’on peut insérer du code à exécuter.

Numbers

1234 # Fixnum
123456789012345 # Bignum
3.5 # Float, ou nombre décimal

Range

ma_suite = 2..5 # 2,3,4,5
mon_autre_suite = 7...10 # 7,8,9

Array (tableau)

mon_tableau = ['un', 'deux', 'trois'] # tableau basique
mon_identite = ['Nom' => 'Smith' , 'Prénom' => 'John' ] # hash, ou tableau associatif

Blocs

Begin

begin
#contenu de mon bloc
end

Méthode

Par analogie, les objets sont des noms, les méthodes sont des verbes.

def ma_methode(parametre)
#contenu de ma méthode
end

Si une méthode :

• modifie l’objet qui l’appelle, on rajoute un ! à la fin
• questionne l’objet, on rajoute un ? à la fin

Les méthodes retournent par défaut le dernier objet utilisé.

Les méthodes d’une classe peuvent avoir 3 niveaux d’accès :

• public : accessible de partout
• protected : accessible uniquement aux instances de classes et aux instances des classes enfants
• private : accessible uniquement par l’instance actuelle self

Bloc en paramètre

mon_tableau = ['france','allemagne','italie']
mon_tableau.each {|pays| puts "Je suis allé en " + pays + "."}

Proc

Un Proc est un bloc de code passé en paramètre. C’est comme créer une méthode sur une ligne.

mon_proc = Proc.new {|transport| puts "Je préfère le " + transport + "."}
mon_proc.call("train")

On peut remplacer Proc.new par lambda.

Yield

Un yield permet d’ajouter éventuellement un bloc de code à un endroit précis.

def bonjour
  puts "Bonjour."
  yield
  puts "Comment allez-vous ?"
end
bonjour{puts "Je m'appelle Jeremy."}

Classes

Une classe est un “moule” qui permet, grâce à des méthodes, de créer des objets (instances de classe).

class MaClasse < Array
# MaClasse débute avec une majuscule et peut éventuellement hériter d'une classe, ici Array, pour obtenir ses méthodes
end

initialize

C’est la méthode appelée lorsque l’on fait MaClasse.new

class Eleve
  def initialize(nom)
    puts "Je suis " + nom + "."
  end
end
moi = Eleve.new("Jeremy")

Variable d’instance

Une variable d’instance permet de sauvegarder une valeur pour, par exemple, l’afficher par la suite.

class Eleve
  def initialize(nom)
    @nom = nom
  end
  def qui_est_ce
    puts "Je suis " + @nom + "."
  end
end
moi = Eleve.new("Jeremy")
moi.qui_est_ce

Attributs

Les attributs sont des variables d’instance lisibles et/ou éditables de l’extérieur (hors de la classe).

class Eleve
  attr_reader :note
  attr_writer :note
  def initialize(nom)
    @nom = nom
  end
end
etudiant = Eleve.new("Grégory")
etudiant.note = 16
puts etudiant.note

On peut l’écrire de 2 façons :

• attr_reader :attribut : l’attribut est lisible de l’extérieur
• attr_writer:attribut : l’attribut est éditable de l’extérieur

Constante de classe

Une constante de classe permet de sauvegarder une valeur pour une classe entière. Elle s’écrit en MAJUSCULES.

class Equipe
DEFINITION = "Groupe de sportifs."
end

Variable de classe

C’est une variable qui permet de sauvegarder une valeur pour la classe entière.

class Equipe
def vainqueur(club)
@@champion = club
end
end

Méthode de classe

C’est une méthode qui, au lieu de faire une action sur une instance, agit sur la classe en elle-même, et utilise des variables de classe.

class Equipe
def Equipe.champion_en_titre
puts @@champion
end
end

Module

Un module est un bloc de code qui permet de regrouper des méthode/constantes ayant un lien entre elles, et permet surtout d’éviter des conflits entre méthodes/constantes portant le même nom. Un module peut ensuite être inclus dans différentes classes.

module Sport
  # Ici je mets des méthodes et constantes communes à tous les sports
end
class Football
  include Sport
  puts "Le football se joue à 11vs11."
end
class Basket
  include Sport
  puts "Le basket se joue à 5vs5."
end

Importation de fichiers

Deux méthodes pour importer :

• load "mon_fichier.rb" : le fichier est importé sans condition (donc, à chaque fois qu’on l’appelle)
• require "mon_fichier.rb" : le fichier est importé une seule fois (cela permet d’éviter les duplicatas)

Conditions

if

if (a>b)
  puts a.to_s + " plus grand que " + b.to_s
elsif (a<b)
  puts a.to_s + " plus petit que " + b.to_s
else
  puts a.to_s + " égal à " + b.to_s

On peut aussi écrire en ternaire.

a=3
b=4
(a <= b) ? (puts a.to_s + " pas plus grand que " + b.to_s ) : (puts a.to_s  + " plus grand que " + b.to_s )

On peut l’écrire à la fin.

puts "Je peux passer le permis." if age >= 18

unless est le contraire de if.

case

pays = "FR"
case pays
  when "FR": puts "France"
  when "EN": puts "Angleterre"
  else puts "Je ne trouve pas."
end

a = 5
case
  when a > 3 : puts "Plus grand que 3."
  when a < 3 : puts "Plus petit que 3."
  else puts "Egal à 3."
end

Boucle

Boucle conditionnelle

a=0
while a<5
print a
a+=1
end

until est l’inverse de while.

Boucle itérative

mon_tableau = [23,45,95]
for ma_valeur in mon_tableau
puts ma_valeur
end

mon_tableau = [23,45,95]
mon_tableau.each do |ma_valeur|
  puts ma_valeur
end

Contrôle des boucles

La boucle s’arrête si le test de la ligne break est vrai.

my_x = 115
my_y = 40
while(my_x < 150)
my_x += 1
puts my_x
break if (my_x % my_y) == 0
end

Gestion des erreurs

Rescue

def ma_methode
  # plein de code
  rescue NoMethodError => ma_var:
    puts "Contenu de l'erreur : " + ma_var.to_s
  rescue Exception => ma_var:
    puts "Exception!"
  else
    puts "OK."
end

Accessoirement, ensure permet d’assurer l’exécution d’un code, quoiqu’il arrive.

Raise

Autant rescue permet de gérer les erreurs Ruby, autant raise permet de gérer les erreurs que l’on veut.

def edf
if nouveau_joueur != francais
raise "Tu ne peux que sélectionner des français."
end
end

Créer sa propre exception

class MaPropreException < RuntimeError
  # Ma classe d'exception doit hériter d'une classe d'exception déjà existante, en l'occurence ce sera RuntimeError.
end

Throw and catch

Un bloc catch permet de sortir du bloc s’il rencontre un throw portant le même mot-clé.

catch :mot_clef do
  # code exécuté
  throw :mot_clef
  # code exécuté car situé après le throw
end