Ruby: Creando clases y objetos

Luego de tener idea básica del lenguaje y definición de métodos, veamos la creación de clases y objetos.

class Anfitrion
    def initialize(nombre=”Mundo”)
        @nombre = nombre
    end

    def decir_hola
        puts “Hola #{@nombre)“
    end

    def decir_adios
        puts “Adios #{@nombre}“
    end

De esa forma tenemos una clase anfitrión con dos métodos (decir_hola, decir_adios). Además se tiene una variable de instancia (@nombre) disponible durante la vida del objeto. Para crear el objeto:

A = Anfitrion.new(“Bernardo“).
A.decir_hola => “Hola Bernardo“
A.decir_adios => “Adios Bernardo“

Una aspecto interesante es que no podemos acceder a la variable de instancia como sí se puede en otros lenguajes. La expresión A.@nombre no es válida.

Anfitrion.instance_methods devuelve todos los métodos de instancia que se pueden invocar. Eso retorna todos los métodos disponibles de la clase Anfitrion y sus superclases. Si quisiéramos solamente los métodos que se definieron en la clase anfitrión y nada más, entonces bastará con poner:

Anfitrion.instance_methods(false)

En este caso se retornará

 => “[decir_hola, decir_adios]“

Existe otra funcionalidad interesante que es la de respond_to?. Escribimos

 Anfitrion.respond_to?(“nombre“)

y retornará false. Sin embargo si escribimos Anfitrion.respond_to?(“decir_hola“) retornará true. Si el objeto es capaz de responder a esos métodos entonces retorna true.

Para poder acceder y modificar los valores de las variables de clase, es necesario poner attr_accessor: nombres.
De esa forma podemos acceder como a.nombre, donde a es el objeto instanciado de la clase Anfitrion.

Ejemplo....

class MegaAnfitrion
  attr_accessor :nombres

  # Crear el objeto
  def initialize(nombres = "Mundo")
    @nombres = nombres
  end

  # Decirle hola a todos
  def decir_hola
    if @nombres.nil?
      puts "..."
    elsif @nombres.respond_to?("each")

      # @nombres es una lista de algún tipo,
      # ¡así que podemos iterar!
      @nombres.each do |nombre|
        puts "Hola #{nombre}"
      end
    else
      puts "Hola #{@nombres}"
    end
  end

  # Decirle adiós a todos
  def decir_adios
    if @nombres.nil?
      puts "..."
    elsif @nombres.respond_to?("join")
      # Juntar los elementos de la lista
      # usando la coma como separador
      puts "Adiós #{@nombres.join(", ")}. Vuelvan pronto."
    else
      puts "Adiós #{@nombres}. Vuelve pronto."
    end
  end

end

if __FILE__ == $0
  ma = MegaAnfitrion.new
  ma.decir_hola
  ma.decir_adios

  # Cambiar el nombre a "Diego"
  ma.nombres = "Diego"
  ma.decir_hola
  ma.decir_adios

  # Cambiar el nombre a un vector de nombres
  ma.nombres = ["Alberto", "Beatriz", "Carlos",
    "David", "Ernesto"]
  ma.decir_hola
  ma.decir_adios

  # Cambiarlo a nil
  ma.nombres = nil
  ma.decir_hola
  ma.decir_adios
end

Y hasta aquí llegué con Ruby. En cuanto profundice en él iré actualizando los posts. Saludos!

Ruby: Definiendo métodos

La sintáxis de definición de un método es similar a la sintaxis de python:

def saludador
    puts “Hola mundo“
end

“def“ es la definición del método llamado saludador. La palabra “end“ al final indica el fin del método.

La invocación del método requiere que solamente se escriba el nombre del mismo, en este caso saludador. También puede ser invocado como saludador(). En este caso tendrán el mismo comportamiento. Sin embargo este caso es un tanto particular, ya que no se pasan parámetros al método. En caso de tener parámetros se deberían pasar entre medio de los paréntesis, por ejemplo saludador(“bernie”).

def saludador(nombre)
    puts “Hola #{nombre}“
end

 

Otra alternativa es definir el método con un valor por defecto para el paráemtro. Por ejemplo:

def saludador(nombre=”Mundo”)
    puts ”Hola #{nombre.capitalize}”
end

En este caso se pone la primer letra del parámetro en mayúscula. Si invocamos:

Saludador ->; obtendremos la salida “Hola Mundo“

Dado que si no se pasa un parámetro, el mismo toma el valor (=”Mundo”).

 

Ruby: Primeros pasos...

Hace un tiempo hice un tutorial de Ruby para aprender el lenguaje. La verdad es que me gustó, se asemejó bastante a Python en lo que refiere a sintaxis. No me dio el tiempo de ver performance, variedad de frameworks en la vuelta, etc. Sin embargo como primeros pasos para conocer la sintaxis básica puede servir. Pongo una serie de posts explicando conceptos básicos del lenguaje.

Accediendo a la consola

Para poder acceder a la consola de Ruby simplemente escribimos “irb“ en el terminal (si estamos en Mac OS o Linux, si estuviéramos en Windows sería Fxri).

Si quisieramos obtener la versión que tenemos instalada de Ruby en nuestro pc, basta con escribir “ruby -v“ en la terminal. La salida debería ser algo similar a la siguiente línea:

ruby 1.8.7 (2009-06-12 patchlevel 174) [universal-darwin10.0].

Primeros pasos...

La salida de Ruby es con puts.

Puts “Hola mundo“ responderá en pantalla dos cosas:

1. Hola mundo


2. Nil.

El nil es la salida de la evaluación del comando puts. Puts siempre retorna nil luego de una evaluación.

Las operaciones matemáticas son sencillamente como si fuera una calculadora, 2+3, 5*2, 5**2.  Existen ciertos módulos como ser Math que agrupan funcionalidades similares, como ser Sqrt, Sin, Cos, Tan, etc. Para poder invocar ese tipo de operaciones es necesario escribir Math.sqrt(16). El resultado de ese mensaje será 4.0.