Introducción a Ruby
Tags: ruby, beginners, oop, webdev
Published: 2020-05-13 03:21:24

---
series: Fundamentos de Ruby
---

# Tabla de contenido
1. [Introducción](#introduccion)
2. [¿Qué es Ruby?](#ruby)
3. [Sintaxis básica](#basics)
4. [Condicionales](#condiciones)
5. [Arrays y Hashes](#arrays-hashes)
6. [Estructuras de control (ciclos)](#ciclos)
7. [Fin :(](#fun)

##Introducción<a name="introduccion">

¡hola a todos! he vuelto con un nuevo artículo, en esta última semana estuve leyendo sobre un lenguaje de programación, el cual nunca había tenido ningún acercamiento, no conocía su sintaxis (solo sabía que era muy parecido a *Python*), no conocía __frameworks__ escritos con él, en pocas palabras no me había interesado por aprenderlo, sin embargo leyendo en __Twitter__ y en __LinkedIn__ que muchas empresas lo usan, me dio mucha curiosidad y comencé a ver algunos videos y a leer algunos libros y artículos que encontré y la verdad me atrapó, el lenguaje del que hablo es [Ruby](https://www.ruby-lang.org/es/), y bien la idea de escribir una serie de tutoriales sobre el es porque aún lo estoy aprendiendo y quiero compartir todo lo que pueda aprender y todos aprendamos juntos, voy a omitir la instalación de Ruby ya que realmente es bastante sencilla y creo que tomando 5 minutos en Google puedes lograr instalarlo sin problemas.

##¿Qué es Ruby?<a name="ruby">

Antes de entrar en tema de sintaxis quiero mostrarte lo que la página oficial dice de Ruby:

> ### Ruby es...
>Un lenguaje de programación dinámico y de código abierto enfocado en la simplicidad y productividad. Su elegante sintaxis se siente natural al leerla y fácil al escribirla.

También se dice que *Ruby* es el lenguaje de las grandes *Startups*, si haz utilizado *Python* te sentirás familiarizado con la sintaxis de *Ruby*, ya que de cierto modo son parecidos, *Ruby* es un lenguaje de tipado dinámico, lo que quiere decir que no necesitarás declarar un tipo de dato cuando declaras una variable o definir un tipo de dato de retorno en las funciones como en otros lenguajes de tipado estático como *Java* o *C#*, entonces vamos a comenzar con las variables y tipos de datos en *Ruby*.

##Sintaxis básica<a name="basics">

Antes de comenzar vamos a crear un archivo con el nombre que tu quieras en la carpeta que tu desees, yo lo pondré en mi workspace y lo llamare `intro.rb`, OJO `.rb` es la extensión que deben tener los archivos de Ruby y así el interprete pueda ejecutarlos.

Bueno para comenzar no hay trucos, las variables en *Ruby* se definen escribiendo el nombre y su valor asignándolo con el signo de `=` de la siguiente manera:

```ruby
name = 'John'
last_name = 'Doe'
age = 30
```

Si bien nuestro ejemplo es muy básico, creo que podemos hacer algunas observaciones, la primera es que Ruby es indiferente a las comillas simples o las comillas dobles, sin embargo se recomienda que estandarices las que vayas a usar en tu código y no que las combines, segunda observación es que a diferencia de otros lenguajes Ruby recomienda usar `snake_case` para variables y funciones, y `CamelCase` solo para nombres de clases, algo muy parecido a lo que recomienda la comunidad de Python, para continuar podemos imprimir en pantalla las variables de la siguiente manera:

```ruby
puts "Mi nombre es #{name} #{last_name} y tengo #{age} años"
```
Si desde nuestra terminal ejecutamos `ruby intro.rb` podemos observar la siguiente salida:

```console
Mi nombre es John Doe y tengo 30 años
```

Vamos a detenernos a explicar lo que acaba de ocurrir, bien la palabra reservada `puts` realmente es un método en Ruby, podemos o no escribirlo con paréntesis (`puts()`) sin embargo en documentación y otros ejemplos en internet difícilmente lo encontrarás con paréntesis, porque en Ruby es común escribirlo así como lo hicimos, lo segundo que podemos observar es algo que muchos lenguajes ya han incorporado y es la interpolación de cadenas con Ruby usamos esta sintaxis `"#{variable}"` para imprimir contenido dinámico en un `string` sin necesidad de concatenarlo, y si eres un poco observador, te darás cuenta que esta vez usamos comillas dobles, y es que esto tiene un propósito, la interpolación de cadenas solo se puede hacer con comillas dobles, ya que las comillas simples imprimirán el contenido de la cadena tal cual lo escribimos y eso incluye nuestra sintaxis para la interpolación.

Ahora vamos a ver las constantes, podemos definir constantes en Ruby simplemente con poner el nombre de la "variable" en mayúsculas, de esta forma el interprete de Ruby entenderá que el valor asignado a la constante nunca cambiará, por ejemplo:

```ruby
BIRTHDAY = Time.new(1992, 07, 24)
```

De esta forma hemos declarado una constante `BIRTHDAY` con nuestra fecha de cumpleaños, si la reasignamos, obtendremos el siguiente `warning` en la consola `warning: previous definition of BIRTHDAY was here` este nos avisará que la constante ya fue asignada, la clase `Time` como en todo lenguaje de programación existe una clase para manejar fechas y horas y en este tutorial no vamos a profundizar en esta clase.

Existen muchos detalles que no considero tan relevantes en un tutorial como este si es que ya conoces de programación, ya que no es un tutorial de fundamentos de programación sino de Ruby, así que los mencionaré muy rápidamente, por ejemplo los tipos de datos que tenemos en ruby son `int` como `100`, los `float` como `100.0`, `boolean` como `true` o `false` entre otros que tenemos disponibles en la mayoría de los lenguajes, en Ruby todo es un objeto y por ende cada tipo de dato tiene muchos métodos a los cuales se pueden acceder, te invito a que los explores, por ejemplo si quieres saber que métodos corresponden a la clase `String` puedes hacer lo siguiente:

```ruby
puts "una cadena cualquiera".methods
```

Y de esta manera puedes comprobarlo con cualquier tipo de dato, recuerda todo en Ruby es un objeto y por lo tanto todo tiene métodos a los que podemos acceder. Otro detalle poco relevante pero que es bueno que lo sepas es que existen 3 métodos para imprimir en consola, `print`, `puts` y `p`, puedes experimentar con ellos y ver sus diferencias que no son muchas.

Bien otro detalle interesante que aprendí de Ruby, la entrada datos por el usuario y como hacemos esto, muy fácil:

```ruby
print "dame tu nombre: "
nombre = gets.chomp
puts "Mucho gusto #{nombre}"
```

Te explico en la primera línea usamos `print` porque `puts` nos agrega un salto de línea y `print` no hace eso, segundo `gets` captura lo que el usuario escriba en la terminal, `gets` también agrega un salto de línea, y eso aunque sea invisible nos agrega un caracter más que no necesitamos, para eliminarlo utilizamos `chomp`, como puedes ver en el ejemplo podemos asignar la entrada del usuario a una variable e imprimirla.

## Condicionales<a name="condiciones">

Vamos a ver los condicionales en Ruby, la sintaxis es muy sencilla y de nuevo comparando con Python son muy parecidos, en este momento vamos a entrar a una característica del lenguaje que son los bloques de código, pero ¿cómo definimos un bloque de código? con el condicional `if` lo miraremos:

```ruby
if true 
  puts 'es verdadero!'
end
```

Así de simple es Ruby, delimitamos el final de un bloque de código a través de la palabra reservada `end`, rápidamente otra característica del lenguaje son los operadores lógicos que de igual manera como en otros lenguajes son, `and` (&&), `or` (||) `not` (!), puedes usar los símbolos que están entre paréntesis o las palabras reservadas, vamos al código:

```ruby
#con palabras reservadas
falso = false
verdadero = true

if not falso and verdadero or true
  puts 'es falso! o verdadero? O.o'
end

#con simbolos
falso = false
verdadero = true

if !falso && verdadero || true
  puts 'es falso! o verdadero? O.o'
end

```

La salida es la misma sin embargo los símbolos tienen mayor procedencia, un detalle en este ejemplo es este símbolo `#`, el cual usamos para hacer comentarios en la misma línea, continuando con las condiciones todo `if` podría tener un `else` y se ve de la siguiente manera:

```ruby
if 10 < 1
  puts 'si es'
else
  puts 'no es'
end
```

Y también podría tener un `sino` o `elsif`, si así se escribe `elsif`:

```ruby
if 10 < 1
  puts 'si es menor que 1'
elsif 10 > 5
  puts 'si es mayor que 5'
else
  puts 'no es'
end
```

Como puedes ver las condiciones y los operadores lógicos en Ruby son muy simple, para terminar con la parte de condicionales, vamos a ver muy rápidamente el condicional `case`:

```ruby
dia = 8

case dia
when 1
  puts 'es lunes'
when 2
  puts 'es martes'
when 3
  puts 'miercoles'
when 4
  puts 'es jueves'
when 5
  puts 'es viernes'
else
  puts 'es fin de semana'
end
```

 Y `unless`:

```ruby
unless !true
  puts 'es falso'
else
  puts 'es verdadero'
end
```

`unless` es exactamente lo opuesto a `if`, es la negación de `if`, puedes experimentar con los condicionales e ir probándolos y descubriendo su funcionamiento.

##Arrays y Hashes<a name=“arrays-hashes”>

Antes de comenzar a hablar de las estructuras de control, vamos a ver dos estructuras de datos las cuales vamos a ocupar para trabajar con ciclos, bien estos son los `arrays` y los `hashes`, vamos a empezar rápidamente con los `array`, como en otros lenguajes son colecciones de información que pueden ser de cualquier tipo de dato, por ejemplo:

```ruby
arr = [1,2,4,true,'string']
puts arr
```

Los `hashes` son diccionarios osea que son estructuras de tipo `clave-valor`, un ejemplo sería el siguiente:

```ruby
dict = {
  'clave' => 'valor',
  'otra clave' => 'otro valor'
}

puts dict
```

Algo que me gustaría mucho mencionar sobre los `hashes`, es que existe una sintaxis especial sobre las cadenas, de hecho esta sintaxis es muy usada con los `hashes`, y esta sintaxis lleva el nombre de `symbols`, esta solo pueden ser aplicadas a cadenas de una sola palabra osea que no tienen espacios, por ejemplo:

```ruby
dict = {
  :clave => 'valor',
  :otra_clave => 'otro valor'
}

puts dict
```

Tenemos otra manera de escribir los `hashes` y es la siguiente:
```ruby
dict = {
  clave: 'valor',
  otra_clave: 'otro valor'
}

puts dict
```

También son `symbols` pero con una sintaxis diferente, son como los diccionarios en Python.

Bien rápidamente, los `symbols`, hacen referencia a un solo objeto o mejor dicho al mismo lugar en memoria, y muchas veces trabajar con `symbols` es mas eficiente que las cadenas y el mejor ejemplo es trabajar con ellos en los `hashes`, las claves debería ser `symbols` y no `strings`, para demostrar que se trata del mismo objeto (recuerda en Ruby todo es un objeto) podemos hacer lo siguiente:

```ruby
puts 'hola'.object_id
puts 'hola'.object_id
puts :hola.object_id
puts :hola.object_id
```

Nuestra consola arrojará el siguiente resultado, porque aunque los `strings` son los mismos, se crea un objeto diferente por cada uno, en cambio los `symbols` siempre apuntan al mismo:

```console
42140380
42140240
1102428
1102428
```

Para terminar solo nos falta ver como accedemos a los elementos de un `array` y de un `hash` y esto es muy sencillo:

```ruby
#accediendo al valor de un hash
dict = {
  clave: 'valor',
  otra_clave: 'otro valor'
}

puts dict[:clave]

#accediendo al valor de un array por medio de su índice
arr = [1,2,4,true,'string']
puts arr[4]
```

Como podemos ver es muy sencillo trabajar con estas estructuras de datos y nos serán muy útiles para trabajar con ciclos.

## Estructuras de control (ciclos)<a name="ciclos">

Bien ahora si vamos directo a las estructuras de control, y la primera que vamos a explorar será el ciclo `for`, supongamos que tenemos el siguiente *array*: `colores = ['rojo', 'azul', 'verde', 'amarillo', 'negro', 'blanco']`, podemos hacer un `puts` o podemos recorrerlo de la siguiente manera:

```ruby
colores = ['rojo', 'azul', 'verde', 'amarillo', 'negro', 'blanco']

for color in colores
  puts color
end
```

Así de simple, así de sencillo, sin más complicaciones hemos recorrido nuestro `array`, pero Ruby nos provee otras formas, por ejemplo:

```ruby
colores = ['rojo', 'azul', 'verde', 'amarillo', 'negro', 'blanco']

colores.each do |color|
  puts color
end
```

Prácticamente es una manera de hacer un ciclo de manera funcional, recuerda que en Ruby **TODO** es un objeto, de modo que los `array` y los `hash` también tienen métodos que pueden ser aplicados a ellos, para terminar con el ciclo `for` vamos a ver un ejemplo de como recorrer un `hash`:

```ruby
autos_colores = {
  nissan: 'rojo',
  chevrolet: 'azul',
  volkswagen: 'verde',
  susuki: 'amarillo',
  ford: 'negro',
  kia: 'blanco'
}

autos_colores.each do |key, value|
  puts "El auto #{key} es de color #{value}"
end
```

Por último en este artículo, vamos a ver el ciclo `while`, su modificador o "`do while`" y el ciclo `ùntil`:

```ruby
numero = 1

while numero <= 5
  puts 'en ejecucion'
  numero += 1
end
```

El ciclo `while` es muy sencillo sin embargo, existe un modificador para este ciclo, que hace la función de `do while` en otros lenguajes, vamos a ello:

```ruby
begin 
  puts 'en ejecucion'
end while 1 > 10
```

La condición NO es verdadera pero de igual manera que `do while`, la instrucción se ejecuta una sola ves, después se evalúa la condición y al ser `false` se sale del ciclo. Por último y muy rápidamente vamos a ver el ciclo `until`:

```ruby
numero = 1

until numero > 5
  puts 'en ejecucion'
  numero += 1
end
```

Si notas su función, así como `unless` es la negación de `if`, `until` es la negación del `while`, ya que until se va a ejecutar mientras la condición sea falsa, cuando la condición se evalúe como verdadera el ciclo se termina.


## Fin :( <a name="fin">

Como pudiste ver Ruby es un lenguaje, muy simple, súper expresivo, muy divertido y sobre todo "fácil" de aprender, NO abarcamos funciones, clases, métodos de clases, atributos etc... Porque podemos utilizarlo para un artículo posterior, y también conforme siga adentrándome a este maravilloso lenguaje podemos seguir compartiendo conocimiento, sin embargo esta introducción ha sido bastante buena y productiva, insisto acabo de empezar a aprenderlo y si tu ya sabes Ruby y consideras que algo de lo que escribí es incorrecto, con toda confianza envíame un mensaje, porque no solo busco compartir información, sino también aprenderla bien, esta serie de artículos serán como una especie de diario, la cual irá creciendo a medida que siga aprendiendo más sobre Ruby y descubriendo algunos trucos que nos harán más productivos y mejores programadores. Hasta la próxima, nos vemos pronto.