Ruby

Syntaxe

Variables

Ruby propose cinq catégories de variables :


	variable_locale 
	$variable_globale 
	@variable_d_instance 
	@@variable_de_classe 
	Constante

Une variable locale débute obligatoirement par un caractère minuscule (a-z) ou un '_'. La portée de ce type de variable se limite à un bloc de code (qui peut éventuellement être une mé thode).

Le premier caractère d'une variable globale est un '$'. Ce type de variable est accessible de n'importe où au sein d'un même script.

Une variable d'instance débute par un arobase (@). Ces variables sont propres à un objet.

Les variables de classes sont préfixées par un double arobase (@@).

Le dernier type de variable est particulier puisqu'il s'agit des constantes. Celles-ci débutent nécessairement par une majuscule (A-Z). En Ruby, il est possible d'affecter une nouvelle valeur à une constante après son initialisation. Cependant, un message d'avertissement sera émis mais la constante sera tout de même modifiée.


De plus, Ruby ajoute à ces cinq types de variables trois "pseudo-variables" :


	self
	true / false
	nil

self représente l'objet courant. On peut donc le comparer au mot-clé this que l'on retrouve dans les langages orientés traditionnels comme le C++ ou Java.

true et false sont utilisés pour représenter les deux valeurs booléennes possibles.

Enfin, nil représente une valeur indéfinie. Dans de nombreux autres langages, cette valeur peut être comparée à null.
Toutes les variables précédemment décrites (excepté les variables de classes) sont par défaut initialisées à nil.
A noter que, dans une structure conditionnelle, nil est évalué comme la valeur booléenne false.


Tableaux

Pour mieux comprendre le fonctionnement des tableaux, voici quelques exemples regroupant les fonctions principales disponibles en Ruby :


	# Affectation d'une liste de valeurs
	tab = [1,2,"a","b"]
	
	# Initialisation d'un tableau à partir de valeurs d'un autre tableau
	tab2 = [0,tab]			# => [0,1,2,"a","b"]

	
	# Accès à l'antépénultième valeur d'un tableau
	tab[-2]				# => ["a"]
	
	# Accès à une coupe d'un tableau
	tab[-3..-1]			# => [2,"a","b"]
	
	# Extraction de la dernière valeur
	tab.pop				# => "b"
	
	# Insertion d'un valeur en fin de tableau
	tab.push("c")			# tab = [1,2,"a","c"]
	
	# Extraction de la première valeur
	tab.shift			# => 1
	
	# Insertion de valeurs en début de tableau
	tab.unshift(-1,0)		# tab = [-1,0,2,"a","c"]
	
	# Regroupe toutes les valeurs d'un tableau dans une chaîne de caractères avec le sépérateur spécifié
	print tab.join(" ")		# Affiche : "-1 0 2 a c"
	
	# Suppression des doublons
	tab = tab.uniq			
	
	# Retourne le nombre d'élé contenus dans un tableau
	print tab.length		# Affiche : 5
	
	# Suppresion d'un élément en fonction d'une condition
	tab.delete_if { |e| e%2 == 0 } 	# Supprime les nombres pairs
	
	# Suppression de toutes les valeurs d'un tableau
	tab.clear			# Vide le tableau

Tables de hachage

De même que pour les tableaux, voici les fonctions principales disponibles pour les tables de hachage en Ruby :


	# Affectation
	h = { "a" => 100, "b" => 200 }

	# Vérification de la présence d'une clé
	h.has_key?("a")						# => true
	
	# Vérification de la présence d'une valeur
	h.has_value?(100)					# => true
	
	# Parcours de chaque couple clé-valeur
	h.each {|key, value| puts "#{key} : #{value}" }		# => a : 100
								# => b : 200
	
	# Retourne l'ensemble des clés sous forme de tableau
	h.keys							# => ["a","b"]
	
	# Retourne l'ensemble des valeurs sous forme de tableau
	h.values						# => [100,200]
	
	# Retourne une table de hachage sous forme d'une liste de tableaux contenant chacun un couple clé-valeur
	h.to_a							# => [["a", 100], ["b", 200]]
	
	# Supprime l'ensemble des couples clés-valeurs d'une table de hachage
	h.clear							# Vide la table