One place for hosting & domains

      cadenas

      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 escapeFormato que proporciona
      Barra diagonal inversa
      Comillas dobles
      nSalto de línea
      tTabulació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