Ir a las operaciones básicas de cuerdas

Cadenas Las cadenas en el
idioma Go aparecen como tipos de datos nativos. Usar cadenas es como usar otros tipos de datos nativos. La implementación interna de las cadenas del idioma Go está codificada en utf-8 y el valor de la cadena está entre comillas dobles " "Contenido, puede agregar directamente
el escape de cadenas de caracteres no ASCII en el código fuente del idioma Go.
\ R Retorno de carro \ n Salto de línea \ t Carácter de tabulación \ 'Comillas simples \" Comillas dobles \ Barra invertida
Cadena de varias líneas
Ir al idioma Cuando desee especificar una cadena de varias líneas, debe usar comillas invertidas ''

package main

import "fmt"
func main() {
    
    
    s := `
        君不见
        黄河之水天上来
        奔流到海不复回
    `
    fmt.Print(s)
}

Operaciones comunes en cadenas

package main

import (
    "fmt"
    "strings"
)
func main() {
    
    
    s := "sdfasdfa"
    //求长度
    fmt.Println(len(s)) //8
    //拼接字符串
    ss := s + "sdfasdf"
    fmt.Println(ss)
    fmt.Sprintln(s, ss) //sdfasdfasdfasdf
    //以什么什么字符分割,
    arr := strings.Split(ss, "a")
    fmt.Printf("%v\n", arr) //[sdf sdf sdf sdf]
    //判断是否包含
    b := strings.Contains(ss, "sdf")
    fmt.Printf("%T--%v\n", b, b) //bool--true
    //判断以什么什么开头
    b1 := strings.HasPrefix(ss, "sdf")
    fmt.Printf("%T--%v\n", b1, b1) //bool--true
    //判断以什么什么结尾
    b2 := strings.HasSuffix(ss, "sdf")
    fmt.Printf("%T--%v\n", b2, b2) //bool--true
    //子串出现的位置
    i := strings.Index(ss, "a")
    fmt.Printf("%T--%v\n", i, i) //int--3
    //join操作
    s1 := strings.Join(arr, "00")
    fmt.Printf("%T--%v\n", s1, s1) //string--sdf00sdf00sdf00sdf
}

Tipos de bytes y runas
Cada elemento de una cadena se denomina carácter, y el carácter se obtiene atravesando u obteniendo un solo elemento de cadena.
Hay dos tipos de caracteres en el idioma Go,

package main

import (
    "fmt"
)
func main() {
    
    
s := "sdfasdfa" 
//遍历字符串
    for _, sss := range s {
    
    
        fmt.Print(string(sss))
    }
}

El tipo uint8, también llamado byte representa un carácter de
tipo ASCII int32, también llamado runa representa un carácter UTF-8.
Cuando necesita tratar con caracteres chinos, japoneses y otros caracteres compuestos, necesita el tipo de runa, el tipo de runa es en realidad int32
Go usa El procesamiento especial de tipos Unicode hace que sea más conveniente procesar texto basado en Unicode. Puede usar bytes para el procesamiento de cadenas predeterminado. Se cuidan el rendimiento y la escalabilidad.
Modificación de la cadena
Para modificar la cadena, debe convertirla a [] runa o [] byte, cambie a cadena después de la finalización, sin importar qué tipo de conversión, reasigne la memoria y copie la matriz de bytes

package main

import (
    "fmt"
)
func main() {
    
    
    s := "sdfasdfa"
    ss := []rune(s)
    ss[4] = '董'
    fmt.Println(string(ss))
}