Ruby es un lenguaje de programación muy conocido. Su objetivo es mejorar la sencillez y la productividad. También es un lenguaje de programación totalmente orientado a objetos. Además, Ruby cuenta con una sintaxis elegante que resulta natural de leer y fácil de escribir.
Cualquier programación requiere gestionar varios tipos de datos. Un tipo de datos describe una clase específica de datos. Le dice a la máquina cómo debe manejar los datos en el programa. Los tipos de datos son cruciales para determinar qué se puede hacer con los datos (incluidas las operaciones que se pueden realizar). En este tutorial, vamos a profundizar en los tipos de datos disponibles en Ruby. También exploraremos el tipado dinámico. Con esta función, Ruby puede determinar automáticamente el tipo de datos de una variable sin declararla explícitamente. ¡Empecemos!
Requisitos previos
Para practicar e implementar los pasos demostrados en esta guía, necesitará los siguientes componentes:
- Un sistema Linux correctamente configurado. Obtenga más información sobre cómo configurar un servidor Ubuntu personal en CloudSigma.
- Un entorno de desarrollo de Ruby correctamente configurado. Consulte la documentación oficial para instalar Ruby en Ubuntu (usando APT).
Tipos de datos en Ruby
Ruby presenta todos los tipos de datos comunes que encontrará en cualquier lenguaje de programación: enteros, flotantes, cadenas, arreglos, símbolos, hashes, etc. A continuación, ofreceremos una visión general de cómo trabajar con los diversos tipos de datos de Ruby.
Paso 1 – Enteros
Al igual que en las matemáticas, los enteros en la programación informática son números enteros. El valor puede ser positivo, negativo o 0. El rango de valores es el siguiente:
|
1 |
{-∞, …, -1, 0, 1, …, ∞} |
Es hora de probar los enteros en Ruby. El primer ejemplo consiste en imprimir un entero simple en la pantalla:
|
1 2 |
print 99 print "\n" |
A continuación, trabajaremos con una variable entera. Aquí, la variable sample_int contiene un valor entero (99) y la función print imprime el valor de la variable en la pantalla:
|
1 2 3 |
sample_int = 99 print sample_int print "\n" |
También podemos hacer operaciones matemáticas con enteros. El siguiente ejemplo demuestra una suma simple de dos números enteros:
|
1 2 3 |
sample_int = 99 + 100 print sample_int print "\n" |
Cuando trabajamos con números grandes, a menudo usamos comas (,) para facilitar la lectura. Por ejemplo, un millón (1000000) se escribe como 1,000,000 para una mejor legibilidad. Aunque el uso de comas está prohibido, Ruby permite usar guiones bajos ( _) como delimitador. Eche un vistazo al siguiente ejemplo:
|
1 2 3 |
sample_int = 1_000_999 print sample_int print "\n" |
El uso de guiones bajos mejora la legibilidad del código, especialmente cuando se trata de valores enteros grandes.
Paso 2 – Números de punto flotante
Un número de punto flotante (o float para abreviar) representa un número real. Al igual que en la definición matemática, los números reales pueden ser racionales o irracionales. En Ruby, un float es básicamente un número que contiene un punto decimal.
Intentemos imprimir un valor float en la pantalla:
|
1 2 |
print 55.66 print "\n" |
El siguiente ejemplo demuestra la declaración de una variable float:
|
1 2 3 |
sample_float = 55.66 print sample_float print "\n" |
También podemos realizar varias operaciones matemáticas con los valores y variables float. El siguiente ejemplo demuestra una suma simple de dos números float:
|
1 2 3 |
sample_float = 55.66 + 99.222 print sample_float print "\n" |
¿Qué pasa si sumamos un float y un entero? El valor resultante será un float. En el siguiente ejemplo, a pesar de que 55.0 es un número entero, se trata como un float:
|
1 2 3 |
sample_float = 55.0 + 10 print sample_float print "\n" |
Paso 3 – Booleanos
Los booleanos representan los valores de verdad de la rama lógica de las matemáticas. En Ruby, los tipos de datos booleanos se representan mediante dos valores: true y false:
-
Mayor que
-
100 > 99: true
-
99 > 100: false
-
-
Menor que
-
500 < 999: true
-
999 < 500: false
-
-
Igual
-
10 == 10: true
-
9 == 99: false
-
Al igual que con los números, también podemos almacenar un true o false valor en una variable. El siguiente ejemplo demuestra esta característica:
|
1 2 3 |
result = 9 == 99 print result print "\n" |
Paso 4 – Cadenas
En programación, una cadena se representa como una secuencia de caracteres (letras, números y símbolos). En Ruby, las cadenas existen entre comillas simples ( ') o comillas dobles ( "). Ya cubrimos en detalle el uso de cadenas en Ruby, por lo que esta será una sección corta.
El siguiente ejemplo es un programa básico hola mundo en Ruby:
|
1 |
print "hello world!\n" |
También podemos almacenar cadenas en variables. El siguiente ejemplo también incorpora la concatenación de cadenas:
|
1 2 |
username = "Cloudsigma" print "hello, " + username + "!\n" |
Paso 5 – Arrays
Un array es una estructura de datos que puede almacenar una colección de tamaño fijo de elementos del mismo tipo de datos. También se puede conceptualizar como una colección de variables del mismo tipo de datos. Es una de las estructuras de datos más fundamentales en la mayoría de los lenguajes de programación modernos.
En Ruby, un array se define de la siguiente manera:
|
1 |
[value_1, value_2, …, value_N] |
Es posible crear un array de cualquier otro tipo de datos que hayamos discutido hasta ahora (enteros, flotantes y cadenas). Aquí hay algunos ejemplos:
-
Entero: [-5, 0, 5]
-
Flotante: [-9.99, -6.99, -3.99, 0, 3.99]
-
Cadena: [“the”, “quick”, “brown”, “fox”]
El siguiente ejemplo implementa todos estos tipos de arrays:
|
1 2 3 4 5 6 |
print [-5, 0, 5] print "\n" print [-9.99, -6.99, -3.99, 0, 3.99] print "\n" print ["the", "quick", "brown", "fox"] print "\n" |
Ten en cuenta que cuando la función print encuentra un array, imprime el array completo en la pantalla. Para mayor comodidad, a menudo encontrarás arrays como variables. Actualicemos el código:
|
1 2 3 4 5 6 7 8 9 10 |
array_int = [-5, 0, 5] print array_int print "\n" array_float = [-9.99, -6.99, -3.99, 0, 3.99] print array_float print "\n" array_string = ["the", "quick", "brown", "fox"] print array_string print "\n" |
Ahora, podemos trabajar con elementos individuales de los arrays:
|
1 2 3 4 5 6 7 8 9 |
array_int = [-5, 0, 5] print array_int[2] print "\n" array_float = [-9.99, -6.99, -3.99, 0, 3.99] print array_float[1] print "\n" array_string = ["the", "quick", "brown", "fox"] print array_string[3] print "\n" |
Ten en cuenta que en Ruby, el valor del índice de los arrays comienza con 0.
Para mayor comodidad, los arrays en Ruby vienen con los métodos .first y .last que imprimen el primer y el último elemento:
|
1 2 3 4 |
array_float = [-9.99, -6.99, -3.99, 0, 3.99] puts array_float.first puts array_float.last print "\n" |
En Ruby, los arrays tienen otra característica interesante. Pueden contener diferentes tipos de datos al mismo tiempo. Por ejemplo, puedes almacenar cadenas, símbolos e incluso otros arrays:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
mixed_array = [ "hello", 99.99, "world", [ "the", "quick", "brown", "fox" ] ] print mixed_array print "\n" print mixed_array[3] print "\n" |
Paso 6 – Símbolos
En Ruby, un símbolo es un tipo de datos especial que actúa como una etiqueta o un identificador. Los símbolos son inmutables, lo que significa que no se pueden cambiar. Los símbolos aparecen como si se declararan variables sin ningún valor.
Aquí hay un ejemplo de un símbolo:
|
1 |
:time_zone |
Generalmente, los símbolos se utilizan para identificar algo importante. Para otras situaciones, sin embargo, las cadenas son más que suficientes.
Ruby, al ser un lenguaje orientado a objetos, trata todo como un objeto (incluidas las cadenas) con su ubicación de memoria única, incluso si las cadenas son idénticas. Sin embargo, cuando hace referencia a un símbolo, es el mismo objeto en todas partes del programa, la misma ubicación de memoria.
Paso 7 – Hashes
Un hash es una colección de claves y valores similar a un diccionario. A menudo, los hashes se utilizan para almacenar datos relacionados, por ejemplo, información sobre un usuario.
Aquí hay un ejemplo rápido de un hash. Hemos creado un hash user_info que contiene el nombre de usuario y la contraseña de un usuario:
|
1 2 3 4 5 6 |
user_info = { "username" => "HelloWorld999", "password" => "password123" } print user_info print "\n" |
Para recuperar los valores de un par clave-valor, tenemos que usar la clave. El siguiente ejemplo demuestra este proceso:
|
1 2 3 4 5 6 7 |
user_info = { "username" => "HelloWorld999", "password" => "password123" } print user_info["username"] print "\n" |
Ruby también permite definir un hash utilizando sintaxis ligeramente diferentes ( : en lugar de =>):
|
1 2 3 4 5 6 |
user_info = { username: "HelloWorld999", password: "password123" } print user_info[:password] print "\n" |
Esta estructura de sintaxis es similar a la sintaxis utilizada en otros lenguajes, por ejemplo, JavaScript. En esta estructura de sintaxis, las claves se definen como símbolos. Es por eso que en lugar de usar "username", estamos usando: username para acceder al valor.
Tipado dinámico
Es posible que ya haya notado que al declarar una variable, no tenemos que asignar explícitamente un tipo de datos. En su lugar, el valor de la variable determina el tipo de datos. Ruby utiliza tipado dinámico donde la comprobación de tipos se realiza en tiempo de ejecución. Por el contrario, los tipos de datos se determinan durante la compilación en los lenguajes de programación de tipado estático (C/C++, por ejemplo).
En el siguiente ejemplo, todos los valores asignados a la variable dyn_var son válidos:
|
1 2 3 4 5 |
dyn_var = 123 dyn_var = 456.789 dyn_var = true dyn_var = "the quick brown fox" dyn_var |
En los lenguajes de tipado dinámico, somos libres de reutilizar una variable existente para almacenar diferentes tipos de datos. Aquí, el ejemplo anterior se actualiza para demostrar este fenómeno:
|
1 2 3 4 5 6 7 |
dyn_var = 123 puts dyn_var dyn_var = 456.789 dyn_var = true dyn_var = "the quick brown fox" puts dyn_var dyn_var |
Como demuestra este ejemplo, cada vez que se asigna un nuevo valor, cambia el tipo de datos de dyn_var sobre la marcha. Es útil al convertir un tipo de datos a otro. El siguiente ejemplo demuestra esto:
|
1 2 3 4 |
print "ingrese la longitud: " length = gets.chop length = length.to_f puts length |
Aquí,
-
Debido a que las entradas del teclado son cadenas, length es una cadena al principio.
-
Como nuestro valor deseado es un float, estamos convirtiendo el valor de la cadena a float usando el to_f método.
-
Debido al cambio de valor, length se le asigna el tipo de datos float. Esto es lo que vemos al imprimir su valor en la pantalla.
¿Qué pasaría si intentáramos mezclar dos tipos de datos diferentes? Ruby arrojará un error. Eche un vistazo:
|
1 |
print 9 + "77" |
Identificación del tipo de datos
En Ruby, todo se trata como un objeto. Cada objeto en Ruby viene con el método class. Al llamarlo, este método indica cuál es el tipo de datos del origen. Aquí hay algunos ejemplos de uso del class método:
|
1 2 3 4 |
puts 55.class puts (55.55).class puts true.class puts nil.class |
Otra forma de saber el tipo de datos es usando el kind_of? método. Compara el tipo de datos del objeto con el tipo de datos solicitado y devuelve un valor booleano. Pruébalo en el siguiente ejemplo:
|
1 2 |
puts 55.kind_of?(Float) puts 55.kind_of?(Integer) |
De manera similar, existe otro método is_a? que compara el tipo de datos y devuelve un valor booleano. La única diferencia es la etiqueta del método. Sin embargo, puede ser preferible porque es un poco más fácil de leer y entender para los desarrolladores. Actualiza el ejemplo anterior con is_a?:
|
1 2 |
puts 55.is_a?(Float) puts 55.is_a?(Integer) |
Consideraciones finales
Trabajar con cualquier lenguaje de programación requiere una buena comprensión de los tipos de datos que admite. En esta guía, exploramos los tipos de datos más comunes utilizados en la programación de Ruby. Analizamos y demostramos enteros, flotantes, cadenas, símbolos, booleanos y hashes (con ejemplos).
Echa un vistazo a más tutoriales de nuestro blog que te ayudarán a explorar Ruby:
- Instalación de Ruby on Rails con RVM en Ubuntu 20.04
- Configuración de Ruby on Rails con PostgreSQL
- Uso de MySQL con una aplicación Ruby on Rails en Ubuntu 21.04
- Explorando CloudSigma PaaS: ¿Cómo utilizar los servicios de alojamiento PaaS de Ruby?
¡Feliz programación!
Comentarios
Aún no hay comentarios. Sea el primero.