Símbolos en

Acerca de Símbolos

Los símbolos son identificadores con nombre que se pueden usar para referirse a un valor. Los símbolos se crean mediante un literal de símbolo, que consiste en anteponer un carácter : a un nombre, por ejemplo, :foo. También se pueden escribir entre comillas, por ejemplo, :"foo", lo que permite, por ejemplo, espacios en el nombre.

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

Los símbolos se usan en muchos lugares del lenguaje, por ejemplo, como claves en los hashes, para representar nombres de métodos y nombres de variables.

Identificador

Lo que hace diferentes a los símbolos de los strings es que son identificadores, y no representan datos ni texto. Esto significa que dos símbolos con el mismo nombre son siempre el mismo objeto.

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

Modificar símbolos

Los símbolos son inmutables, lo que significa que no se pueden modificar. Esto significa que cuando «modificas» un símbolo, en realidad estás creando un símbolo nuevo. Hay algunos métodos que se pueden usar para manipular símbolos, y todos ellos devuelven símbolos nuevos. Todos los métodos se pueden encontrar en la API de Symbol.

:foo.upcase # => :FOO

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

La ventaja de que los símbolos sean inmutables es que son más eficientes en memoria que los strings, pero también más seguros de usar como identificadores.

Conversión

Los símbolos se pueden convertir en strings y viceversa. Esto puede ser útil cuando quieres modificar un símbolo, o cuando quieres usar un símbolo como un string. Para presentar un string como un símbolo, puedes usar el método String#to_sym, y para hacer lo contrario, puedes usar el método Symbol#to_s. Debido a que los símbolos tienen un conjunto limitado de métodos, puede ser útil convertir un símbolo en un string para usar métodos de string sobre él, si se necesita un símbolo nuevo.

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

Obtener nombres en los scopes

En Ruby puedes obtener nombres en los scopes usando varios métodos para obtener nombres de constantes, métodos y variables. Estos métodos devuelven arrays de símbolos.

Algunos métodos son Module#constants, Module#instance_methods, Module#class_variables, global_variables y local_variables.

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

a = 1

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

local_variables # => [:a]

Todos los métodos se pueden encontrar en la API de Kernel y la API de Module.