Symboles en

À propos de Symboles

Les symboles sont des identifiants nommés qui permettent de faire référence à une valeur. Un symbole est créé à partir d'un littéral de symbole, qui consiste à préfixer un nom avec le caractère :, par exemple :foo. On peut aussi les écrire entre guillemets, par exemple :"foo", ce qui permet par exemple d'avoir des espaces dans le nom.

:foo # => :foo
:"foo boo" # => :"foo boo"

Les symboles sont utilisés à de nombreux endroits dans le langage, notamment comme clés dans les hash, pour représenter des noms de méthodes et de variables.

Identifiant

Ce qui distingue les symboles des strings, c'est qu'il s'agit d'identifiants, et qu'ils ne représentent ni des données ni du texte. Cela signifie que deux symboles portant le même nom sont toujours le même objet.

"foo".object_id # => 60
"foo".object_id # => 80
:foo.object_id # => 1086748
:foo.object_id # => 1086748

Modifie les symboles

Les symboles sont immuables, ce qui signifie qu'on ne peut pas les modifier. Ainsi, quand on « modifie » un symbole, on crée en réalité un nouveau symbole. Il existe quelques méthodes pour manipuler les symboles ; elles renvoient toutes un nouveau symbole. Toutes ces méthodes sont documentées dans l'API Symbol.

:foo.upcase # => :FOO

:foo.object_id # => 1086748
:foo.upcase.object_id # => 60

L'avantage de l'immuabilité des symboles est qu'ils consomment moins de mémoire que les strings, mais qu'ils sont aussi plus sûrs à utiliser comme identifiants.

Conversion

On peut convertir des symboles en strings et inversement. Cela peut être utile lorsqu'on veut modifier un symbole, ou l'utiliser comme string. Pour transformer une string en symbole, on peut utiliser la méthode String#to_sym, et pour faire l'inverse, la méthode Symbol#to_s. Comme les symboles ne disposent que d'un ensemble limité de méthodes, il peut être utile de convertir un symbole en string pour lui appliquer des méthodes de string, si l'on a besoin d'un nouveau symbole.

:foo.to_s # => "foo"
"foo".to_sym # => :foo

Récupère les noms dans les portées

En Ruby, on peut récupérer les noms présents dans les portées à l'aide de diverses méthodes qui donnent les noms des constantes, des méthodes et des variables. Ces méthodes renvoient des tableaux de symboles.

Citons par exemple Module#constants, Module#instance_methods, Module#class_variables, global_variables et local_variables.

module Foo
  BAR = 1
  def self.baz; end
end

a = 1

Foo.constants # => [:BAR]
Foo.instance_methods # => [:baz]

local_variables # => [:a]

Toutes ces méthodes sont documentées dans l'API Kernel et l'API Module.