Cómo trabajar con cadenas en Ruby

Introducción

A string is a sequence of one or more characters that may consist of letters, numbers, or symbols.

Las cadenas en Ruby son objetos, y a diferencia de otros lenguajes, las cadenas son mutables, lo que significa que pueden cambiarse en su lugar en vez de crear nuevas cadenas.

Usarás cadenas en casi todos los programas que escribas. Las cadenas te permiten mostrar y comunicarte con tus usuarios utilizando texto. De hecho, la página que estás leyendo en este momento está compuesta por cadenas que se muestran en tu pantalla a través de tu navegador web. Las cadenas son uno de los fundamentos más importantes de la programación.

En este tutorial, aprenderás cómo trabajar con cadenas en Ruby. Crearás cadenas, las mostrarás en pantalla, las almacenarás en variables, unirás múltiples cadenas juntas y aprenderás cómo manejar caracteres especiales como saltos de línea, apóstrofos y comillas dobles.

Creación e Impresión de Cadenas

Las cadenas existen dentro de comillas simples ' o comillas dobles " en Ruby, así que para crear una cadena, encierra una secuencia de caracteres en una u otra:

'This is a string in single quotes.'

"This is a string in double quotes."

Puedes elegir usar comillas simples o comillas dobles. En la mayoría de los casos, no importa cuál elijas, siempre y cuando seas consistente. Sin embargo, al usar comillas dobles, puedes realizar la interpolación de cadenas, de la cual aprenderás en este tutorial.

Para mostrar una cadena en tu programa, puedes usar el método print:

print "Let's print out this string."

El método print muestra la cadena exactamente como está escrita.

Pruébalo. Crea un nuevo programa Ruby llamado print.rb usando tu editor de texto y utiliza el método print para imprimir tres cadenas:

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

Guarda el archivo y ejecuta el programa:

ruby print.rb

Verás la siguiente salida:

Output
This is the first string.This is the second string.This is the third string.

En lugar de que las tres cadenas se impriman en líneas separadas, las tres cadenas se imprimieron juntas en una sola línea. El método print imprime la cadena en la pantalla, pero si quisieras que cada cadena esté en su propia línea, tendrías que agregar un carácter de salto de línea tú mismo.

Si quisieras que las tres cadenas estén en líneas separadas, usa en su lugar el método puts. Modifica tu programa para usar puts en lugar de print:

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

Ahora ejecuta el programa nuevamente y verás esta salida:

Output
This is the first string.
This is the second string.
This is the third string.

El método puts imprime la cadena especificada, pero también agrega un carácter de nueva línea al final de la cadena por ti.

Almacenar cadenas en variables

Las variables son una referencia nombrada a un lugar en la memoria de la computadora. Utilizas variables para almacenar datos y recuperarlos más tarde.

Para almacenar una cadena en una variable, define el nombre de la variable y asigna el valor de la cadena:

my_string = 'This is my string'

Luego, para recuperar el valor, utiliza el nombre de la variable:

print my_string

Para probar esto por ti mismo, crea el archivo string_variables.rb en tu editor con el siguiente comando:

nano string_variables.rb

Luego agrega el siguiente código:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts my_name
puts my_age

Este programa define dos variables: my_name y my_age. A cada variable se le asigna una cadena. Luego utilizamos el método puts para imprimir cada cadena en su propia línea.

Guarda el archivo con CTRL + X y y, luego ejecuta el programa:

ruby string_variables.rb

Verás la siguiente salida:

Output
Sammy the Shark
none of your business

Al asignar cadenas a variables, puedes evitar escribir la misma cadena una y otra vez cada vez que desees usarla, lo que facilita trabajar con y manipular cadenas en tus programas.

Vamos a ver cómo unir cadenas para crear nuevas cadenas.

Concatenación de cadenas

Concatenación significa unir dos o más cadenas para crear una nueva cadena. Para concatenar, usamos el operador de concatenación, representado por el símbolo +. El símbolo + también es el operador de suma cuando se usa en operaciones aritméticas.

Así es como concatenarías las cadenas sammy y shark juntas:

"sammy" + "shark"

Esto produciría la siguiente salida:

Output
sammyshark

La concatenación une las cadenas extremo a extremo, combinándolas y produciendo un valor de cadena completamente nuevo. Si deseas tener un espacio entre las palabras sammy y shark, debes incluir ese espacio en una de las cadenas, así:

"sammy " + "shark"

Ahora, realmente no escribirías código así en un programa, pero necesitarás mezclar cadenas y variables bastante a menudo, y ahí es donde entra en juego la concatenación.

Aquí tienes un ejemplo:

color = "Blue"
print "My favorite color is " + color

Esto resultaría en la salida Mi color favorito es azul. Ten en cuenta que dejamos un espacio después de la palabra es en la cadena para que la salida tenga un espacio entre la cadena y el valor de la variable en la salida.

Puedes concatenar múltiples cadenas de esta manera. Crea el archivo concatenation.rb y agrega este código:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts "My name is " + my_name + " and my age is " + my_age + "."

Este programa define dos variables: mi_nombre y mi_edad, cada una con su propia cadena asignada, tal como has hecho antes. Pero esta vez, en lugar de imprimir los valores, estamos imprimiendo una cadena que usa la concatenación para imprimir esos valores con un poco más de contexto.

Cuando ejecutas este programa, verás la siguiente salida:

Output
My name is Sammy the Shark and my age is none of your business.

En este pequeño programa, utilizaste concatenación para insertar variables en esta cadena.

Cuando combinas dos o más cadenas a través de la concatenación, estás creando una nueva cadena que puedes usar en todo tu programa, por lo que es posible que desees asignar la cadena que creaste a una nueva variable que puedas usar más tarde:

my_name = "Sammy the Shark"
my_age = "none of your business"

# asignar cadena concatenada a variable
output = "My name is " + my_name + " and my age is " + my_age + "."

# Imprimir la salida.
puts output

En un programa pequeño como este, probablemente sea innecesario usar una variable adicional de output. Pero en programas más grandes, es posible que desees crear una cadena usando concatenación que usarás en varios lugares. También es una buena práctica separar el procesamiento de datos como la concatenación y la aritmética de la salida, ya que eventualmente tus programas serán más grandes y querrás separar la lógica y la salida en archivos o componentes separados para que sean más fáciles de gestionar.

Asegúrate de no usar el operador + entre dos tipos de datos diferentes. No puedes concatenar cadenas e enteros juntos, por ejemplo.

Para ver qué sucede, crea un nuevo programa llamado strings_and_integers.rb con el siguiente contenido:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Esta vez tenemos my_name que contiene la cadena Sammy the Shark y my_number que contiene el entero 27. Sabemos que 27 no es una cadena porque no está rodeada de comillas. Tampoco tiene un punto decimal, así que sabemos que es un entero.

Si ejecutas el programa:

ruby strings_and_ints.rb

Verás este mensaje de error:

Output
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

El error no implicit conversion of Integer into String significa que Ruby solo puede concatenar una cadena a la cadena existente.

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Podríamos alterar nuestro programa y colocar el número 27 entre comillas ("27") para que se declare como una cadena en lugar de un entero. O podemos convertir el número a una cadena cuando creamos la cadena, de esta manera:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

El método .to_s convierte el entero en una cadena. Este es un enfoque mejor, ya que nos permite mantener nuestro número como un entero en nuestro programa. Solo necesitamos que sea una cadena cuando lo imprimimos, pero tal vez queramos que sea un entero si tenemos que usarlo en otras partes de la lógica de nuestro programa.

Ejecuta el programa nuevamente y verás Sammy the Shark27 impreso en la pantalla.

Convertir números a cadenas para la concatenación es algo que encontrarás frecuentemente al tratar con códigos postales, moneda, números de teléfono y otros datos numéricos que deseas mostrar en la pantalla junto con texto.

La concatenación es poderosa, pero puede ser complicada. Si accidentalmente omites uno de los operadores +, puedes obtener un error de sintaxis. Y si tienes que unir cadenas con variables que contienen números, debes convertir las variables a cadenas. Ruby proporciona otra forma de insertar valores de variables en una cadena, llamada interpolación de cadenas que aborda ambos problemas.

Usando la interpolación de cadenas

Cuando concatenas cadenas y variables, la salida puede ser difícil de leer y depurar. La interpolación de cadenas resuelve esto al permitirte incrustar expresiones en una cadena encerrada entre comillas dobles.

En lugar de escribir esto:

"My name is " + my_name + "!"

Puedes hacer esto:

"My name is #{my_name}!"

En lugar de terminar la cadena y usar el operador +, encierras la variable con la sintaxis #{}. Esta sintaxis le indica a Ruby que evalúe la expresión e inyecte su valor en la cadena.

Pruébalo. Crea un nuevo programa llamado interpolation.rb y agrega este código:

my_name = "Sammy the Shark"
my_age = "none of your business"

output = "My name is #{my_name} and my age is #{my_age}."

puts output

Este es el mismo programa que ya has escrito, pero esta vez estamos usando la interpolación de cadenas para crear la salida.

La interpolación de cadenas tiene otro beneficio: puede convertir automáticamente valores numéricos a cadenas. ¿Recuerdas tu programa strings_and_integers.rb? Abre ese archivo en tu editor nuevamente pero cambia la última línea para que se vea como la siguiente:

my_name = "Sammy the Shark"
my_number = 27

# utiliza interpolación en lugar de concatenación
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby convertirá automáticamente my_number a una cadena, y tu programa imprimirá la siguiente salida cuando lo ejecutes:

Output
My name is Sammy the Shark and my favorite number is 27.

La interpolación de cadenas es poderosa y conveniente. También es el método preferido para concatenar cadenas con variables.

Literales de cadenas y valores de cadenas

Observa que todas las cadenas que has creado están encerradas entre comillas en el código, pero la salida impresa real no incluye las comillas.

Hay una distinción al referirse a cada una de ellas. Un literal de cadena es la cadena tal como está escrita en el código fuente, incluidas las comillas. Un valor de cadena es lo que ves en la salida y no incluye comillas.

Este es un literal de cadena:

"Sammy the Shark"

El valor de la cadena sería Sammy the Shark.

En la mayoría de los casos, no tendrás que preocuparte por esta diferencia, a menos que quieras usar caracteres especiales como comillas o apóstrofos en tus cadenas.

Escapando comillas y apóstrofos en cadenas

Debido al hecho de que las comillas se utilizan para denotar cadenas, tendrás que hacer un poco de trabajo extra si deseas apostrofes y comillas en las cadenas.

Si intentas usar un apóstrofe en medio de una cadena entre comillas simples, como este ejemplo:

'This isn't what I wanted.'

El apóstrofe en isn't termina la cadena, como puedes ver por el resaltado extraño en este ejemplo. Como resultado, el intérprete de Ruby intentará analizar el resto de la cadena prevista como código y obtendrás un error.

Te encontrarías en la misma situación si usaras comillas dobles en una cadena encerrada entre comillas dobles:

"Sammy says, "Hello!""

En este ejemplo, la comilla doble de cierre delante de Hello termina la cadena, y la comilla doble después de Hello! crea una nueva cadena que no tiene una comilla doble coincidente para terminarla, por lo que Ruby mostrará un error.

Para evitar este problema, tienes algunas opciones. Primero, puedes usar la sintaxis alternativa para crear cadenas; si tienes que usar comillas dobles en la cadena, usa comillas simples para definir la cadena, y viceversa. También podrías escapar las comillas, o podrías usar una sintaxis de Ruby diferente para definir las cadenas. Veamos cada enfoque.

Opción 1: Usa la Sintaxis Alternativa de Cadenas

La forma más fácil de solucionar estos problemas es encerrar tu cadena entre comillas simples cuando tu cadena necesite incluir comillas dobles, y encerrar tu cadena entre comillas dobles cuando tu cadena necesite usar comillas simples.

En lugar de definir esta cadena con comillas simples:

'This isn't what I wanted.'

Defínela con comillas dobles:

"This isn't what I wanted."

Y en lugar de usar comillas dobles para definir esta cadena:

"Sammy says, "Hello!""

Usa comillas simples:

'Sammy says, "Hello!"'

Usar la sintaxis alternativa puede sacarte de apuros rápidamente, pero no siempre funcionará. Por ejemplo, ninguno de los enfoques funcionará para esta cadena:

"Sammy says, "I'm a happy shark!""

En este ejemplo, la comilla doble de cierre delante de I'm realmente complica las cosas. Esto termina la primera cadena, y luego Ruby encuentra el apóstrofe en I'm, que comienza una nueva cadena con el valor m a happy shark!"". Pero esta nueva cadena no tiene una comilla simple coincidente para terminarla. Y usar comillas simples para encerrar la cadena introduce un problema similar:

'Sammy says, "I'm a happy shark!"'

Esta vez el apóstrofe en I'm termina la cadena.

Usar la sintaxis alternativa también puede hacer que tu código sea inconsistente. Cambiar constantemente entre la sintaxis de cadenas puede ser confuso, Podemos escapar caracteres para solucionar este problema.

Opción 2: Escapar Caracteres en Cadenas

El carácter de barra invertida (\), a menudo referido como el carácter de escape en las cadenas, evitará que Ruby interprete el siguiente carácter en la cadena literalmente.

Aquí está nuestra cadena problemática, codificada entre comillas dobles, con comillas dobles en su interior:

"Sammy says, "I'm a happy shark!""

Crea un nuevo programa Ruby llamado quoting.rb y agrega este código al archivo:

print "Sammy says, "I'm a happy shark!""

Ejecuta el programa:

ruby quoting.rb

Y verás esta salida:

Output
quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^

Para corregir el error, utiliza la barra invertida delante de las comillas dobles internas:

print "Sammy says, \"I'm a happy shark!\""

Luego, ejecuta el programa nuevamente y verás la salida esperada:

Sammy says, "I'm a happy shark!"

Observa que no es necesario escapar el apóstrofe en este ejemplo, ya que no hay conflicto. Solo necesitas escapar las comillas que confundirán a Ruby.

Puedes evitar escapar comillas por completo utilizando una sintaxis diferente para definir cadenas.

Opción 3: Usar una Sintaxis Alternativa para Cadenas

Hasta ahora has utilizado comillas para definir los límites de tus cadenas. Puedes crear cadenas en Ruby utilizando otros caracteres también. Puedes definir el delimitador, o el carácter que te gustaría usar para encerrar tu cadena, especificándolo después de un signo de porcentaje, así:

%$Sammy says, "I'm a happy shark!"$

Esta sintaxis escapará automáticamente las cadenas incrustadas por ti. La cadena real se ve así:

"Sammy says, \"I'm a happy shark!\""

Sin embargo, cambiar el delimitador significa que debes escapar el delimitador si necesitas usarlo. En este caso, si tuvieras que usar un signo de dólar en tu cadena, necesitarías escapar el signo de dólar literal en la cadena.

Para evitar esto, también puedes usar pares de llaves, corchetes o paréntesis como delimitadores. Las llaves son las más comunes:

%{Sammy says, "I'm a happy shark!"}

Estas formas admiten la interpolación de cadenas si la necesitas.

droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}

También verás que se utilizan %Q{} y %q{} para definir cadenas en programas Ruby. La sintaxis %Q{} funciona exactamente como las cadenas entrecomilladas dobles, lo que significa que no tienes que escapar las comillas dobles, y podrás usar la interpolación de cadenas:

droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}

La sintaxis %q{} funciona exactamente como las cadenas entrecomilladas simples:

%q{Sammy says, "I'm a happy shark!"}

Puedes ver que la sintaxis %q y %Q se usa con paréntesis o corchetes en algunos programas en lugar de llaves.

Como puedes ver, hay muchas formas de crear cadenas en Ruby. Sea cual sea el método que elijas, sé consistente en tu código. Descubrirás que los métodos %Q{} y %{} son los más comunes.

Ahora que sabes cómo manejar caracteres especiales, veamos cómo manejar cadenas largas y caracteres de nueva línea.

Cadenas Largas y Caracteres de Nueva Línea

Hay momentos en los que es posible que desees insertar un carácter de nueva línea o retorno de carro en tu cadena. Puedes utilizar los caracteres de escape \n o \r para insertar una nueva línea en el código:

output = "This is\na string\nwith newlines"
puts output

Este programa produciría la siguiente salida:

Output
This is
a string
with newlines

Esto funciona técnicamente para obtener nuestra salida en varias líneas. Sin embargo, escribir una cadena muy larga en una sola línea rápidamente se volverá difícil de leer y trabajar. Hay algunas soluciones.

Primero, puedes utilizar el operador de concatenación para dividir la cadena en varias líneas:

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

Esto simplemente concatena tres cadenas juntas, similar a lo que ya has hecho.

También puedes colocar los saltos de línea directamente en la cadena:

output = "This is a
longer string
with newlines"
puts output

También puedes utilizar cualquiera de las sintaxis alternativas de cadena para crear cadenas multilineales:

output = %{This is a
longer string
with newlines}
puts output

En ambos ejemplos, observa que no necesitamos los caracteres de nueva línea (\n). Este enfoque conserva los espacios en blanco, incluida la sangría y las nuevas líneas.

Como resultado, la salida contendrá los saltos de línea, así como toda la sangría inicial, de esta manera:

Output
This is a
longer string
with newlines

Para evitar eso, elimina el espacio en blanco adicional de tu código:

output = %{This is a
longer string
with newlines
}

También puedes crear cadenas multilineales utilizando un heredoc, o “documento aquí”, un término utilizado para literales de cadena multilineales en programas. Así es como escribirías ese código:

output = <<-END
This is a
longer string
with newlines
END

Los marcadores <<-END y END indican el inicio y el final del heredoc.

Aquí tienes el texto traducido:

Las heredocs en Ruby también conservan los caracteres de espacio en blanco, lo que significa que si sangras el código en la heredoc, la sangría principal también se conserva. Entonces, este código:

output = <<-END
This is a
longer string
with newlines
END

se imprimiría con dos espacios de sangría.

Ruby 2.3 y versiones superiores proporcionan la sintaxis de “heredoc ondulado” que elimina automáticamente este espacio en blanco inicial. Reemplaza el guión en la definición de la heredoc con una virgulilla, así que <<- se convierte en <<~, así:

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

Esto produce la siguiente salida:

Output
This is a
longer string
with newlines
and the code is indented
but the output is not.

Esto te permite usar heredocs y mantener tu código bien sangrado.

Las heredocs en Ruby también admiten interpolación de cadenas.

Como puedes ver, hay muchas formas de manejar saltos de línea y cadenas multilineales en Ruby. Encontrarás todos estos métodos mientras trabajas con código Ruby existente, ya que cada proyecto tiende a tener su propio estilo. En tu propio código, elige el estilo que sea adecuado para ti y sé consistente.

Replicación de cadenas

Puede haber momentos en los que necesites usar Ruby para repetir una cadena de caracteres varias veces. Puedes hacerlo con el operador *. Al igual que el operador +, el operador * tiene un uso diferente cuando se usa con números, donde es el operador de multiplicación. Cuando se usa con una cadena y un número entero, * es el operador de replicación de cadenas, repitiendo una única cadena tantas veces como desees usando el número entero que proporcionas.

Para imprimir Sammy nueve veces, usarías el siguiente código:

print "Sammy" * 9

Este código produce la siguiente salida:

Output
SammySammySammySammySammySammySammySammySammy

Puedes usar esto para crear un bonito arte ASCII. Crea un archivo llamado banner.rb y agrega el siguiente código:

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

¿Puedes imaginar qué producirá el programa antes de ejecutarlo?

Produce esta salida:

Output
===============
| Hello World |
===============

Este es solo un pequeño ejemplo de cómo puedes hacer que la computadora realice tareas repetitivas por ti.

Conclusión

En este tutorial, aprendiste cómo trabajar con el tipo de dato string en el lenguaje de programación Ruby. Creaste nuevas cadenas, las concatenaste con otras cadenas y manejaste saltos de línea, comillas y apóstrofos. Luego, usaste interpolación de cadenas para hacer más fácil mezclar cadenas y valores de variables, y aprendiste cómo repetir cadenas.