• Cours : Ruby Learning, apprentissage (Anglais)
• Ruby essentials (Anglais)
• Rubyist, technique (Anglais)
• Interprêteur Ruby en ligne

• La principale est celle du créateur :
Matz's Ruby Interpreter (MRI)
Les versions actuelles : V1.8.X, V1.9.X
• Ruby Enterprise Edition (REE)
• Rubinius (Rbx)
• Il existe une version java :
JRuby

2.1) Syntaxe des fichiers :

2.2) Inclusions :

require <fichier>.rb

2.3) Test d'instructions :

• Instructions à la volée (One liner) :
Commande :

ruby -n -e <fichier>.rb

Récupération de la ligne courante (saisie à l'entrée standard) dans la variable globale :
$_


• Récupération d'objet / paramètre à la volée :

<Instruction retournant un objet>
@o = _ #==> @o est affecté avec l'objet retourné par la dernière instruction



• Vérification de la syntaxe :

ruby -cw <fichier>.rb

3.1) La dernière action d'un bloc renvoie sa valeur :

un = deux = trois = ""

3.2) Tests :

• If :
Le end est toujours nécessaire;
Le then ou le ; ou le : est nécessaire si l'instruction est sur une seule ligne :

if <cond°> then <inst°> end

if <cond°> : <inst°> end

if <cond°> ; <inst°> end




if <cond°>
	<inst°s>
	...
end

if <cond°>
	<inst°s>
	...
elsif
	<inst°s autre cas>
	...
else
	<inst°s aucun des cas précédents>
	...
end

• Assertions :

if <false>

=> nil ou false


if (0) then puts '0 => true' else puts '0 => false' end

0 => true


:nom == :nom

=> true

"nom" == "nom"

=> true

3.3) Sélection de cas (case):

case x
	when 1
		<inst°s>
		...
	when n
		<inst°s>
		...
end

3.4) Boucle for :

(1..10).each do |i|
	puts i
end

3.5) Boucle loop :

loop do
	break if <cond°>
end

3.6) Boucle while :

while <cond°>
	...
end

begin
	...
end while <cond°>

f=2
puts f=f+2 while f < 10

3.7) Exceptions :

begin
	...
rescue ZeroDivisionError
	...
	exit
rescue IOError
	...
	exit
rescue TypeError
	#Ruby n'est pas typé, mais possible (paramètres de méthode)
	...
	exit
rescue
	#Toutes les autres
	puts "Exception survenue: #{$!}"
	...
	exit
ensure
	#Toujours executé
end

begin
	...
rescue exception
	#Toutes
	puts "erreur : #{exception.message}"
end

def factorial(n)
	if n == 0
		1
	else
		n * factorial(n-1)
	end
end

numbers = [1,2,3]

begin
	puts factorial(numbers)
rescue TypeError
	puts "une erreur de type est arrivée : #{$!}"
end


puts(numbers.map { |n| factorial(n) })

4.1) Chaînes :

• dans les chaines à cote simple, \ et " n'ont pas besoin d'être échappés
Rien à échapper sauf : '.


• Passage continu à la ligne avec le caractère : \


• Répétition :

"Salut" * 3

=> "SalutSalutSalut"

4.2) Caractères :

• Code ASCII du charactère :

?a #Ruby 1.8
.getbyte(0) #Ruby 1.9

4.3) Encodage :

latin1_resume = "Résumé"
transcoded_utf8_resume = latin1_resume.encode("UTF-8")

# now correctly changed to UTF-8
puts transcoded_utf8_resume.encoding.name # ==> UTF-8
puts transcoded_utf8_resume.bytesize # ==> 8
puts transcoded_utf8_resume.valid_encoding? # ==> true

4.4) Formats de date et d'heure :

<objet_time>.strftime(<string>) #=> <tring>

• Ubiquité :
• Toute donnée est un objet.
• Toute fonction est une méthode.
• Toute fonction est un message :
• send
• call
• start('<nom de fonction>')


• Passage des paramètres :
Les Variables / Objets sont passés par référence de façon systématique.


• Spécificateur de portée :
C'est le premier caractère du le nom de la variable (préfixe), il doit être utilisé à la déclaration et ensuite à l'utilisation.
Voici leur liste, classés par portée croissante :

$	Variable Globale à l'application.
@@	Variable de Classe.
@	Variable d'Instance.
[a-z] ou _	Variable locale.
[A-Z]	Constante.


Un petit schéma explicatif :


Un exemple un peu trompeur (une variable nommée comme instance mais pour une classe):



class DesY
	@y = 1

	def y=(p_y)
		@y = p_y
	end

	def y
		@y
	end

	def self.get_y
		@y
	end

	def self.set_y(p_y)
		@y = p_y
	end
end

dy1 = DesY.new
dy1.y = 2
puts 'dy1.y: ' + dy1.y.to_s

dy2 = DesY.new
dy2.y = 3
puts 'dy2.y: ' + dy2.y.to_s

puts "Il existe deux types de variables @y: une pour les instances (#{dy1.y}, #{dy2.y}) et une pour la classe (#{DesY.get_y})"

DesY.set_y(4)
puts 'Input.get_y: ' + DesY.get_y.to_s

• Classes :
• Détermination de la classe d'un objet :

<objet>.class

#=> son type (le nom de sa classe)

Exemple :

[].class

#=>> Array


• Parents :

<objet>.class.superclass
# => son parent (toujours unique).


Exemple avec Irb :

irb(main):001:0> un = 1
=> 1

irb(main):006:0> un.class.superclass
=> Integer

irb(main):007:0> un.class.superclass.superclass
=> Numeric

irb(main):008:0> un.class.superclass.superclass.superclass
=> Object

irb(main):009:0> un.class.superclass.superclass.superclass.superclass
=> nil


Lister tous les ancêtres d'une classe : parent et parents de parents, etc. (Mixins inclus) :

<objet>.class.ancestors

#ex:
1.class.ancestors
=> [Fixnum, Integer, Precision, Numeric, Comparable, Object, Kernel]



• Constructeur / Destructeur :
• Constructeur :

def initialize(*params)
	...
	super(*params)
end

• Destructeur :

def finalize
	...
end

• Constructeur de classe :

def self.initialize
	...
end

• Type de (is_as?) :

<objet>.is_a?(<type>)

Exemple :

{}.is_a?(Hash)

#=> true



• Objets :
• Adresse en mémoire :

.object_id #Rails 3

.id #Rails 2

.__id__

• Existence :

defined?

Exemple :

if defined? @@c_nombre


Apporté par ROR :

blank?

Et son contraire :

present?



• Méthodes :
Les méthodes peuvent être des méthodes d'objet ou de classe.
• Vérification de l'existence d'une méthode (respond_to?) :
On peut utiliser la méthode respond_to? pour vérifier qu'une méthode existe :

if (photo.respond_to?(:commentaire) && !photo.commentaire.blank? )



• Liste des Méthodes :

<objet>.methods

Les méthodes de l'objet sont retournées dans un Tableau (Array).
Pour les avoir dans l'ordre :


.sort


Publiques :

<variable>.public_methods



• Modules et héritage :
À la différence de bien d’autres langages orientés objet, Ruby ne donne accès qu’à l’héritage unique, et ce, volontairement.
En effet, Ruby supporte par ailleurs le concept de Modules. Ces Modules sont des regroupements de méthodes.

Les classes peuvent « incorporer » un module (opération dite de mixin) afin d’en recevoir toutes les méthodes, sans plus de travail.
Par exemple :
Toute classe implémentant une méthode each peut ensuite incorporer le module Enumerable, lequel fournit gratuitement plusieurs méthodes utilisant each pour faire des boucles.


class MonTableau
	include Enumerable

	def each
		...
	end
end

• Symboles :
Liste :

Symbol.all_symbols


Conversions :

<symbole>.to_s
#=> <String>

<string>.to_sym
#=> <Symbole>



• Mots-clé
Ne jamais mettre en mot-clé :

action



• Closures (Blocs) :
When a proc or lambda is created the variables in local scope are bound and not copied.

6.1) Méthodes :

6.2) Opérateurs :

7.1) Tableaux :

7.2) Hash :

.each_key
.each_value
.each do |key, value|
.invert #(clés <==> valeurs)

api jruby1.2
gem install activerecord-jdbc-adapter

jruby -e 'p $:'