Go
Cuerda

Introducción

Sintaxis

• variableName: = "Hello World" // declara una cadena
• variableName: = `Hello World` // declara una cadena literal en bruto
• variableName: = "Hola" + "Mundo" // concatena cadenas
• substring: = "Hello World" [0: 4] // obtener una parte de la cadena
• letter: = "Hello World" [6] // obtener un carácter de la cadena
• fmt.Sprintf ("% s", "Hello World") // formatea una cadena

Tipo de cadena

El tipo de string permite almacenar texto, que es una serie de caracteres. Hay múltiples formas de crear cadenas. Se crea una cadena literal escribiendo el texto entre comillas dobles.

text := "Hello World"

Debido a que las cadenas Go son compatibles con UTF-8, el ejemplo anterior es perfectamente válido. Las cadenas contienen bytes arbitrarios, lo que no significa necesariamente que todas las cadenas contengan UTF-8 válido, pero los literales de cadena siempre tendrán secuencias UTF-8 válidas.

El valor cero de las cadenas es una cadena vacía "" .

Las cadenas se pueden concatenar usando el operador + .

text := "Hello " + "World"

Las cadenas también pueden definirse usando backticks `` . Esto crea un literal de cadena sin formato que significa que los caracteres no se escaparán.

text1 := "Hello\nWorld"
text2 := `Hello
World`

En el ejemplo anterior, text1 escapa al carácter \n que representa una nueva línea, mientras que text2 contiene el nuevo carácter de línea directamente. Si comparas text1 == text2 el resultado será true .

Sin embargo, text2 := `Hello\nWorld` no escapará al carácter \n , lo que significa que la cadena contiene el texto Hello\nWorld sin una nueva línea. Sería el equivalente de escribir text1 := "Hello\\nWorld" .

Formato de texto

El paquete fmt implementa funciones para imprimir y formatear texto usando verbos de formato. Los verbos se representan con un signo de porcentaje.

Verbos generales

%v    // the value in a default format
      // when printing structs, the plus flag (%+v) adds field names
%#v   // a Go-syntax representation of the value
%T    // a Go-syntax representation of the type of the value
%%    // a literal percent sign; consumes no value

Booleano

%t    // the word true or false

Entero:

%b    // base 2
%c    // the character represented by the corresponding Unicode code point
%d    // base 10
%o    // base 8
%q    // a single-quoted character literal safely escaped with Go syntax.
%x    // base 16, with lower-case letters for a-f
%X    // base 16, with upper-case letters for A-F
%U    // Unicode format: U+1234; same as "U+%04X"

Elementos de coma flotante y complejos:

%b    // decimalless scientific notation with exponent a power of two,
      // in the manner of strconv.FormatFloat with the 'b' format,
      // e.g. -123456p-78
%e    // scientific notation, e.g. -1.234456e+78
%E    // scientific notation, e.g. -1.234456E+78
%f    // decimal point but no exponent, e.g. 123.456
%F    // synonym for %f
%g    // %e for large exponents, %f otherwise
%G    // %E for large exponents, %F otherwise

Cadena y segmento de bytes (tratados de manera equivalente con estos verbos):

%s    // the uninterpreted bytes of the string or slice
%q    // a double-quoted string safely escaped with Go syntax
%x    // base 16, lower-case, two characters per byte
%X    // base 16, upper-case, two characters per byte

Puntero:

%p    // base 16 notation, with leading 0x

Usando los verbos, puedes crear cadenas que concatenen múltiples tipos:

text1 := fmt.Sprintf("Hello %s", "World")
text2 := fmt.Sprintf("%d + %d = %d", 2, 3, 5)
text3 := fmt.Sprintf("%s, %s (Age: %d)", "Obama", "Barack", 55)

La función Sprintf formatea la cadena en el primer parámetro, reemplazando los verbos con el valor de los valores en los siguientes parámetros y devuelve el resultado. Al igual que Sprintf , la función Printf también se formatea, pero en lugar de devolver el resultado, imprime la cadena.

paquete de cuerdas

• strings.Contains

  fmt.Println(strings.Contains("foobar", "foo")) // true
  fmt.Println(strings.Contains("foobar", "baz")) // false
  

• strings.HasPrefix

  fmt.Println(strings.HasPrefix("foobar", "foo")) // true
  fmt.Println(strings.HasPrefix("foobar", "baz")) // false
  

• strings.HasSuffix

  fmt.Println(strings.HasSuffix("foobar", "bar")) // true
  fmt.Println(strings.HasSuffix("foobar", "baz")) // false
  

• strings.Join

  ss := []string{"foo", "bar", "bar"}
  fmt.Println(strings.Join(ss, ", ")) // foo, bar, baz
  

• strings.Replace

  fmt.Println(strings.Replace("foobar", "bar", "baz", 1)) // foobaz
  

• strings.Split

  s := "foo, bar, bar"
  fmt.Println(strings.Split(s, ", ")) // [foo bar baz]
  

• strings.ToLower

  fmt.Println(strings.ToLower("FOOBAR")) // foobar
  

• strings.ToUpper

  fmt.Println(strings.ToUpper("foobar")) // FOOBAR
  

• strings.TrimSpace

  fmt.Println(strings.TrimSpace("  foobar  ")) // foobar
  

Más: https://golang.org/pkg/strings/ .