Que signifie str dans le langage go ?

Dans le langage Go, str fait référence à "string", qui est une séquence d'octets immuable. Une chaîne peut contenir n'importe quelle donnée, mais est généralement utilisée pour contenir du texte lisible. Une chaîne est une séquence de caractères UTF-8 (lorsque le caractère est un caractère dans la table de codes ASCII, il occupe 1 octet et les autres caractères sont basés sur). Nécessite 2 à 4 octets). La chaîne est un type valeur et la valeur est immuable, c'est-à-dire qu'une fois qu'un texte est créé, le contenu du texte ne peut plus être modifié. Plus profondément, une chaîne est un tableau d'octets de longueur fixe.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

En langage go, str fait référence à "string".

Une chaîne est une séquence d'octets immuable. Une chaîne peut contenir des données arbitraires, mais est généralement utilisée pour contenir du texte lisible. Une chaîne est une séquence de caractères UTF-8 (lorsque les caractères sont des codes ASCII, les caractères de la table occupent 1. octet, les autres caractères occupent 2 à 4 octets selon les besoins).

L'implémentation interne des chaînes dans le langage Go utilise le codage UTF-8, et chaque caractère UTF-8 est facilement accessible via le type rune. Bien entendu, le langage Go prend également en charge l’accès caractère par caractère dans le code ASCII traditionnel.

UTF-8 est un format d'encodage largement utilisé et l'encodage standard pour les fichiers texte, notamment XML et JSON. En raison de l'incertitude sur la longueur d'octets occupée par cet encodage, les chaînes du langage Go peuvent également occuper 1 à 4 octets selon les besoins, ce qui est différent des autres langages de programmation comme C++, Java ou Python (Java toujours utilise 2 octets). Le langage Go fait cela non seulement pour réduire l'utilisation de la mémoire et de l'espace disque dur, mais n'a pas non plus besoin d'encoder et de décoder le texte en utilisant le jeu de caractères UTF-8 comme les autres langages.

String est un type valeur, et la valeur est immuable, c'est-à-dire qu'après avoir créé un certain texte, le contenu de ce texte ne peut plus être modifié. Plus profondément, une chaîne est un tableau d'octets de longueur fixe.

Définir des chaînes

Vous pouvez utiliser des guillemets doubles "" pour définir des chaînes. Les caractères d'échappement peuvent être utilisés dans les chaînes pour obtenir des sauts de ligne, des indentations et d'autres effets. Les caractères d'échappement couramment utilisés incluent :

• n : Caractère de saut de ligne<code>n：换行符

• r：回车符

• t：tab 键

• u 或 U：Unicode 字符

• \：反斜杠自身

package main
import (
    "fmt"
)
func main() {
    var str = "PHP中文网\nGo语言教程"
    fmt.Println(str)
}

运行结果为：

一般的比较运算符（==、!=、=、>）是通过在内存中按字节比较来实现字符串比较的，因此比较的结果是字符串自然编码的顺序。字符串所占的字节长度可以通过函数 len() 来获取，例如 len(str)。

字符串的内容（纯字节）可以通过标准索引法来获取，在方括号[ ]内写入索引，索引从 0 开始计数：

• 字符串 str 的第 1 个字节：str[0]

• 第 i 个字节：str[i - 1]

• 最后 1 个字节：str[len(str)-1]

需要注意的是，这种转换方案只对纯 ASCII 码的字符串有效。

注意：获取字符串中某个字节的地址属于非法行为，例如 &str[i]。

字符串拼接符“+”

两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。将 s2 追加到 s1 尾部并生成一个新的字符串 s。

可以通过下面的方式来对代码中多行的字符串进行拼接：

str := "Beginning of the string " +
"second part of the string"

提示：因为编译器会在行尾自动补全分号，所以拼接字符串用的加号“+”必须放在第一行末尾。

也可以使用“+=”来对字符串进行拼接：

s := "hel" + "lo,"
s += "world!"
fmt.Println(s) //输出 “hello, world!”

定义多行字符串

在Go语言中，使用双引号书写字符串的方式是字符串常见表达方式之一，被称为字符串字面量（string literal），这种双引号字面量不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用`反引号，代码如下：

const str = `第一行
第二行
第三行
\r\n
`
fmt.Println(str)

代码运行结果：

反引号`

r : Caractère de retour chariot

t : Touche de tabulation🎜🎜🎜u ou U : caractère Unicode 🎜🎜🎜\ : barre oblique inverse elle-même 🎜

const codeTemplate = `// Generated by github.com/davyxu/cellnet/
protoc-gen-msg
// DO NOT EDIT!{{range .Protos}}
// Source: {{.Name}}{{end}}
package {{.PackageName}}
{{if gt .TotalMessages 0}}
import (
    "github.com/davyxu/cellnet"
    "reflect"
    _ "github.com/davyxu/cellnet/codec/pb"
)
{{end}}
func init() {
    {{range .Protos}}
    // {{.Name}}{{range .Messages}}
    cellnet.RegisterMessageMeta("pb","{{.FullName}}", reflect.TypeOf((*{{.Name}})(nil)).Elem(), {{.MsgID}})    {{end}}
    {{end}}
}

🎜 run Le résultat est : 🎜🎜 🎜🎜 Les opérateurs de comparaison généraux (==, !=, =, >) implémentent la comparaison de chaînes en comparant les octets en mémoire, de sorte que le résultat de la comparaison est un caractère L'ordre de codage naturel des chaînes. La longueur en octets occupée par une chaîne peut être obtenue via la fonction len(), telle que len(str). 🎜🎜Le contenu de la chaîne (octets purs) peut être obtenu via la méthode d'indexation standard. Écrivez l'index entre crochets [], et l'index commence à compter à partir de 0 : 🎜🎜🎜🎜Le premier octet de la chaîne str : str[0]🎜🎜🎜i-ème octet : str[i - 1]🎜🎜🎜dernier 1 octet : str[len(str)-1]🎜🎜Il convient de noter que ce schéma de conversion n'est valide que pour les chaînes ASCII pures. 🎜🎜🎜Remarque : Il est illégal d'obtenir l'adresse d'un certain octet dans une chaîne, telle que &str[i]. 🎜🎜🎜🎜🎜Caractère d'épissage de chaîne "+"🎜🎜🎜🎜Deux chaînes s1 et s2 peuvent être épissées ensemble via s := s1 + s2. Ajoute s2 à la fin de s1 et génère une nouvelle chaîne s. 🎜🎜Vous pouvez raccorder plusieurs lignes de chaînes dans le code de la manière suivante : 🎜

package main

import "fmt"

func main() {

    //创建并初始化
    //带有字符串文字的变量
    //使用双引号
    My_value_1 := "Welcome to nhooo"

    //添加转义字符
    My_value_2 := "Welcome!\nnhooo"

    //使用反引号
    My_value_3 := `Hello!nhooo`

    //添加转义字符

    //原始文本
    My_value_4 := `Hello!\nnhooo`

    //显示
    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)
}

🎜🎜Conseils : étant donné que le compilateur complètera automatiquement les points-virgules à la fin de la ligne, le signe plus "+" utilisé pour raccorder les chaînes doit être à la fin de la première ligne. 🎜🎜🎜Vous pouvez également utiliser "+=" pour épisser des chaînes : 🎜

//字符串是不可变的
package main 
  
import "fmt"
  
func main() { 
  
        //创建和初始化字符串
        //使用简写声明
    mystr := "Welcome to nhooo"
  
    fmt.Println("String:", mystr) 
  
    /* 果你试图改变字符串的值，编译器将抛出一个错误,例如, 
     cannot assign to mystr[1] 
       mystr[1]= 'G' 
       fmt.Println("String:", mystr) 
    */
  
}

🎜🎜🎜Définir des chaînes multilignes 🎜🎜🎜🎜En langage Go, utiliser des guillemets doubles pour écrire des chaînes est une expression courante de chaînes. On l'appelle une chaîne littéral. Ce littéral entre guillemets ne peut pas s'étendre sur plusieurs lignes. Si vous souhaitez intégrer une chaîne multiligne dans le code source, vous devez utiliser ` pour l'inverser. 🎜

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

🎜Résultat d'exécution du code : 🎜🎜🎜🎜Le backtick ` est la touche à gauche de la touche 1 du clavier. La chaîne entre les deux backticks sera assignée à la variable str telle quelle. 🎜🎜De cette façon, les nouvelles lignes entre les backticks seront traitées comme des nouvelles lignes dans la chaîne, mais tous les caractères d'échappement seront invalides et le texte sera affiché tel quel. 🎜🎜Les chaînes multilignes sont généralement utilisées pour le code source intégré et les données intégrées, etc. Le code est le suivant : 🎜

const codeTemplate = `// Generated by github.com/davyxu/cellnet/
protoc-gen-msg
// DO NOT EDIT!{{range .Protos}}
// Source: {{.Name}}{{end}}
package {{.PackageName}}
{{if gt .TotalMessages 0}}
import (
    "github.com/davyxu/cellnet"
    "reflect"
    _ "github.com/davyxu/cellnet/codec/pb"
)
{{end}}
func init() {
    {{range .Protos}}
    // {{.Name}}{{range .Messages}}
    cellnet.RegisterMessageMeta("pb","{{.FullName}}", reflect.TypeOf((*{{.Name}})(nil)).Elem(), {{.MsgID}})    {{end}}
    {{end}}
}

这段代码只定义了一个常量 codeTemplate，类型为字符串，使用`定义，字符串的内容为一段代码生成中使用到的 Go 源码格式。

在`间的所有代码均不会被编译器识别，而只是作为字符串的一部分。

字符串字面量

在Go语言中，字符串字面量是通过两种不同的方式创建的：

• 使用双引号（""）：在这里，字符串字面量使用双引号（""）创建。此类字符串支持转义字符，如下表所示，但不跨越多行。这种类型的字符串文字在Golang程序中被广泛使用。

转义符	描述
\\	反斜杠（\）
\000	具有给定的3位8位八进制代码点的Unicode字符
\’	单引号（'）。仅允许在字符文字中使用
\”	双引号（""）。仅允许在解释的字符串文字中使用
\a	ASCII铃声(BEL)
\b	ASCII退格键(BS)
\f	ASCII换页(FF)
\n	ASCII换行符(LF)
\r	ASCII回车(CR)
\t	ASCII标签(TAB)
\uhhhh	具有给定的4位16位十六进制代码点的Unicode字符。
	具有给定的8位32位十六进制代码点的Unicode字符。
\v	ASCII垂直制表符(VT)
\xhh	具有给定的2位8位十六进制代码点的Unicode字符。

• 使用反引号（''）：此处，字符串文字是使用反引号（''）创建的，也称为raw literals(原始文本)。原始文本不支持转义字符，可以跨越多行，并且可以包含除反引号之外的任何字符。通常，它用于在正则表达式和HTML中编写多行消息。

package main

import "fmt"

func main() {

    //创建并初始化
    //带有字符串文字的变量
    //使用双引号
    My_value_1 := "Welcome to nhooo"

    //添加转义字符
    My_value_2 := "Welcome!\nnhooo"

    //使用反引号
    My_value_3 := `Hello!nhooo`

    //添加转义字符

    //原始文本
    My_value_4 := `Hello!\nnhooo`

    //显示
    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)
}

输出：

关于字符串的要点

• 字符串是不可变的：在Go语言中，一旦创建了字符串，则字符串是不可变的，无法更改字符串的值。换句话说，字符串是只读的。如果尝试更改，则编译器将引发错误。

//字符串是不可变的
package main 
  
import "fmt"
  
func main() { 
  
        //创建和初始化字符串
        //使用简写声明
    mystr := "Welcome to nhooo"
  
    fmt.Println("String:", mystr) 
  
    /* 果你试图改变字符串的值，编译器将抛出一个错误,例如, 
     cannot assign to mystr[1] 
       mystr[1]= 'G' 
       fmt.Println("String:", mystr) 
    */
  
}

输出：

• 如何遍历字符串？：您可以使用for range循环遍历字符串。此循环可以在Unicode代码点上迭代一个字符串。

语法：

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

在这里，索引是存储UTF-8编码代码点的第一个字节的变量，而chr是存储给定字符串的字符的变量，str是字符串。

//遍历字符串
//使用for范围循环
package main

import "fmt"

func main() {

    //字符串作为for循环中的范围
    for index, s := range "nhooo" {

        fmt.Printf("%c 索引值是 %d\n", s, index)
    }
}

输出：

• 如何访问字符串的单个字节？：字符串是一个字节，因此，我们可以访问给定字符串的每个字节。

//访问字符串的字节
package main

import "fmt"

func main() {

    //创建和初始化一个字符串
    str := "Welcome to nhooo"

    //访问给定字符串的字节
    for c := 0; c < len(str); c++ {

        fmt.Printf("\n字符 = %c 字节 = %v", str[c], str[c])
    }
}

• 如何从切片创建字符串？：在Go语言中，允许您从字节切片创建字符串。

//从切片创建一个字符串 
package main 
  
import "fmt"
  
func main() { 
  
    //创建和初始化一个字节片
    myslice1 := []byte{0x47, 0x65, 0x65, 0x6b, 0x73} 
  
    //从切片创建字符串
    mystring1 := string(myslice1) 
  
    //显示字符串
    fmt.Println("String 1: ", mystring1) 
  
    //创建和初始化一个符文切片 
    myslice2 := []rune{0x0047, 0x0065, 0x0065, 0x006b, 0x0073} 
  
    //从切片创建字符串
    mystring2 := string(myslice2) 
  
    //显示字符串
    fmt.Println("String 2: ", mystring2) 
}

• 如何查找字符串的长度？：在Golang字符串中，可以使用两个函数（一个是len()，另一个是RuneCountInString()）来找到字符串的长度。UTF-8包提供了RuneCountInString()函数，该函数返回字符串中存在的符文总数。len()函数返回字符串的字节数。

//查找字符串的长度
package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {

    //创建和初始化字符串
    //使用简写声明
    mystr := "Welcome to nhooo ??????"

    //查找字符串的长度
    //使用len()函数
    length1 := len(mystr)

    //使用RuneCountInString()函数
    length2 := utf8.RuneCountInString(mystr)

    //显示字符串的长度
    fmt.Println("string:", mystr)
    fmt.Println("Length 1:", length1)
    fmt.Println("Length 2:", length2)

}

【相关推荐：Go视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!