Structure de donnees (Ruby)

Fiche express
Sujet	Structures de données Ruby
Types	tableaux, ranges, hachages
Console	Irb / Console (Rails)
Voir aussi	Chaine de caracteres (Ruby)

Principales structures de données de Ruby : tableaux, ranges, blocs, tables de hachage et symboles, ainsi que les classes et l'héritage. Exemples à tester dans Irb ou la Console (Rails) (invite >>).

Tableaux

"foo bar     baz".split
"fooxbarxbazx".split('x')

a = [42, 8, 17]
a[0]
a[-1]
a.first
a.last == a[-1]
x = a.length

# Tri
a.sort
a.reverse
a.shuffle

# Ajout d'entrées (types hétérogènes possibles)
a << 7
a << "foo" << "bar"
a.join
a.join(', ')

Ranges

0..9
(0..9).to_a

a = %w[foo bar baz quux]   # %w crée un tableau de chaines
a[0..2]

('a'..'e').to_a

Blocs

(1..5).each { |i| puts 2 * i }
# |i| est la syntaxe Ruby pour une variable de bloc

(1..5).each do |i|
  puts 2 * i
end

3.times { puts "Betelgeuse!" }   # bloc sans variable

(1..5).map { |i| i**2 }          # ** = puissance
%w[a b c].map { |char| char.upcase }

('a'..'z').to_a.shuffle[0..7].join

Tables de hachage et symboles

user = {}                        # table de hachage vide
user["first_name"] = "Michael"
user["last_name"]  = "Hartl"
user["first_name"]
user                             # => {"last_name"=>"Hartl", "first_name"=>"Michael"}

Les tables de hachage ne garantissent pas l'ordre des éléments (utiliser un tableau si l'ordre importe).

user = { "first_name" => "Michael", "last_name" => "Hartl" }

# Symboles comme clés
personne = { :nom => "Michael Hartl", :email => "michael@example.com" }
personne[:nom]
personne[:password]   # clé indéfinie => nil

Tables imbriquées

params = {}
params[:user] = { :nom => "Michael Hartl", :email => "mhartl@example.com" }
params[:user][:email]   # => "mhartl@example.com"

flash = { :success => "Ça marche !", :error => "Raté… :-(" }
flash.each do |key, value|
  puts "La clé #{key.inspect} a la valeur #{value.inspect}"
end

Parenthèses et accolades optionnelles

# Parenthèses optionnelles à l'appel
stylesheet_link_tag('blueprint/screen', :media => 'screen')
stylesheet_link_tag 'blueprint/screen', :media => 'screen'

# Accolades optionnelles sur le dernier argument (hash)
stylesheet_link_tag 'blueprint/screen', { :media => 'screen' }
stylesheet_link_tag 'blueprint/screen', :media => 'screen'

Classes et héritage

# Constructeurs nommés
s = String.new("foobar")
s.class
s == "foobar"

a = Array.new([1, 3, 2])   # valeur initiale nécessaire
h = Hash.new               # le hash n'en prend pas
h[:foo]                    # => nil
h = Hash.new(0)            # clés inexistantes => 0
h[:foo]                    # => 0

# Héritage
s.class                    # String
s.class.superclass
s.class.superclass.superclass   # Ruby 1.9 -> BasicObject

Définir puis modifier une classe :

class Mot
  def palindrome?(string)
    string == string.reverse
  end
end

w = Mot.new
w.palindrome?("foobar")

# Rouvrir la classe String pour lui ajouter une méthode
class String
  # Retourne vrai si la chaine est son propre inverse
  def palindrome?
    self == self.reverse
  end
end

"kayak".palindrome?   # => true

Exemple de classe complète :

class User
  attr_accessor :nom, :email   # génère les getters et setters

  def initialize(attributes = {})   # appelé lors de User.new
    @nom   = attributes[:nom]
    @email = attributes[:email]
  end

  def formatted_email
    "#{@nom} <#{@email}>"
  end
end

require './example_user'

Voir aussi

• Chaine de caracteres (Ruby)
• Ruby base2
• MVC (Rails) — les modèles ActiveRecord
• Irb