Cuerdas de golang

Una cadena se refiere a una secuencia de uno o más caracteres, incluidas letras, números y caracteres especiales. Las cadenas son un concepto crítico en la mayoría de los lenguajes de programación a pesar de la definición simplista.

Esto se debe a que las cadenas nos ayudan a trabajar con información textual dentro de nuestros programas. Por lo general, es difícil construir una aplicación no trivial sin usar cuerdas.

En esta guía, cubriremos los conceptos básicos de trabajar con cuerdas en el lenguaje de programación GO.

Que es una cadena?

En Go, nos referimos a una cadena como una porción de solo lectura de bytes. Podemos crear una cadena en GO encerrando la secuencia de caracteres dentro de citas dobles o citas de retroceso.

Tenga en cuenta que el método que utiliza para crear una cadena en Go Matters.

Usar tics posteriores (") para crear una cadena en Go crea una cadena en bruto literal. Una cadena en bruto literal significa que la cadena puede contener cualquier carácter, excepto por una marca de fondo.

El siguiente ejemplo muestra una cadena en bruto literal.

raw_string: = 'Esta es una cadena'

A diferencia de los literales de cadena interpretados creados con citas dobles, los personajes de la reacción violenta no tienen una denotación especial dentro de una cadena en bruto literal. Por ejemplo, \ n, que puede insertar un carácter de nueva línea en cadenas interpretadas, lo imprimimos como está en literales de cadenas sin procesar.

Para crear una cadena interpretada literal en GO, encienda el conjunto de caracteres en cotizaciones dobles, como se muestra en el siguiente ejemplo:

interpretado_string: = "Esta es una cadena"

Aquí, los personajes de la reacción se interpretan para tener un significado especial. Por ejemplo, para insertar una nueva línea en la cadena, podemos usar \ n como:

interpretado_string: = "Esta es \ n una cadena"

Es común usar la cadena interpretada literal, ya que le permiten agregar caracteres especiales y secuencias de escape.

Ir, imprima cadena

Puede imprimir una cadena en Go usando el método println () desde el paquete FMT. Asegúrese de importar el paquete antes de llamar al método. Un código de ejemplo es como se muestra:

paquete principal
importar "fmt"
func Main ()
fmt.Println ("Esta es una cadena")

El código anterior usa el FMT.Método println () para imprimir una cadena interpretada literal. También puede almacenar una cadena como una variable y hacer referencia en el método como se muestra:

paquete principal
importar "fmt"
func Main ()
my_string: = "Esta es una cadena"
fmt.Println (my_string)

Operaciones de cadena en Go

Hay una colección de operaciones que puede realizar en tipos de cadenas. GO proporciona un conjunto de métodos para realizar operaciones de cadena en el paquete de cadenas.

https: // pkg.ir.dev/strings

Vamos a mirar algunas operaciones que puedes realizar en cadenas.

Concatenación de cuerdas

La concatenación de cadenas se refiere a la técnica de combinar dos o más literales de cadena para crear una nueva cadena.

En Go, podemos concatenar cadenas usando el operador de adición (+).

Por ejemplo, combinemos las cadenas "Linux" y "Sugerencia" como se muestra.

paquete principal
importar "fmt"
func Main ()
fmt.Println ("Linux" + "Sugerencia")

Si ejecutamos el código anterior, debemos obtener una salida como:

$ Go Run Golang_strings.ir
Linuxhint

Tenga en cuenta que no puede usar el operador de adición (+) con valores de diferentes tipos. Por ejemplo, si intenta concatenar una cadena y un int, recibirá un error como:

fmt.Println ("Linux" + 12)

El código anterior devuelve un error como:

Operación no válida: "Linux" + 12 (tipos no coincidentes Cadena sin tipo e int típado)

Una forma de superar esto es encerrar ambos valores en quotas dobles. Esto convierte el valor numérico en una cadena, lo que le permite realizar la concatenación de la cadena.

La concatenación de cadenas siempre da como resultado una nueva cadena que puede almacenar en una variable y reutilizar en otras partes de su programa.

Convertir la cadena en minúsculas o mayúsculas

Como se mencionó, GO nos proporciona el paquete Strings, que le permite realizar operaciones en tipos de cadenas.

Dos métodos útiles del paquete son ToLower y Toupper, que convierten una cadena en minúsculas y mayúsculas, respectivamente.

Nota: En Go, los tipos de cadenas son inmutables. Esto significa que no puede cambiar el valor original de la cadena una vez creado.

El ejemplo a continuación convierte la cadena "Linuxhint" en minúsculas.

paquete principal
importar "fmt"
importar "cadenas"
func Main ()
my_string: = "linuxhint"
fmt.Println (cadenas.Tolower (my_string))

La función tolower () toma la cadena para convertirse en minúsculas como argumento. Luego devuelve la secuencia de caracteres de la cadena convertida en minúsculas. La función devuelve una nueva cadena, ya que las cadenas son tipos de datos inmutables.

Si ejecutamos el código anterior, debemos obtener una salida como:

Linuxhint

Para convertir una cadena en mayúsculas, podemos usar el método toupper (), como se muestra en el siguiente ejemplo:

my_string: = "linuxhint"
fmt.Println (cadenas.Toupper (my_string))

La cadena resultante es como se muestra:

Linuxhint

Obtener longitud de cadena

Para obtener la longitud de una cadena en Go, puede usar el método Len () y pasar la cadena como argumento.

El método devolverá el número de caracteres en la cadena.

Por ejemplo:

my_string: = "linuxhint"
fmt.Println (len (my_string))

Una vez que ejecutamos el código anterior, debemos obtener el número de caracteres de la cadena como:

$ Go Run Golang_strings.ir
9

El número de caracteres, en este caso, se refiere a cualquier personaje incluido en citas dobles, incluidos símbolos y otros caracteres especiales.

Compruebe si la cadena contiene

También puede buscar una subcadena en Go utilizando el método Contiene. El método acepta la cadena principal para buscar la subcadena y la subcadena para buscar y como argumentos.

La función devuelve un valor booleano si se encuentra la subcadena y se falsa lo contrario.

Considere el ejemplo que se muestra a continuación:

paquete principal
importar (
"FMT"
"instrumentos de cuerda"
)
func Main ()
Full_string: = "Bienvenido a la programación de GO Langugae!"
fmt.Println (cadenas.Contiene (full_string, "ir"))

Una vez que ejecutamos el código anterior, debemos obtener una salida como:

$ Go Run Golang_strings.ir
verdadero

La subcadena "GO" se encuentra en la variable Full_String; la función devuelve verdadero.

Conclusión

Este tutorial cubre los conceptos básicos de trabajar con cuerdas en Go. Si está comenzando en Go, consulte nuestros tutoriales sobre el tema para obtener más información. También puede consultar la documentación para obtener información adicional.