Cuerdas en Golang

Posted on by Rudeus Greyrat

En el lenguaje Go, las strings son diferentes de otros lenguajes como Java , C++ , Python , etc. Es una secuencia de caracteres de ancho variable donde todos y cada uno de los caracteres están representados por uno o más bytes usando la codificación UTF-8 . O, en otras palabras, las strings son la string inmutable de bytes arbitrarios (incluidos los bytes con valor cero) o la string es una porción de bytes de solo lectura y los bytes de las strings se pueden representar en el texto Unicode mediante la codificación UTF-8.
Debido a la codificación UTF-8, la string Golang puede contener un texto que es una mezcla de cualquier idioma presente en el mundo, sin ninguna confusión ni limitación de la página. Generalmente, las strings se escriben entre comillas dobles””, como se muestra en el siguiente ejemplo:

Ejemplo:

// Go program to illustrate
// how to create strings
package main
  
import "fmt"
  
func main() {
  
    // Creating and initializing a
    // variable with a string
    // Using shorthand declaration
    My_value_1 := "Welcome to GeeksforGeeks"
  
    // Using var keyword
    var My_value_2 string
    My_value_2 = "GeeksforGeeks"
  
    // Displaying strings
    fmt.Println("String 1: ", My_value_1)
    fmt.Println("String 2: ", My_value_2)
}

Producción:

String 1:  Welcome to GeeksforGeeks
String 2:  GeeksforGeeks

Nota: la string puede estar vacía, pero no es nula.

Literales de string

En el lenguaje Go, los literales de string se crean de dos maneras diferentes:

  • Usando comillas dobles («»): aquí, los literales de string se crean usando comillas dobles («»). Este tipo de string admite el carácter de escape, como se muestra en la siguiente tabla, pero no abarca varias líneas. Este tipo de literales de string se usa mucho en los programas de Golang.
    Personaje de escape Descripción
    \\ barra invertida(\)
    \000 Carácter Unicode con el punto de código octal de 8 bits de 3 dígitos dado
    \’ Una frase (‘). Solo se permite dentro de caracteres literales
    \” Comillas dobles (“). Solo se permite dentro de literales de string interpretados
    \a Campana ASCII (BEL)
    \b Retroceso ASCII (BS)
    \F Alimentación de formulario ASCII (FF)
    \norte Salto de línea ASCII (LF
    \r Retorno de carro ASCII (CR)
    \t Pestaña ASCII (TAB)
    \uhhhh Carácter Unicode con el punto de código hexadecimal de 16 bits de 4 dígitos dado.
    Carácter Unicode con el punto de código hexadecimal de 32 bits de 8 dígitos dado.
    \v Tabulador vertical ASCII (VT)
    \xhh Carácter Unicode con el punto de código hexadecimal de 8 bits de 2 dígitos dado.
  • Usando backticks(“): aquí, los literales de string se crean usando backticks(“) y también se conocen como raw literals. Los literales sin procesar no admiten caracteres de escape, pueden abarcar varias líneas y pueden contener cualquier carácter excepto el acento grave. Generalmente, se utiliza para escribir mensajes de varias líneas, en expresiones regulares y en HTML.

    Ejemplo:

    // Go program to illustrate string literals
    package main
      
    import "fmt"
      
    func main() {
      
        // Creating and initializing a
        // variable with a string literal
        // Using double-quote
        My_value_1 := "Welcome to GeeksforGeeks"
      
        // Adding escape character
        My_value_2 := "Welcome!\nGeeksforGeeks"
      
        // Using backticks
        My_value_3 := `Hello!GeeksforGeeks`
      
        // Adding escape character
        // in raw literals
        My_value_4 := `Hello!\nGeeksforGeeks`
      
        // Displaying strings
        fmt.Println("String 1: ", My_value_1)
        fmt.Println("String 2: ", My_value_2)
        fmt.Println("String 3: ", My_value_3)
        fmt.Println("String 4: ", My_value_4)
    }

    Producción:

    String 1:  Welcome to GeeksforGeeks
String 2:  Welcome!
GeeksforGeeks
String 3:  Hello!GeeksforGeeks
String 4:  Hello!\nGeeksforGeeks

Puntos importantes sobre la string

  • Las strings son inmutables: en el lenguaje Go, las strings son inmutables una vez que se crea una string, el valor de la string no se puede cambiar. O, en otras palabras, las strings son de solo lectura. Si intenta cambiar, el compilador arrojará un error.

    Ejemplo:

    // Go program to illustrate
    // string are immutable
    package main
      
    import "fmt"
      
    // Main function
    func main() {
      
        // Creating and initializing a string
        // using shorthand declaration
        mystr := "Welcome to GeeksforGeeks"
      
        fmt.Println("String:", mystr)
      
        /* if you trying to change
              the value of the string
              then the compiler will
              throw an error, i.e,
             cannot assign to mystr[1]
      
           mystr[1]= 'G'
           fmt.Println("String:", mystr)
        */
      
    }

    Producción:

    String: Welcome to GeeksforGeeks
  • ¿Cómo iterar sobre una string?: Puede iterar sobre una string usando for rang loop. Este bucle puede iterar sobre el punto de código Unicode de una string.

    Sintaxis:

    for index, chr:= range str{
     // Statement..
}

    Aquí, el índice es la variable que almacena el primer byte del punto de código codificado en UTF-8 y chr almacena los caracteres de la string dada y str es una string.

    Ejemplo:

    // Go program to illustrate how
    // to iterate over the string
    // using for range loop
    package main
      
    import "fmt"
      
    // Main function
    func main() {
      
        // String as a range in the for loop
        for index, s := range "GeeksForGeeKs" {
          
            fmt.Printf("The index number of %c is %d\n", s, index)
        }
    }

    Producción:

    The index number of G is 0
The index number of e is 1
The index number of e is 2
The index number of k is 3
The index number of s is 4
The index number of F is 5
The index number of o is 6
The index number of r is 7
The index number of G is 8
The index number of e is 9
The index number of e is 10
The index number of K is 11
The index number of s is 12
  • ¿Cómo acceder al byte individual de la string?: La string es de un byte, por lo que podemos acceder a cada byte de la string dada.

    Ejemplo:

    // Go program to illustrate how to
    // access the bytes of the string
    package main
      
    import "fmt"
      
    // Main function
    func main() {
      
        // Creating and initializing a string
        str := "Welcome to GeeksforGeeks"
      
        // Accessing the bytes of the given string
        for c := 0; c < len(str); c++ {
      
            fmt.Printf("\nCharacter = %c Bytes = %v", str, str)
        }
    }

    Producción:

    Character = W Bytes = 87
Character = e Bytes = 101
Character = l Bytes = 108
Character = c Bytes = 99
Character = o Bytes = 111
Character = m Bytes = 109
Character = e Bytes = 101
Character =   Bytes = 32
Character = t Bytes = 116
Character = o Bytes = 111
Character =   Bytes = 32
Character = G Bytes = 71
Character = e Bytes = 101
Character = e Bytes = 101
Character = k Bytes = 107
Character = s Bytes = 115
Character = f Bytes = 102
Character = o Bytes = 111
Character = r Bytes = 114
Character = G Bytes = 71
Character = e Bytes = 101
Character = e Bytes = 101
Character = k Bytes = 107
Character = s Bytes = 115
  • ¿Cómo crear una string a partir del segmento?: En el lenguaje Go, puede crear una string a partir del segmento de bytes.

    Ejemplo:

    // Go program to illustrate how to
    // create a string from the slice
      
    package main
      
    import "fmt"
      
    // Main function
    func main() {
      
        // Creating and initializing a slice of byte
        myslice1 := []byte{0x47, 0x65, 0x65, 0x6b, 0x73}
      
        // Creating a string from the slice
        mystring1 := string(myslice1)
      
        // Displaying the string
        fmt.Println("String 1: ", mystring1)
      
        // Creating and initializing a slice of rune
        myslice2 := []rune{0x0047, 0x0065, 0x0065, 
                                   0x006b, 0x0073}
      
        // Creating a string from the slice
        mystring2 := string(myslice2)
      
        // Displaying the string
        fmt.Println("String 2: ", mystring2)
    }

    Producción:

    String 1:  Geeks
String 2:  Geeks
  • ¿Cómo encontrar la longitud de la string?: En Golang string, puede encontrar la longitud de la string usando dos funciones, una es len() y otra es RuneCountInString() . El paquete UTF-8 proporciona la función RuneCountInString(), esta función devuelve el número total de runas presentes en la string. Y la función len() devuelve el número de bytes de la string.

    Ejemplo:

    // Go program to illustrate how to
    // find the length of the string
      
    package main
      
    import (
        "fmt"
        "unicode/utf8"
    )
      
    // Main function
    func main() {
      
        // Creating and initializing a string
        // using shorthand declaration
        mystr := "Welcome to GeeksforGeeks ??????"
      
        // Finding the length of the string
        // Using len() function
        length1 := len(mystr)
      
        // Using RuneCountInString() function
        length2 := utf8.RuneCountInString(mystr)
      
        // Displaying the length of the string
        fmt.Println("string:", mystr)
        fmt.Println("Length 1:", length1)
        fmt.Println("Length 2:", length2)
      
    }

    Producción:

    string: Welcome to GeeksforGeeks ??????
Length 1: 31
Length 2: 31

Publicación traducida automáticamente

Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *