One place for hosting & domains

      cadenas

      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."
      

      Nota: Si está familiarizado con otros lenguajes de programación, es posible que haya escrito la variable como sammy. En Go, sin embargo, se prefieren los nombres de variables más cortos. Elegir s para el nombre de la variable en este caso se consideraría más apropiado para el estilo en el que Go está escrito.

      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.



      Source link

      Cómo dar formato a cadenas en Go


      Debido a que las cadenas suelen estar compuestas de texto escrito, hay muchos casos en los que posiblemente queramos tener un control más amplio sobre su apariencia para que los humanos puedan leerlas con mayor facilidad mediante puntuación, saltos de línea y sangrías.

      En este tutorial, repasaremos algunas de las maneras en las que podemos trabajar con las cadenas de Go para asegurarnos de que todo el texto de salida tenga el formato correcto.

      Literales de cadena

      Primero, diferenciaremos un literal de cadena de un valor de cadena. Un literal de cadena es lo que vemos en el código fuente de un programa informático, incluidas las comillas. Un valor de cadena es lo que vemos cuando invocamos la función fmt.Println y ejecutamos el programa.

      En el programa “Hello, World!”, el literal de cadena es “Hello, World!” y el valor de cadena es Hello, World! sin las comillas. El valor de cadena es lo que vemos como resultado en una ventana del terminal cuando ejecutamos un programa de Go.

      Sin embargo, es posible que para algunos valores de cadena se deban incluir comillas, como cuando citamos a una fuente. Debido a que los literales y los valores de cadena no son equivalentes, a menudo es necesario añadir formato adicional a los literales para permitir que los valores se muestren de la manera deseada.

      Citas

      Debido a que en Go podemos usar comillas invertidas (`) o comillas dobles ("), es sencillo insertar citas en una cadena usando comillas dobles dentro de una cadena encerrada entre comillas invertidas:

      `Sammy says, "Hello!"`
      

      Alternativamente, para usar comillas invertidas se puede encerrar la cadena entre comillas dobles:

      "Sammy likes the `fmt` package for formatting strings.."
      

      Al combinar comillas invertidas y dobles, podemos controlar la visualización de las comillas en nuestras cadenas.

      Es importante recordar que las comillas inversas en Go crean un literal de cadena raw y que las comillas dobles crean un literal de cadena interpreted. Para obtener más información sobre esta diferencia, lea el tutorial Introducción al trabajo con cadenas en Go.

      Caracteres de escape

      Otra opción para dar formato a las cadenas es usar un carácter de escape. Los caracteres de escape se utilizan para indicar al código que el siguiente carácter tiene un significado especial. Los caracteres de escape comienzan con una barra diagonal inversa () en combinación con otro carácter dentro de una cadena para dar cierto formato a la cadena.

      Esta es una lista de varios de los caracteres de escape comunes:

      Carácter de escape Formato que proporciona
      Barra diagonal inversa
      Comillas dobles
      n Salto de línea
      t Tabulación (sangría)

      Emplearemos un carácter de escape para añadir las comillas al ejemplo de comillas anteriores, pero esta vez usaremos comillas dobles para denotar la cadena:

      fmt.Println("Sammy says, "Hello!"")
      

      Output

      Sammy says, "Hello!"

      Al usar el carácter de escape ", podemos usar comillas dobles para encerrar una cadena que incluya texto entre comillas dobles.

      Podemos usar el carácter de escape n para insertar saltos de línea sin tener pulsar la tecla Intro:

      fmt.Println("This stringnspans multiplenlines.")
      

      Output

      This string spans multiple lines.

      También podemos combinar caracteres de escape. Imprimiremos una cadena de varias líneas e incluiremos sangrías para una lista detallada, por ejemplo:

      fmt.Println("1.tSharkn2.tShrimpn10.tSquid")
      

      Output

      1. Shark 2. Shrimp 10. Squid

      La sangría que cuenta con el carácter de escape t garantiza la alineación dentro de la segunda columna del ejemplo anterior, lo cual hace que el resultado sea sumamente fácil de leer para los seres humanos.

      Los caracteres de escape se utilizan para añadir formato a cadenas que pueden ser difíciles, o imposibles, de lograr. Sin caracteres de escape, no podría crear la cadena Sammy says, "I like to use the `fmt` package".

      Líneas múltiples

      La impresión de cadenas en varias líneas puede facilitar la lectura del texto para los humanos. Con varias líneas, las cadenas pueden agruparse en un texto prolijo y ordenado, recibir formato de carta o usarse para mantener los saltos de línea de un poema o la letra de una canción.

      Para crear una cadena que abarque varias líneas, se usan comillas invertidas para encerrar la cadena. Tenga en cuenta que, si bien esto preserva los saltos de línea, también crea un literal de cadena raw.

      `
      This string is on
      multiple lines
      within three single
      quotes on either side.
      `
      

      Al imprimir esto, notará que hay un salto al principio y otro al final:

      Output

      This string is on multiple lines within three single quotes on either side.

      Para evitar que esto suceda, debe disponer la primera línea inmediatamente después de la comilla invertida y terminar la última con otra comilla invertida.

      `This string is on
      multiple lines
      within three single
      quotes on either side.`
      

      Si debe crear un literal de cadena interpretado, puede hacerlo con comillas dobles y el operador +, pero tendrá que insertar sus propios saltos de línea.

      "This string is onn" +
      "multiple linesn" +
      "within three singlen" +
      "quotes on either side."
      

      Si bien las comillas invertidas pueden facilitar la impresión y la lectura de textos largos, si necesita un literal de cadena interpretado, tendrá que usar comillas dobles.

      Literales de cadena sin formato

      ¿Qué sucede si no deseamos que nuestras cadenas tengan un formato especial? Por ejemplo, es posible que debamos comparar o evaluar cadenas de código informático que utilizan la barra diagonal inversa a propósito, por lo cual no nos convendrá que Go la utilice como carácter de escape.

      Un literal de cadena raw indica a Go que ignore todo el formato de una cadena, incluidos los caracteres de escape.

      Creamos una cadena sin formato rodeándola con comillas invertidas:

      fmt.Println(`Sammy says,"The balloon's color is red."`)
      

      Output

      Sammy says,"The balloon's color is red."

      Al crear una cadena sin formato encerrada entre comillas invertidas, podemos mantener las barras diagonales inversas y otros caracteres que se utilizan como caracteres de escape.

      Conclusión

      En este tutorial, repasamos varias maneras de dar formato a texto en Go al trabajar con cadenas. Al usar técnicas como los caracteres de escape o las cadenas sin formato, podemos garantizar que las cadenas de nuestro programa se representen de forma correcta en la pantalla para que el usuario final pueda leer fácilmente todo el texto de salida.



      Source link