Introducción al uso de cadenas en Go

Una cadena es una secuencia de uno o más caracteres (letras, números y símbolos) que puede ser una constante o una variable. Las cadenas, compuestas por Unicode, son secuencias inmutables, lo cual significa que no cambian.

Debido a que el texto es una forma de datos común que usamos en la vida cotidiana, el tipo de datos de cadena es un elemento fundamental de la programación.

En este tutorial de Go se repasará la forma de crear e imprimir cadenas, concatenarlas y replicarlas, y guardarlas en variables.

Literales de cadena

En Go, las cadenas existen dentro de comillas invertidas ` (a veces llamadas tildes inversas) o comillas dobles ". Dependiendo de las comillas que utilice, la cadena tendrá diferentes características.

Si se usan comillas inversas, como en ` ```bar``` `, se creará un literal de cadena sin formato. En un literal de cadena sin formato, cualquier carácter puede aparecer entre comillas, con la excepción de las comillas inversas. Aquí se ofrece un ejemplo de un literal de cadena sin formato:

`Say "hello" to Go!`

Las barras diagonales inversas no tienen un significado especial dentro de los literales de cadena sin formato. Por ejemplo, \n aparecerá como los caracteres reales, la barra diagonal inversa \ y la letra n. A diferencia de los literales de cadena interpretados, en los cuales \n insertará una nueva línea real.

Los literales de cadena sin formato también pueden usarse para crear cadenas de varias líneas:

`Go is expressive, concise, clean, and efficient.
Its concurrency mechanisms make it easy to write programs
that get the most out of multi-core and networked machines,
while its novel type system enables flexible and modular
program construction. Go compiles quickly to machine code
yet has the convenience of garbage collection and the power
of run-time reflection. It's a fast, statically typed,
compiled language that feels like a dynamically typed,
interpreted language.`

Los literales de cadena interpretados son secuencias de caracteres entre dobles comillas, como en "bar". Dentro de las comillas, puede aparecer cualquier carácter, con la excepción de las comillas de nueva línea y las comillas dobles sin escapes.

"Say \"hello\" to Go!"

Casi siempre usará literales de cadena interpretados porque permiten caracteres con escapes dentro de ellas.

Ahora que comprende la manera en que aplica formato a las cadenas en Go, veremos la forma en que puede imprimir cadenas en programas.

Imprimir cadenas

Puede imprimir cadenas usando el paquete fmt de la biblioteca del sistema e invocando la función PrintIn():

fmt.Println("Let's print out this string.")

Output
Let's print out this string.

Debe aplicar import a paquetes del sistema cuando los utilice. Por lo tanto, un programa sencillo para imprimir una cadena tendría este aspecto:

package main

import "fmt"

func main() {
	fmt.Println("Let's print out this string.")
}

Concatenación de cadenas

La concatenación implica unir cadenas de extremo a extremo para crear una cadena nueva. Puede concatenar cadenas con el operador +. Tenga en cuenta que cuando trabaje con números, + será un operador para sumar, pero cuando se use con cadenas, será un operador de unión.

Combinaremos los literales de cadena "Sammy"y "Shark" con una concatenación a través de la instrucción fmt.PrintIn():

fmt.Println("Sammy" + "Shark")

Output
SammyShark

Si desea un espacio en blanco entre las dos cadenas, simplemente puede incluir el espacio en blanco en una. En este ejemplo, añada el espacio en blanco entre las comillas después de Sammy:

fmt.Println("Sammy " + "Shark")

Output
Sammy Shark

El operador + no puede usarse entre dos tipos de datos diferentes. Como ejemplo, no puede concatenar cadenas y enteros. Si intenta escribir lo siguiente:

fmt.Println("Sammy" + 27)

Verá los siguientes errores:

Output
cannot convert "Sammy" (type untyped string) to type int
invalid operation: "Sammy" + 27 (mismatched types string and int)

Si desea crear la cadena "Sammy27", podría hacerlo disponiendo el número 27 entre comillas ("27") de modo que deje de ser un entero y sea, en su lugar, una cadena. Convertir números a cadenas para su concanetación puede ser útil al manejar códigos postales o números de teléfono. Por ejemplo, no le convendría realizar una suma entre un código de país y un código de área, pero sí le convendrá que se mantengan juntos.

Cuando combina dos o más cadenas a través de una concatenación, crea una nueva cadena que puede usar en su programa.

Almacenar cadenas en variables

Las variables son símbolos que puede usar para guardar datos en un programa. Puede imaginarlas como cajas vacías que llena con datos o valores. Las cadenas son datos. Por lo tanto, puede usarlas para completar una variable. Declarar cadenas como variables puede hacer que sea más fácil trabajar con cadenas en sus programas de Go.

Para guardar una cadena dentro de una variable, simplemente asigne una variable a una cadena. En este caso, declare s como su variable:

s := "Sammy likes declaring strings."

Ahora que fijó la variable s en esa cadena concreta, puede imprimirla de esta forma:

fmt.Println(s)

Luego, recibirá el siguiente resultado:

Output
Sammy likes declaring strings.

Al usar las variables como sustitutas de las cadenas, no es necesario que vuelva a escribir una cadena cada vez que desee usarla, lo cual hace que sea más sencillo trabajar con cadenas y manipularlas en sus programas.

Conclusión

En este tutorial, se explicaron los aspectos básicos necesarios para trabajar con el tipo de dato de cadenas en el lenguaje de programación Go. Crear cadenas, imprimirlas, concatenarlas, replicarlas y guardarlas en variables le brindará lo esencial para usar cadenas en sus programas de Go.