Petit tuto ruby en français

ruby.md

Le commencement

Les variables

Tout d'abord nous allons voir les variables Elle ne sont pas bien différentes du python, js, php

En php, les variables commencent par un '$' En js on les déclares avec var En ruby, c'est comme en python :

boulou = "Hello World"
numb = 21
vrai_ou_faux = true

Rien de bien sorcier jusqu'ici N'oublions pas l'utilité des variables qui est de stocké des valeurs que nous voulons ré-utilisé

Entrée et sorti en ligne de commande

Sorti

Vous pouvez afficher du texte dans la ligne de commandes en passant par 2 fonctions au choix:

puts "Salut"
print "Salut"
print " World"

La fonction puts sert à afficher du texte et de retourner à la ligne juste après La fonction print fait exactement la même chose, àl'exception prêt qu'elle ne retourne pas à la ligne juste après SI on fait tourner nos trois petites ligne la sortie donnera :

Salut
Salut World

SI nous voulons maintenant afficher des variables avec du texte, pas besoin de concatenation :

prenom_variable = "Chris"
puts "Salut #{prenom_variable}"

ET ceci marche avec n'importe quel type de variable !

Vous pouvez aussi passer par un autre moyen, qui est de passer un "Hash" (que nous verrons juste après), en paramètre si je puis dire Comme ceci :

puts "Salut %{prenom} je suis %{friend} et j'ai %{age}" % {prenom: "Chris", friend: "Boulou", age: 21}

Entrée

Pour demander une valeurs à l'utilisateur depuis la ligne de commandes il faut passer par la fonction :

boulou = gets.chomp

Cette fonction demander une string (chaîne de caractère) à l'utilisateur

Vous pouvez aussi passez via l'objet '$stdin'

$stdin.get.chomp

SI par exemple vous voulez récupérer un nombre entier au lieu d'une string :

boulou = gets.chomp.to_i # to_i qui signifie "to integer"

Pareil avec un nombre à virgule ...

boulou = gets.chomp.to_f

Tableaux et Hash

Tableaux

Les tableaux en ruby s'écrivent de cette manière :

myTab = []
myTab[0] = "Hello"
myTab.push("World")
# join en string
str = myTab.join(' ')
# une string en array : 
arr = str.split(' ')

Jusque la se sont des tableaux ... Pour avoir la liste de ce qui est possible avec des tableaux :

puts myTab.methods

Hash

Maintenant ... le plus important, les Hash ! On peux les définir de deux manière :

h = Hash.new( "example" ) # ou encore Hash.new "example"

# on peut aussi écrire

h2 = {"hello" => "world"}

Ici, on écrira plutot la deuxième méthode (qui est la plus simple de compréhension) Comme vous avez pu le voir, les Hash ne sont rien d'autres que des tableaux avec une pair <clé - valeur> personnalisable

Il y a une autre forme de hash que vous verrez certainement,

tab = {:salut => "world"}
tab[:salut] # --> "world"

Il n'est pas tellement différent de son autre forme La seul différence est que l'on appelle dans le premier cas via une string et dans le second cas, d'un "symbole" (un symbole est toujours précédé d'un ":")

Contidions et boucles

If

Une condition "si .. ou alors .. sinon" en ruby s'écris de se système la :

if boulou == 0
    puts "I'm #{boulou}"
elsif boulou > 0
    puts "I'm greater than you"
else
    puts "Oh ... I'm little ..."
end

N'oubliez jamais l'instruction "end" de fin

Simple nan ?

while

i = 0
num = 5

while i < num  do
   puts(" i = #{i}" )
   i +=1
end

begin while

le begin est comme le do .. while Il execute au moins une fois la boucle :

i = 0
num = 5
begin
   puts("i = #{i}" )
   i +=1
end while i < num

until

Execute du code, tant que la condition est fausse !

i = 0
num = 5

until i > num  do
   puts(" = #{i}" )
   i +=1;
end

begin until

comme le begin while, mais tant que la condition est fausse comme le until

i = 0
num = 5
begin
   puts("i = #{i}" )
   i +=1;
end until i > num

for

Une simple boucle for, pour tout X compris entre 0 et 5

tab = [0, 1, 2, 3, 4, 5]
for i in tab
   puts "#{i}"
end

retry

Le retry fais revenir au début, si une condition est vrai :

tab = [1, 2, 3, 4, 5]
for i in tab
   retry if  i > 2
   puts "#{i}"
end

unless

Execute le code si la condition est fausse

x=1
unless x>2
   puts "x is less than 2"
 else
  puts "x is greater than 2"
end

case

Le case est similaire au switch des autres langages

P.S. Ne vous fiez pas au 0 .. 2 on verra ça plus tard

$age =  5
case $age
when 0 .. 2
    puts "baby"
when 3 .. 6
    puts "little child"
when 7 .. 12
    puts "child"
when 13 .. 18
    puts "youth"
else
    puts "adult"
end

each

L'opérateur each, qui n'est pas un opérateur :p C'est une méthode qui appartient au tableaux et au Hash. Moins de blabla, plus de code :

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

Voilà, donc ici on utilise la méthode each pour boucler sur chaque élément du tableaux ! i prend donc les valeurs, 1 puis 2 puis 3 puis ... On s'arrête la !

Monsieur, comment on fait pour boucler sur un Hash du coup ?

C'est une très bonne question Jean-Alphonse .. La théorie et la pratique est la même, sauf que au lieu d'avoir un parmaètre entre les deux pipes '|' On aura 2 paramètre !

h = {"Hello" => "World", "Boulou" => "Bala"} 
h.each do |key, value|
  puts key
  puts value
end

Rien de sorcier en plus ..

Attrapez les tous !

Ici, nous allons voir le .collect d'un tableau, il permet de retourner un autre tableau en ayant appliquer une opération sur chaque élément.

APPORTEZ L'EXEMPLE !!!

b = (0..5).collect{|x| 10*x}
puts b # il aura multiplier chaque élément par 10

Ranges

Ici on entre dans des fonctionnalitées qui sont très utiles ! (surtout pour ceux qui font des maths).

On va commencer par simple

a = (0..5)

Ceci va nous ressortir : [0, 1, 2, 3, 4, 5]

a = (0...5) # [0, 1, 2, 3, 4] les trois point exclu le dernier résultat

C'est bien pour faire des listes rapides :)

Mais c'est inutile !!!

Comment ça ? Bon ok, je vais vous donner une autre astuce qui pourrais vous plaire :

("a" .. "z").each do |x|
	puts x
end

Et la résultats ? a, b, c, d, e, f ... z Ca vous plait un peu mieux ? ;)

Nous verrons la suite plus tard

Les fonctions

Nous y voilà !

Comment définir une fonction ? that's so simple !

def myFunction
	puts "je suis une fonction !"
end

myFunction # affiche "je suis une fonction !"
myFunction() # affiche "je suis une fonction !"

Comment ? Vous voulez des paramètres ?

def myFunc(boulou)
	puts "je suis #{boulou}"
end

myFunc("Chris")

Je vais même vous donner une astuce, mais chut c'est un secret !

def myFunc(*args)
	puts args
end

myFunc("Chris", "boulou") # il va applique la fonction pour chaque paramètre donné
# et donc afficher "Chris" puis "boulou"

Avec une valuer par défaut :

def func(boulou = "boulou")
	puts boulou
end

func # affiche "boulou"

Module

Les modules sont un point clé, c'est comment bien structurer vos ficher et donc vos fonctions

# ./MyMath.rb
module MyMath
	PI = 3.14
	
	def MyMath.add(numb1, numb2)
		return numb1 + numb2
	end
end

# ./main.rb

require "./MyMath.rb"

puts MyMath::PI
result = myMath.add(1, 2)

C'est quasiment tout ce qu'il y à savoir sur le sujet ;)

Date Time

Bien, maintenant la parti relou dans chaque langage, le date time !

Commençons par quelques exemple pour se mettre dans le bain

# July 8, 2008
Time.local(2008, 7, 8)  

# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)   

# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)  

# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)  

Maintenant, créons notre propre date !

time = Time.new

puts time.ctime # Mon Jun  2 12:35:19 2016
puts time.strftime("%Y-%m-%d %H:%M:%S") # 2016-06-02 12:35:19

Maintenant je ne vois pas comment vous faire un bon tuto sur les dates time donc vous pouvez vous référrez à ça : http://www.tutorialspoint.com/ruby/ruby_date_time.htm

Exceptions

Détecter une exception

J'aime bien les appeller les casse c***lles :D Mais trêve de plaisanterie ...

Les exceptions sont des blocks qui se lancent lorsque qu'une erreur se produit dans le code Mais ce n'est pas magique, il faut les ajouter soi-même !!

Bien, imaginons une division par zero ... c'est impossible, sommes-nous d'accord sur ce point ? Si quelqu'un veut faire une division par zero dans notre code par exemple, il faudra dire que cela n'est pas possible

Voilà comment nous pourrions l'écrire :

begin
	puts 5 / 0
rescue
	puts "Division by zero is forbidden bast*rd!!!"
end

Si vous executez ce code, vous pouvez voir que la seul chose afficher est la string. Pourquoi ? Tout simplement parce que l'interpréteur ruby à detecter une erreur donc est passé dans notre phase "rescue"

En effet si vous lancez un code comme celui-ci :

puts 5 / 0

La seule chose que vous verrez apparaître sera une jolie erreur comme celle-ci : test.rb:1:in `/': divided by 0 (ZeroDivisionError)

Rééssayer

Grâce à une super fonctionnalité de ruby, il est possible de retenter une opération du block !

Regardons par l'exemple :

n1 = 5
n2 = 0
begin
	puts n1 / n2
rescue
	n2 = 1
end

Et là vous pouvez voir que celà nous ressort ... 5 !!! Bah oui 5/1 == 5 (thanks captain obvious :D)

Lancer une exception

Bon, on détecte, on peut retry ... Mais j'aimerai bien pouvoir signalez exception !! Et non, le 'puts' ne suffit pas ! :p

Pour cela on va devoir utiliser l'expression raise

Je ne vais pas vous faire languir plus longtemps bande de coquinou ;)

begin 
	puts "Avant l'exception"
	raise "MY FUCKING EXCEPTION MOTHER F*CKER"
	puts "Après l'exception"
rescue
	puts "Je suis là ne t'en fais pas !"
end

Ici, vous pourrez observez que le résultat est donc : Avant l'exception Je suis là ne t'en fais pas !

Mais que deviens le "MY FUCKING EXCEPTION MOTHER F*CKER ?
Et le : puts "Après l'exception" ??????!!!!

Ah, je vois que vous êtes de nature curieuse ! Je préfère vous prévenir, je n'aime pas ça.

Mais bon, tout simplement parce que l'exception lancer (raise), avec une chaine de caractère est envoyé, mais nous ne lui avons pas dis quoi en faire :D ET pour le : puts "Après l'exception" Tout simplement, une fois une exception lancé, la suite du code dans le block begin est stop, comme si l'on avait fait un break ou un exit

Si vous voulez afficher votre message du raise il vous suffit de :

begin  
  raise 'Petit test'  
rescue Exception => e  
  puts e.message
  puts e.backtrace.inspect  
end 

Et le résultat sera .... roulement de tambour...

Petit test ["main.rb:4"]

C'est génial je trouve, pas vous ?

Finalement ...

Si vous avez déjà fait des exceptions dans d'autres langages Type en php (beurk), nosu avons le block "finally". Ici nous utiliseront "ensure", mais le concepte reste le même. Il s'agit de faire un block dans la egstion d'erreur qui s'executera si une exception est lancé, ou même si il n'y en a pas de lancé !

Faites place au prince ali ! Heu non, faites place à l'exemple !

begin
  raise 'Petit test'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
ensure
  puts "Je suis la"
end

Et le grand gagnant sera ...

Petit test ['main.rb:4'] Je suis la

ELSE !

Il existe un block, comme dans les conditions, qui permettent d'executer du code si aucune exception n'est lancé le block "else"

begin
 # raise 'Petit test'
 puts "Je ne lance pas d'exception"
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
else
   puts "Aucune erreur !"
ensure
  puts "Je serai toujours la ..."
end

Le résultat :

Je ne lance pas d'exception Aucune erreur ! Je serai toujours la ...

catch / throw : la dernière ligne droite

Bon, la dernière parti sur les exceptions je vous le promet ;)

Cette parti là, sert à lancer et capturer une exception, même si on est pas dans un block begin ! Et ça, ça c'est cool ! Sisi, faîtes moi confiance ;)

Place à l'exemple mes (pas) amis !

def func(boulou = nil)
	throw :customException if boulou == nil
end

catch :customException do
	puts "Arg, une exception !"
end

func

block et yield

Commençons pas le yield, je trouve que c'est un concept qui mérite que l'on se pense dessus ... En fait, le mot-clef yield, il sert tout bonnement à executer du code perso directement dans une fonction !

Vous ne voyez pas ce que je veux dire , Let's do it !

def func
	puts "Dans la fonction func"
	yield
	puts "Fin de func"
end

func { puts "Appeler de dehors" }

Ce qui donne :

Dans la fonction func Appeler de dehors Fin de func

Mais bon, c'est bien beau tout ça, mais avec des paramètre c'est encore mieux !

Go !

def func
	puts "Dans la fonction func"
	yield "Chris"
	puts "Fin de func"
end

func { |name| puts "Bonjour je m'appelle #{name}" }

Et donc : Dans la fonction func Bonjour je m'appelle Chris Fin de func

C'est pas trop balèze quand même ? :D

Nous avons vu ce qu'est le yield, mais le block, c'est quoi ? ET bien c'est tout simplement le bout de code appelé après l'appel de fonction le fameux : { |name| puts "Bonjour je m'appelle #{name}" }

Bon et maintenant une notion importante, si nous mettons un ampersand ("&") devant le dernier paramètre de la fonction, cela signifie que nous pouvons apppelé notre block.

Démonstration * sors la baguette magique *

def test(&block)
   block.call
end
test { puts "Hello World!"}

Donne : Hello World!

ET voilà !! C'est la fin de la partie yield et block.

Mais il y a un autre point clé ...

BEGIN and END

La seul chose à savoir, est que le block BEGIN est la première chose à s'executer quand on execute le fichier et END la dernière chose

BEGIN {
  puts "BEGIN"
} 

END {
  puts "END"
}
 
puts "MAIN"

BEGIN MAIN END

Ce qui clos la partie des blocks !

expressions régulières

La je ne vais m'y pencher que très brièvement, juste la base des bases Ce qu'il faut savoir dans les expressions régulières en ruby est juste dans la partie de code en dessous :

line1 = "Chats";
line2 = "Chien";

if ( line1 =~ /Chats(.*)/ )
  puts "Line1 contient le mot Chats"
end
if ( line2 =~ /Cats(.*)/ )
  puts "Line2 contient le mot Chats"
end

Donne: Line1 contient le mot Chats

Voilà, apres les regexp sont pareils de partout et je vous laisserai vous renseigner à ce sujet !

Les Classes !!!!

Bon sans doute une des parties les plus importantes. Donc une class s'initialise avec une fonction "initialize" (qui n'est pas obligatoire) les variables de class (attribut), commence par un '@' On peut rendre visible une variable de class via 'attr_reader'

Mais place à l'exemple :

class Cheval
	attr_reader :name
	
	def initialize(name)
		@name = name
	end
	
	def name=(otherName)
		@name = otherName
	end
end

horse = Cheval.new("Ponyta")
horse.name = "Galopa"

Mais on peux aussi passer par le attr_writer

class Cheval
	attr_reader :name
	attr_writer :name
	
	def initialize(name)
		@name = name
	end
end

horse = Cheval.new("Ponyta")
horse.name = "Galopa"

Mais on peux tout aussi bien raccourcir en mettant le "attr_accessor"

class Cheval
	attr_accessor :name
	
	def initialize(name)
		@name = name
	end
end

horse = Cheval.new("Ponyta")
horse.name = "Galopa"

Voilà le en gros d'une class, vous voyez ça reste toujours aussi bête :)

L'héritage

L'héritage est l'art de reproduire le système parent -> enfant Et donc de donner de ses gênes à son enfant. Regardons comment cela se fesse :

class Animal
	attr_accessor :name

	def initialize(name, nombreDePatte, queue)
		@name = name
		@nombreDePatte = nombreDePatte
		@queue = queue
	end
	
	def grogner
		puts "*grognement sauvage*"
	end
end

class Chien < Animal
	def initialize(name)
		super(name, "4", true)
	end
	
	def grogner
		# super() # super appelle la méthode du parent de la class
		# si elle n'est pas appeller, seulement la méthode de la classe fille sera appelé
		puts "Wouaf Wouaf"
	end
end

dog = Chien.new("Balto")
dog.grogner

N'oubliez pas si il y a encore des points obscures, faites moi signes :)