Le langage Ruby
Aperçu

Ruby est un langage interprété pur object développé par Yukihiro Matsumoto

Pour télécharger ruby aller sur le site francophone http://www.ruby-lang.org/fr
Sous Debian, l'installation se fait avec la commande : apt-get install ruby
Pour lancer l’interpréteur ruby, sous Linux taper irb

Guide de Programmation en Ruby : http://www.ruby-doc.org/docs/ProgrammingRuby/html/

1. String

x=12 "abc #{x} abc" 'abc #{x} abc'	=> "abc 12 abc" => "abc #{x} abc"	Double cote, évalue #{x} Simple cote, n'évalue pas #{x}
"ab"+"cd"	=>"abcd"	Concaténation
"ab" "cd"	=>"abcd"	Concaténation
"ab"*3	=>"ababab"	Répliqué 3 fois
"abc".reverse	=> "cba"
s="abc" s.reverse!	=> "cba"	Modification physique
s="aaa" s << " do" << " re"	=> aaa do re	Modification physique
s=String.new("abc")	=> "abc"
%Q#abc#	=> "abc"	Double cote
%=abc=	=> "abc"	Double cote
%<abc>	=> "abc"	Double cote
%qabc	=> "abc"	Simple cote
%q{abc}	=> "abc"	Simple cote
`date +%A`	=> "dimanche\n"	Anticote, commande système
%x(date +%A)	=> "dimanche\n"	Anticote, commande système
%r&ab\|cd&	=> /ab\|cd/	Expression régulière
s= <<DOC ab cd ef DOC	=>"ab\ncd\nef\n"	Texte avec passage à la ligne ab cd ef
"%05d" % 12	=> "00012"	Format décimal justifié
"%-5d" % 12	=> "12 "	Format décimal justifié
"%b" % 5	=> "101"	Format binaire
"%x" % 255	=> "ff"	Format hexadécimal
"%.2f" % 3.1415	=> "3.14"	Format flotant avec 2 chiffres de précisions
"ab\"cd"	=> "ab\"cd"	Caractère d'échapement \
s="abcde" s.empty? s.length s.size	=> false => 5 => 5
"ab".to_sym	=> :ab	String --> Symbol
:ab.to_s	=>"ab"	Symbol--> String
"12".to_i	=> 12	String --> Fixnum
"3.14".to_f	=> 3.14	String --> Float
5.to_s	=> "5"	Float --> String
5.to_s(2)	=> "101"	En base 2
s="abcdefg" s[1]	=> "b"
s[1..3]	=> "bcd"
s["bcd"]="AB" s	=> aABefg	Modification physique
s.index("Be")	=> 2
s="toto" s.gsub("to","ga") s.gsub!("to","ga") s.insert(2,"zo") s.chop s.chop!	=> "gaga" => "gaga" => "gazoga" => "gazog" => "gazog"	Modification physique Modification physique Voir aussi chomp Modification physique
"e".ord	=> 101
101.chr	=> "e"
"ab" <=> "ac"	=> -1	Comparaison lexicographique
"Ab".casecmp("ac")	=> -1	Comparaison lexicographique sans majuscule
s="ab" s.center(10) s.ljust(10) s.rjust(10)	=> " ab " => "ab " => " ab"
s.upcase s.upcase! s.downcase s.downcase!	=> "AB" => "AB" => "ab" => "ab"	Modification physique Modification physique
s="il fait beau" s.split(/ /)	=> ["il", "fait", "beau"]

s="abcdefg"
r =/cd|dc/
s =~ r
r =~ s
s.match(r)
r.match(s)

=> 2
=> 2
=> #<MatchData "cd">
=> #<MatchData "cd">

Expression régulière cd|dc
Conforme à l'expression régulière cd|dc à partir de l'indice 2

s="zakdd"
r =/([ab]+)k([cd]+)/
s =~ r
m=s.match(r)
m[0]
m[1]
m[2]

=> 1
=> #<MatchData "akdd" 1:"a" 2:"dd">
=> "akdd"
=> "a"
=> "dd"

Expression régulière /([ab]+)k([cd]+)/
Conforme à partir de l'indice 1

2. Expression régulière :

Les caractères de contrôles sont + ? . * ^ $ ( ) [ ] { } | \
Pour les utiliser comme simple caractère il faut les précéder d'un backslash.

Modele	Description
^	Début de ligne.
$	Fin de ligne.
.	Un caractère autre que le newline (sauf en mode m).
[abc]	Un caractère a ou b ou c.
[^abc]	Un caractère qui n'est pas ni a ni b ni c.
[a-e2-5]	Un caractère entre a et e ou entre 2 et 5.
X*	0 ou plusieur occurences de X. Non gourmand X*?
X+	1 ou plusieur occurences de X. Non gourmand X+?
X?	0 ou 1 occurence de X. Non gourmand X??
X{n}	Exactement n occurences de X
X{n,}	n ou plus d'occurences de X. Non gourmand {n,}?
X{n,m}	de n à m occurences de ce qui précède. Non gourmand {n,m}?
X\|Y	X ou Y
(X)	Groupé et mémorisé
(?:X)	Groupé et non mémorisé
X(?=Y)	X si suivie de Y

\w	Caractères word [A-Za-z0-9_]
\W	Caractères word [^A-Za-z0-9_]
\s	Espace [ \t\n\r\f]
\S	Non espade [^ \t\r\n\f]
\d	Chiffre [0-9]
\D	Non chiffre [^0-9]
\n,\t...	newline, tabulation, etc.
\1...\9	n ième expression mémorisées
\10	10 ième expression mémorisée si elle existe sinon caractère de code octal 10.

3. Module Enumerable :

A = [5,9,7,2,8] A.all? {\|x\| x<100} A.any? {\|x\| x==4} [false, nil, false].none? A.none?{\|x\| x>10} A.one?{\|x\| x>8} A.one?{\|x\| x>7}	=> true => true => true => true => true => false
A.collect {\|x\| xx} A.collect_concat{\|x\| xx} A.count A.count(4) A.count{\|x\|, x.even?} A.cycle A.cycle(2) A.cycle(2).to_a (3..6).to_a A.drop(3) A.drop_while{\|x\| x>3} A.first(3) A.find {\|x\| x>6} A.find_all{\|x\| x.even?} A.reject{\|x\| x.even?} A.find_index(8) A.find_index{\|x\| x>6} A.include?(7)	=> [25,81,49,1] (alias map) => [25,81,49,1] (alias flat_map) => 6 => 1 => 3 => 5,9,7,2,8,5,9,7,2,8,5,9,7,2,8.... => 5,9,7,2,8,5,9,7,2,8 => [5,9,7,2,8,5,9,7,2,8] => [3,4,5,6] => [2,8] => [2,8] (alias take_while) => [5,9,7] (alias take) => 9 (alias detect) => [2,8] (alias select) => [5,9,7] => 4 => 1 => true (alias member?)	Nombre de fois 4 dans A Nombre de n pair dans A Saute les 3 premières valeurs Saute les premiers x tant que x>3 Les 3 premières valeurs La première valeur satisfaisant x>6 L'index de la valeur 8 L'index du pemier x>6	Enumerator Enumerator Enumerator Enumerator Enumerator Enumerator Enumerator Enumerator Enumerator Enumerator

A.each{\|x\| p(x)} A.each_with_index{\|x,i\| p(x,i)} A.each_with_object([s0]){\|x,s\| p(x,s); s<<x} A.reverse_each{\|x\| p(x)} (1..10).each_cons(3){\|m\| p(m)} (1..10).each_slice(3){\|m\| p(m)} (1..10).each_slice_before{\|x\| x%4==0}	Boucle for x in A (alias each_entry) Boucle for x in A avec l'indice i s= [s0] puis [s0,x0] puis [s0,x0,x1]..... Boucle for x in A.reverse temporaire Boucle for m in [[1,2,3], [2,3,4], [3,4,5]...., [8,9,10]] Boucle for m in [[1,2,3], [4,5,6], [7,8,9]..., [10]] => [[1, 2, 3], [4, 5, 6, 7], [8, 9, 10]]
A = [5,9,7,2,8] A.group_by {\|x\| x%3} [5,2,4,6,1,3].chunk{\|x\| x%3} A.partition {\|x\| x.even?}	=> {2=>[5, 2, 8], 0=>[9], 1=>[7]} => [[2, [5, 2]], [1, [4]], [0, [6]], [1, [1]], [0, [3]]] => [[2, 8], [5, 9, 7]]
A.sort A.sort{\|a,b\| f(a)<=>f(b)} A.max A.max{\|a,b\| f(a)<=>f(b)} A.min A.min{\|a,b\| f(a)<=>f(b)} A.minmax A.minmax{\|a,b\| f(a)<=>f(b)} A.sort_by {\|x\| f(x)} A.max_by{\|x\| f(x)} A.min_by{\|x\| f(x)} A.minmax_by{\|x\| f(x)}	x<=>y vaut 1 si x>y, 0 si x==y, -1 si x<y
A.reduce(:+) A.reduce{\|s,x\| s+x} A.reduce(s0, :+) A.reduce(s0){\|s,x\| s+x} [1,2,3].zip(A,B)	Somme de tous les éléments de A (alias inject) Somme de tous les éléments de A s0 + Somme de tous les éléments de A s0 + Somme de tous les éléments de A égale à [[1,A₁,B₁],[2,A₂,B₂],[3,A₃,B₃]]

4. Classe Array :

L = [ ]
L = Array.new
L = Array.new(3)
L = Array.new(3,7)
L = Array.[](5,2,4)
[1,1,3,5]&[2,3,1]
[1,2,3]*3
[1,2,3]*","
[1, 5] + ["ab", 7]
[1,1,2,2,3,5]-[3,1,4]

L = [12, 3, 5]
L.last
L.join
L.join(", ")
L[0]
L[1]
L.respond_to?("each")
L.sort
L.length
L.reverse
L.pop
L.push(79)
L.include?(12)
L[5]
L[5]="abc"
L
L=[2]
L<< 5 << 7
L<<"ab"
%w{a bb ccc}
[7,2,5].delete(2)
a,b = [2,7,5]
[a,b]

L=[0,1,2,3,4]
L[0,2]=[5,7,7]
L[1,3]="a"
L[0..1]=[9,9,9]
L[0..3]=[8,9]
L[0..2]=[ ]
L[-1]=9
M=[3,4,9]
M.equal?(L)
M.eql?(L)

=> []
=> []
=> [nil, nil, nil]
=> [7, 7, 7]
=> [5,2,4]
=> [1,3]
=> [1,2,3,1,2,3,1,2,3]
=>"1,2,3"
=> [1, 5, "ab", 7]
=> [2,2,5]

=> [12, 3, 5]
=> 5
=> "1235"
=> "12, 3, 5"
=> 12
=> 3
=> true
=> [3, 5, 12]
=> 3
=> [12, 5, 3]
=> 5=> [12,3,79]
=> true
=> nil
=> "abc"
=> [12,3,79,nil,nil,"abc"]
=> [2]
=> [2,5,7]
=> [2,5,7,"ab"]
=> ["a","bb","ccc"]
=> [7,5]
=> [2,7,5]
=> [2,7]

=> [0,1,2,3,4]
=> [5,7,7,3,4]
=> [0,"a",4]
=> [9,9,9,2,3,4]
=> [8,9,4]
=> [3,4]
=> [3,4,9]
=> [3,4,9]
=> false
=>true

Modification physique de la liste L : pop, push,<<

5. Classe Hash

L = { }
L = Hash.new
L = {2=>53, 6=>12}
L[1]
L[2]
L[3]
L[6]
L.sort
L.respond_to?("each")
L.length
L = {:ab=>123}
L["toto"]=5
L
L.delete("toto")
L

=> { }
=> { }
=> {6=>12, 2=>53}
=> nil
=> 5
=> nil
=> 12
=> [[2, 53], [6, 12]]
=> true
=> 2

=> {:ab=>123,"toto"=>5}
=> 5
=> {:ab=>123}

Modification physique

6. Opérations directes

3+5
2**64
11%3
11/3
11.0/2
Math.sqrt(2)
Math::PI
Math::E
x = -3.2
x.abs
5.23.to_s
"5".to_f
"5".to_i
"ab".to_sym
"a".ord
"\n".ord
rand
rand(5)
srand(156)
0xaabb
0b0110

a=[1,2,3]
a = 1,2,3
a,b = [1,2,3]
a,b = 1,2,3
a,b,c = 1,2
a,b = 1
a,(b,c) = 1,2
(a,b),c = 1,2
(a,b),c = [1,2],3

a,b = b,a

=> 8
=> 18446744073709551616
=> 2
=> 3
=> 3.66666666666667
=> 1.4142135623731
=> 3.14159265358979
=> 2.71828182845905
=> -3.2
=> 3.2
=> "5.23"
=> 5.0
=> 5
=> :ab
=> 97
=> 10
=> 0.0377352350499029
=> 2

=> 43707
=> 6

     a=[1,2,3]
     a=[1,2,3]
     a=1 & b=2
     a=1 & b=2
     a=1 & b=2 & c=nil
     a=1 & b=nil
     a=1 & b=2 & c=nil
     a=1 & b=nil & c=2
    a=1 & b=2 & c=3

Permute a et b

Code ASCII
Code ASCII
Nombre au hasard appartenant à [0,1[
Nombre au hasard appartenant à {0, 1, 2, 3, 4}
Fixe la graine des nombres aléatoires.
Nombre hexadécimal
Nombre binaire

Affectation parallèle

Affectation parallèle

7. Redirections et boucles conditionnelles

if cond1 then action1
  elsif cond2 then action2
  else action3
end

(le then peut être remplacé par un passage à la ligne)

if cond1
action1
elsif cond2
action2
else action3
end

unless cond1 then action1 else action2 end

action if cond

action unless cond

action while cond

action until cond

while cond
action
end

begin
action
end while cond

until cond
action
end

begin
action
end untilcond

case x
  when 0..5 then action1
  when 6 then action2
  when 6 : action3
  when cond then action4
  else action5
end

loop do
action
break if cond
end

(5..8).each do |i| action end
(5..8).each { |i| action }
[2,4,7].each { |i| action }
"toto\nlili\nlulu".each { |i| action }

for i in 5..8
  action
  next if cond1
  retry if cond2
end

for i in 5..8; action end
for i in 5..8 do action end
for i in [2,4,7]; action; end
for i in "toto\nlili\nlulu"; action; end

3.times do action end
3.times { action }

--- 26 mai 2013 ---

def f (x=1,y=1)

  return x+y

end

=> nil

Définition d'une fonction f (appelée aussi une méthode f) avec valeur par défauts.

f(2,5)

          f(8)

          f

=> 7 => 9 => 2

Application de la fonction f

def f(*m)

  m

end

=> nil

Définition d'une fonction f (appelée aussi une méthode f)

f(5,2,12)

=>[5,2,12]

Application de la fonction f

class A

  def initialize(x = 3)

    @x = x

  end

  def f(u)

    @x = @x + u

  end

  attr_accessor:x

  attr_reader:y

end

=> nil

Définition d'une classe avec le constructeur initialise et deux variables x, y. y en lecture seul.

Dans la classe A, @x et @y désigne les variables d'instances.

a = A.new(23)

            a.y="toto"

            a
            
            a.inspect

            a.f(5)

            a1.respond_to?("f")

=> #<A:0xb7c3433c @x=23>7 => "toto" => #<A:0xb7c3433c @y=\"toto\", @x=23> => "#<A:0xb7c3433c @y=\"toto\", @x=23>" => 28 => true

Création d'un objet de classe A

A.instance_methods(false)
 
          A.methods

          A.private_methods.sort

=> ["f", "y", "x", "y=", "x="]!!!!!! =>!!!!!!!!!!!!!!! à revoir !!!!!!!!!!

Non hérités

#!/usr/bin/env ruby

x=0

            while x<3

  puts x

  x=x+1

end

0 1 2 => nil

Boucle while
Ctrl-C poiur arréter une boucle sans fin.

[5,2,7].each do |x|

  puts x

end

      

      

      [5,2,7].each {|x| print x}

5 2 7 => nil 527=> [5,2,7]

Boucle each avec un Array

(5..8).each do |x|

  print x

      end

      (5..8).each {|x| print x}

5678=> 5..8 5678=> 5..8

Boucle each avec un Range

h={:ab=>3,:u=>7} h.each do |x,y| print(x,"->",y,"\n") endh.each {|x,y| print(x,"->",y,"\n")}

ab->3 u->7 => h={:ab=>3,:u=>7} ab->3 u->7 => h={:ab=>3,:u=>7}

Boucle each avec un Hash

3.times do |x|

  puts x

      end

      

      

      

      3.times {|x|, print x}

0 1 2 => nil 012=> 3

Boucle times

Time.new

            Time.new.to_i

            Time.mktime(2010,1,18)
            Time.mktime(2010,1,18,15,25,7)

            Time.now.to_f

=> Sun Jan 17 15:35:07 +0100 2010 => 1263738859 => Mon Jan 18 00:00:00 +0100 2010 => Mon Jan 18 15:25:07 +0100 2010 => => 1263745985.9808

Temps

class Integer 

  def o(x)

    self*x

  end

end

=> nil

Extention de la classe des Integer avec la méthode oDans une classe A, self désigne l'objet solicité par la méthode.

5.o(3)

=> 15

Création d'un objet de classe A

Atoto $x @x @@x :x "x" false true

x = if 5>2 12 end x=if 5>2 then 12 end x.object_id

Constante Variable globale Variable d'instance Variable de classe Symbole Chaine nil ou false Tout sauf nil et false. => 12 => 12=> 25

class A attr_accessor :x end A = Class.new do attr_accessor :x end class A attr_accessor :y def f nom "toto" end end a=A.new a.f def a.f "titi" enddef method_missing(id, *arguments ) puts "ERR #{id}(#{arguments.join(",")})" end5 + 3 5.+(3) 5.send("+", 3)

=> nil => A => nil => #<A:0xb7c26d18> => "toto"=> "titi" => nil => 8 => 8 => 8

Méthode singleton

Redirection d'erreur

attr_reader :v ≡ def v; @v; end attr_writer :v ≡ def v=(x); @v=x; end attr_accessor :v ≡ attr_reader :v; attr_writer :v attr_accessor :v, :w ≡ attr_accessor :v; attr_accessor :w

def f(x) if block_given? yield(x,x*x) else x end end f(5){|x,y| x+y} f(5) do |x| x*x end def g(x,&y) if y y.call(x) else x end end g(5){|x| s=x*x; s*s} def f(&x) xend b = f do |x,y| x+y end b.call(12,46)c = f {|x,y| x+y} c.call(12,46) b = Proc.new do |x,y| x+y end b = Proc.new {|x,y| x+y} def m yield 7 yield 5 yield 2 end m { |x| $M[x]=true }

=> nil => 25 => 25 => nil => 625 => nil => #<Proc:0xb7c7fd3c@(irb):7> => 58 => #<Proc:0xb7c60ae0@(irb):17> => 58 => #<Proc:0xb7d02854@(irb):42> => #<Proc:0xb7cf328c@(irb):53>

f = Proc.new do |x,y|

  x+y

            end

=> #<Proc:0xb7d02854@(irb):42>

fonction

f.call(5,3)

=> 8

Execution de la fonction

def mm(x,&u)

  u.call(x)

            end

=> nil

fonction

mm(5) do |y|y*y end mm(5) {|y| y*y}

=> 25 => 25

Execution de la fonction

method(:puts).call("ab")

ab => nil

Les methodes sont aussi des objets

12.class 2000000000.class 12.0.class "toto".class :abc.class method(:puts).class [1,2].class {2=>5,7=>1}.class (5..8).class b = Proc.new {|x,y| x+y} b.class a = A.new a.class A.class Float.class Class.class nil.class false.class true.class

=> Fixnum => Bignum => Float => String => Symbol => Method => Array => Hash => Range => #<Proc:0xb7ce8d64@(irb):40> => Proc => #<A:0xb7ce2194> => A => Class=> Class => Class => NilClass => FalseClass => TrueClass

class A def +(x) self*x end end

=> nil

Les opérateurs peuvent être définie +, *, [], []=, -@, +@, ... à l'exception des opérateurs suivants : =, .., ..., !, not, &&, and, ||, or, !=, !~, :: et des raccourcis suivants : +=, *=, etc.

defined? x => nil
defined? 56 => "expression"
defined? y => "local_variable"
defined? puts => "method"

x.eql?(y) => true si x et y sont de même type

x.equal?(y) => true si x et y sont le même objet

x == y => true si x est égale en valeur à y

x <=> y => 1, 0 ou -1 selon que x est plus grand, égale, ou plus petit que y

de même pour < <= > =>

not, !, and, &&, or, ||,

class A def A.u return 123 end def self.v return 124 end class << self def w return 125 end end end A.u A.v A.w class B @@n = 0 def initialize @@n += 1 end def n return @@n end end

=> nil => 123 => 124 => 125

Méthodes singletons appelable de la class A :
u, v, w

Variable de classe

class A def initialize(x); @x=x; end end class B<A def initialize(x,y) super(x) @y=y end end

= nil => nil

super désigne le constructeur de la classe mère.

f = File.new("/root/f.txt","w") f<<"toto" f.close

=> #<File:/root/f.txt> => #<File:/root/f.txt> => nil

Ecrire dans un fichier texte.

`pwd` x="rep" `mkdir #{x}` c = IO.popen("ls") c.readlines system("ls") exec("ls")

=> "/root\n" => rep => "" => #<IO:0xb7cbfa04> => ["f.txt\n", "rep\n"] f.txt rep => true f.txt rep

Executer une commande Linux avec paramètres x

Execute une commande et quite ruby

t1 = Thread.new { loop do i=i+1 end }

t1.terminate

=> #<Thread:0x5b37860 run> => #<Thread:0x5b37860 dead>

Oject --|--> Module ----> Class
        |--> IO ----> File
        |--> String
        |--> Array
        |--> Hash
        |--> Regexp
        |--> Numeric --|--> Integer --|--> Fixnum
                       |              |--> Bignum
                       |--> Float
Range
Symbol

Priorité des opérateurs :
[] []=    			Référence, Assignation
**  					Exponantiation
! ~ + -				Non, Complement, Plus unaire (+@), Moins unaire (-@)
* / %					Multiplication, Division, Modulo
+ -					Plus, Moins
>> <<					Shift droit, Shift gauche
&						Et (entre deux entiers)
^|					Ou exclusif (entre deux entiers), Ou (entre deux entiers)
<= < > >= 			Plus petit ou égale, Plus petit, Plus grand, Plus grand ou égale
<=> == === != =~ ~! 

&&					Et
||					Ou
.. ...				Range inclusive, Range exclusive

?:					If-then-else
= %= /= += |= &= >>= <<= *= &&= ||= **= Assignement
defined?				If défined
not					Non
or and				Ou,Et
if unless while until	Modificateur
Begin/end				Bloque




$0  					Nom du fichier de script Ruby qui s'éxecute
$$					Numéro du processus Ruby qui s'éxecute

Les portées locales :
   1- L'entête du programme
   2- Chaque classe et module
   3- Chaque methode



Float::DIG    => 15
Float::MAX    => 1.79769313486232e+308

alias  methodNew  methodOlD

a.sort       pas de modification physique 
a.upcase
a.chomp
a.reverse

a.sort!       modification physique 
a.upcase!
a.chomp!
a.reverse!

STDOUT
STDOUT.flush 
exit
nil
NIL
TRUE
FALSE
nil.object_id   => 4

Trois suffixes spéciaux autorisés pour les méthodes : "?", "!", "="

ENV.each {|k,v| puts "#{k}: #{v}"}    texte seulement

ENV["toto"] = "456"     Le changement ne sera visible que pour le processus et fils.
ARGV    tableau des variables transmises en lign de commande.

Symbol.all_symbols

module

include B,C

class A
module B
end
end

A::B

Marshal.dump(x,f) serialization
x = Marshal.load(f)

Le langage Ruby Aperçu

1. String

2. Expression régulière :

3. Module Enumerable :

4. Classe Array :

5. Classe Hash

6. Opérations directes

7. Redirections et boucles conditionnelles

Le langage Ruby
Aperçu