Sintaxis

R: Una variable precedida por un carácter de dos puntos genera un entero (Fixnum) denominado símbolo que tiene una correspondencia uno a uno con un identificador. "var".intern genera el mismo entero que :var, pero la formula de los dos puntos genera un símbolo local si no existía previamente.

Las rutinas "catch", "throw" y "autoload" y otras requieren como parámetro una cadena o un símbolo.

"method_missing", "method_added" y "singleton_method_added" (y otros) también utilizan símbolos.

El hecho de que los símbolos empiezan a existir la primera vez que se les referencia es utilizado para asignar valores únicos a constantes.

	    
	    NORTH = :NORTH
	    SOUTH = :SOUTH
	    EAST  = :EAST
	    WEST  = :WEST
	  

R: Para obtener el valor de una variable a través de un símbolo, se puede utilizar id2name para acceder al nombre y eval para acceder a su contenido. En el ámbito del símbolo hay que hacer eval(:symbol.id2name)

	    
	    a = 'Este es el contenido de "a"'
	    b = eval(:a.id2name)
	    a.id = b.id  # b ahora referencia al mismo objeto que a
	  

Si el símbolo corresponde al nombre de un método, se puede utilizar la función Method.method para devolver el correspondiente objeto Method, con el cual se puede realizar invocaciones.

	    
	    class Demo
	      def meth
	        "Hello, world"
	      end
	    end

	    d = Demo.new        #-> #Demo:0x4018d554
	    m = d.method(:meth) #-> #Method: Demo(Demo) #meth
	    m.call              #-> "Hello, world"
	  

R: Aunque loop parece una estructura de control en realidad es un método definido en Kernel. El bloque que define introduce un nuevo ámbito para las variables locales.

R: Ruby no tiene una onstrucción del tipo do { ... } while, entonces, cómo se pueden contruir bucles que chequeen la condición al final.

Clemens Hintze escribe: Se puede utilizar begin ... end junto con las sentencias while y until utilizadas como modificadores para obtener el mismo efecto:

	    
	    i = 0
	    begin
	      puts "i = #{i}"
	      i += 1
	    end until i > 4
	  

	    i = 0
	    i = 1
	    i = 2
	    i = 3
	    i = 4
	  

R: Ruby trata de distinguir las llamadas a los métodos de los nombres de los operadores y los nombres de variables de los métodos. Desafortunadamente, no siempre acierta. En este caso, "a +b" lo interpreta como "a(+b)". Si se quita el espacio antes del signo "+" o se añade un espacio a la derecha del "+", se interpretará como un adición.

R: Aquí, de nuevo, Ruby ve un espacio asimétrico e interpreta el puts como puts(s(*10)) (lo cual, verdaderamente, no es muy inteligente). Si se usa "s*10" o "s * 10" se obtendrá el resultado deseado.

R: {} se interpreta como un bloque no como el constructor de un Hash. Se puede forzar a que {} se interprete como una espresión resaltando el hecho de que se trata de un parámetro explícito: p ({}).

R: Se tiene el siguiente código y ni funciona el método pos = 1.

	    def pos (val)
	      print @pos, "\n"
	      @pos = val
	    end
	  

R: Tienen el mismo significado. Es una cadena entre comillas simples, sólo que / Y // se tranforman y otras combinaciones, no.

Sin embargo, en una cadena entre comillas dobles, "\1" es el byte \001, mientras que "\\1" es una cadena de dos caracteres que contiene \ y el carácter 1.

R: "p(nil || "hello")" imprime "hello" mientras que "p(nul or "hello"" da un error al analizar.

|| combina términos es una expresión. Debido a que el primer término en este caso es nil, se evalúa el segundo. or se utiliza para combinar expresiones dentro de condiciones. Ruby no espera una sentencia condicional dentro de una lista de argumentos.