<div class="text-justify">
NOTA: Estoy volviendo a crear mis tutoriales de Ruby y en este caso para este post es una remasterización de un post que escribí hace más de dos años, por lo que ando arreglando algunas cosas que tenía mal explicado, así que busco que sea mejor entendible para el que quiera aprender Ruby y no se pierda en el proceso.
NOTA 2: El primer post de este tutorial lo puedes encontrar en [mi canal de Youtube de Programación](https://youtu.be/bHoj1eoOSD4) o en mi [web personal](https://shadowmyst.net/como-instalar-ruby/), de ahí en adelante crearé una colección en Peakd para que sea fácil su acceso.
---
Después de ver como [instalar el Lenguaje de Programación Ruby en nuestra computadora](https://shadowmyst.net/como-instalar-ruby/), es momento de que aprendamos la sintaxis básica que tiene. Una sintaxis buena para los principiantes, pues lo que busca este lenguaje de programación es que sea gentil para el programador.
Una de las ventajas y al mismo tiempo un poco confuso para los programadores que vienen de lenguajes de programación como C++ o Java es el uso de `{` `}` en nuestro ámbito de programación, ni tampoco terminamos nuestras instrucciones con un `;` en cambio su estructura empieza con la condición a usar y termina con un `end`. Ya lo veremos a continuación cuando ponga algunos ejemplos de su sintaxis, asi que agarren su **IDE** y pongamos manos a la obra. También recordar que una vez que creamos nuestro programa para ejecutarlo, en nuestra terminal ponemos `ruby <nombre_del_archivo>.rb`.
## Tipos de datos en Ruby
Los tipos de datos en Ruby tenemos las más conocidas de otros lenguajes de programación como son los enteros, cadena de caracteres, booleanos, junto con otras nuevas propias de este lenguaje de programación que a continuación mencionaré alguna de ellas. Una característica interesante es que no tenemos que declarar de que tipo es nuestra variable al momento de crearla, pues solo es cuestión de asignarle su valor y Ruby identificara de que tipo son.
* **Cadena de caracteres (`strings`):** Las cadenas de caracteres además de ser igual que otros lenguajes de programación que puedes declararlas usando comillas simples o dobles, tiene también la característica de que puedes incrustar un valor igual dentro de otra cadena usando `#{<variable>}`
~~~ ruby
variable1 ="Shadow Myst"
variable2 = "Hola soy #{variable1}"
~~~
* **Numeros:** Como mencione anteriormente, Ruby detecta de forma automática que tipo de variable estás usando, si es un entero o si es un número decimal (`float`), además que si estás usando números muy grandes, puedes poner guiones bajos, los cuales ignorara `millones=10_000_000`, así que es una forma de poder leer números grandes al momento de declarar variables
* **Booleanos:** Aquí no hay gran diferencia a otros lenguajes de programación, sus únicos valores serán True o False
* **Arreglos:** Los arreglos es algo que usamos mucho en los diferentes lenguajes de programación que llegamos a manejar y obviamente Ruby no seria la excepción. En ruby tenemos diferentes formas de declarar arreglos y tambien de manipularlos.
~~~ ruby
#Crear un objeto array
arreglo = Array.new
#Crear un objeto array pero con el numero de elementos que tendra
arreglo2 =Array.new(2)
#Simplemente iniciarlo con corchetes
arreglo3 = []
#Iniciarlo con los elementos que tendra
arreglo4 = ["Jesus","Leonel","Emmanuel"]
~~~
Ademas para añadir un elemento a nuestro arreglo podemos simplemente usar la anotación de corchetes en el indice correcto `arreglo4[3] = Atzimba` o usar la función push: `arreglo4.push("Atzimba")`
Un gran cambio que podemos notar con los arreglos en Ruby es la forma en recorrer los elementos del mismo, mientras que en otros lenguajes tendriamos que hacerlo con un For.
~~~ ruby
arreglo4.each do |indice|
puts indice
end
~~~
Nos creamos una variable "indice" donde se almacena temporalmente cada elemento de nuestro arreglo para los usos que queramos darle
* **Hash:** Los hash son como los arreglos pero con una gran diferencia, ya que en vez de existir un indice en el que se recorra el elemento, estos contendran llaves que sirvan para poder localizar el elemento que queramos usar. La forma en que las declaramos es casi igual que con los arreglos solo que en vez de corchetes `[ ]` usamos las llaves `{ }`
~~~ ruby
hash= Hash.new
hash2 = {}
#Lo llenamos de la siguiente forma
hash2 = {"Nombre" => "Jesus","apellido" => "Figueroa"}
~~~
Para agregar un nuevo elemento utilizaremos la notación de corchetes. Puedes usar cualquier valor para nombrar la clave: `hash2["edad"] = 30`
* **Simbolos:** Son usados muy seguido como identificadores en lugar de las cadenas porque pueden consumir menos memoria. Para crear un simbolo, simplemente precede una palabra con dos puntos: `:simbolo`
## Tipos de declaración de Variables en Ruby
Una de las características que tiene Ruby, es que las variables no son necesarias declararlas con un tipo de especifico, como suele ser en algunos otros lenguajes como lo que es C++, Java, etc. Las variables cambian de tipo en tiempo de ejecución por lo que por un momento puede ser una variable de tipo entero y en otro se vuelve una variable de tipo cadena, dependiendo de como las estemos usando al momento de necesitarlas.
* **Variables locales:** Tienen un ámbito local (dentro de una función o contexto) por convención se escriben en minúscula y si tiene un nombre compuesto este se separa por un guion bajo.
~~~ ruby
nombre, id_cliente, primer_apellido, segundo_apellido
~~~
* **Variables Globales:** Tienen un ámbito global pueden ser usados en cualquier parte de nuestro código, como una función, una clase o moduelo. Empiezan con el símbolo `$` conservan la misma convención de las variables locales.
~~~ ruby
$nombre, $id_cliente, $primer_apellido, $segundo_apellido
~~~
* **Variables de Instancia:** Aunque lo veremos mas adelante cuando se vean **las Clases** son las variables que se ejecutan dentro de una clase y son las variables que hacen referencia a las propiedades de una clase. Si estas variables las usas fuera de la clase te devolveran un valor nulo, por lo que solo pueden ser usadas dentro de los metodos de nuestra clase. Se representan colocando un `@` antes del nombre de la clase.
~~~ ruby
@nombre, @edad
~~~
* **Variables de clase:** Variables que pertenecen a la clase que tiene la facultad de que la variable al ser cambiado su valor, todos los objetos de esa clase también cambiara el valor de esa variable, por eso es obligado que cuando se crea una variable de este tipo debe comenzar inicializada con un valor y se representan con `@@` antes del nombre de la clase.
~~~ ruby
@@ruedas = 4
~~~
* **Constantes:** Variable que nunca cambiara de valor en todo el programa, por convención siempre se escriben en mayúscula.
~~~ ruby
PI = 3.1416, CAPACIDAD
~~~
## Estructuras de desición y Bucles
### Condicionales
* **if/else y unless:** Ruby tiene algo mas que el **if/else** como condicional primaria, sino que también tenemos a **unless**, mientras que **if** analiza una condición verdadera y de ahí sigue el flujo de instrucciones, **unless** hace justamente lo opuesto, analiza una condicional y si es falsa se ejecutan las instrucciones dentro del ámbito.
~~~ ruby
a = 5
b = 7
if a<b
puts "a es menor de b"
else
puts "b es menor de a"
end
~~~
En este caso como `a` es menor que `b` por lo que la condicion es verdadera nos imprimirá el mensaje dentro del **if**.
~~~ ruby
a = 5
b = 7
unless a<b
puts "b es menor de a"
else
puts "a es menor de b"
end
~~~
Pero en este caso como **unless** necesita que la condición sea falsa, nos va a imprimir lo que esta dentro de **else**.
También podemos poner nuestro condicional en una sola instrucción si es que nuestro programa es algo simple.
~~~ ruby
puts "a es menor a b" if a<b
puts "b es menor a a" unless a<b
~~~
* **switch/case:** Aunque en otros lenguajes de programación lo conocemos como un **"switch"** aqui se usa la palabra reservada **"case"** y su uso es prácticamente igual.
~~~ ruby
case calificacion
when (0..69) #Esta es una variable del tipo Range
puts "Reprobado"
when (70..100)
puts "Aprobado"
else
puts "No existe esa calificación o fue mal escrita"
end
~~~
**NOTA 1:** Los comentarios de una sola linea podemos anteponerlos con `#`
**NOTA 2:** Dentro de nuestro `case` podemos usar variables de tipo string, numéricos o en el caso de este ejemplo usamos de clase `Range`
**NOTA 3:** Mientras que en otros lenguajes se usa `default` como opción final en cuanto no tengamos como evaluar, en ruby usaremos Else como si fuera un if.
### Bucles
Ruby también nos da una variedad de diferentes palabras reservadas para usar bucles aparte de las tradicionales **while, do-while y for**, veamos todas una por una en un ejemplo rápido
* **While:**
~~~ ruby
while a<10
puts a
a+=1
end
~~~
* **Do-While:** Realmente no se conoce como do-while en ruby pero como es lo mas parecido a otros lenguajes lo subtitule de esa forma
~~~ ruby
begin
puts a
a+=1
end while a<10
~~~
* **until:** Until es lo mismo que cuando vimos **unless** mientras la condición sea falsa se va a cumplir la condición
~~~ ruby
until a<10
a+=1
puts "a no es menor a 10"
end
---------------
begin
puts "a no es menor a 10"
a+=1
end until a<10
~~~
De igual forma podemos poner nuestro `while` y `until` en una sola instrucción.
~~~ ruby
a+=1 while a<20 #Para While
a+=1 until a>20 #Para Until
~~~
* **loop:** Cuando conocí `Loop` se me hizo extraño pues realmente consiste de ciclar una instrucción indefinidamente y la única forma de salirse es con la palabra reservada `break`
~~~ ruby
loop do
puts a
a+=1
break if a>100
end
~~~
* **For:** Por ultimo nos falta la instrucción For que se nos simplifica mucho mas, aunque al principio puede confundir. Mientras que en otros lenguajes usamos la sintaxis `for(i=0;i<10;i++)` con Ruby lo reducimos a el nombre de la variable y un rango de valores que se especifica de la siguiente manera: `(0..10)`.
~~~ ruby
for i in (0..10)
puts i
end
~~~
Por ultimo y como recordatorio, podemos usar cuatro comandos que nos ayudaran en nuestros bucles:
* `break`: Termina el bucle
* `next`: Se adelanta a la siguiente interacción del bucle
* `redo`: Se repite el bucle ignorando y anulando la evaluación de la condición
* `retry`: Se repite el bucle repitiendo de igual forma la evaluación de la condición
</div>
[//]: # (CCC LINKS PLACEHOLDER, DON'T DELETE THIS TAG)
hiveblocks