Tutoriel de base Go

Instructions de contrôle Go

Fonction & Méthode Go

Structure Go

Slice & Tableau Go

Chaîne (String) Go

Pointeur Go

Interface Go

Concurrence Go

Exception Go

Autres outils Go

Comparaison de chaîne Go Division de slice Go

Chaîne (String) du langage Go

Dans le langage Go, les chaînes sont différents des autres langages, tels que Java, c++、Python, etc. C'est une séquence de caractères variables, où chaque caractère est utilisé avec UTF-8Un ou plusieurs octets d'encodage. Ou autrement dit, une chaîne est une chaîne immutable de bytes (y compris les bytes de valeur zéro) ou une slice de bytes lecture seule, les bytes de la chaîne peuvent être utilisés avec UTF-8编码 en représentation de texte Unicode.

En raison de l'utilisation de UTF-8Encodage, les chaînes Go peuvent contenir du texte, du texte est une combinaison de toutes les langues du monde, sans causer de désordre ou de restriction sur la page. Souvent, les chaînes sont utiliséesGuillemets doubles””Encadré，comme montré dans les exemples suivants :

示例

//Comment créer une chaîne
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
//(原始文本)。原始文本不支持转义字符，可以跨越多行，并且可以包含除反引号之外的任何字符。通常，它用于在正则表达式和HTML中编写多行消息。
//Variable avec chaîne
//使用简写声明
　　　　My_value_1　:= "Welcome to oldtoolbag.com"
　　
　　　　//Utilisation de la clé var
　　　　var　My_value_2　string　
　　　　My_value_2　=　"w3codebox"
　　
　　　　//显示字符串　
　　　　fmt.Println("String　1: ", My_value_1)　
　　　　fmt.Println("String　2: ", My_value_2)　
}

输出：

String　1: Welcome to oldtoolbag.com
String　2:　　w3codebox

Remarque :Une chaîne peut être vide, mais ne peut pas être nil.

Littéral de chaîne

En langage Go, les littéraux de chaînes sont créés de deux manières différentes :

Utilisation des guillemets doubles (“”):Ici, les littéraux de chaînes utilisent des guillemets doubles (“”) pour être créés. Ce type de littéral de chaîne prend en charge les caractères d'échappement, comme indiqué dans le tableau suivant, mais ne s'étend pas sur plusieurs lignes. Ce type de littéral de chaîne est largement utilisé dans les programmes Go.

Caractère d'échappement	Description
\\\	Barre oblique inversée (\)
\000	\xhh3具有给定的8Caractère Unicode de code point octal bits
\’	Guillemets simples ('). Seulement autorisés dans les textes de caractères
\”	Guillemets doubles (""). Seulement autorisés dans les textes de chaînes d'interprétation
\a	Caractère de son (BEL) ASCII
\b	Caractère de suppression de retour (BS) ASCII
\f	Caractère de saut de page (FF) ASCII
\n	Caractère de retour à la ligne (LF) ASCII
\r	Caractère de retour chariot (CR) ASCII
\t	Caractère de tabulation (TAB) ASCII
\uhhhh	\xhh4具有给定的16位
	\xhh8具有给定的32位
\v	Caractère de tabulation verticale (VT) ASCII
codebox\xhh	\xhh2具有给定的8位

位十六进制代码点的Unicode字符。使用反引号（``）：此处，字符串文字是使用反引号（``）创建的，也称为raw literals

示例

package　main
import　"fmt"
func　main()　{
　　　　//(原始文本)。原始文本不支持转义字符，可以跨越多行，并且可以包含除反引号之外的任何字符。通常，它用于在正则表达式和HTML中编写多行消息。
　　　　//创建并初始化
　　　　//带有字符串文字的变量
　　　　My_value_1　:= "Welcome to w3codebox"
　　　　//添加转义字符
　　　　My_value_2　:= "Welcome to w3codebox"
　　　　//:= "Welcome!\nw
　　　　My_value_3　:= `Hello!w3codebox`
　　　　//添加转义字符
　　　　//原始文本
　　　　My_value_4　:= `Hello!\nw3codebox`
　　　　//显示
　　　　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)
}

输出：

String　1: Welcome to w3codebox
String　2: Welcome!
w3codebox
String　3: Hello!w3codebox
String　4: Hello!\nw3codebox

关于字符串的要点

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

示例

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

输出：

String: Welcome to w3codebox

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

语法：

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

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

示例

//遍历字符串
//使用for范围循环
package　main
import　"fmt"
func　main()　{
　　　　//字符串作为for循环中的范围
　　　　for index, s := range "w3codebox" {
　　　　　　　　fmt.Printf("%c 索引值是 %d\n", s, index)
　　　　}
}

输出：

n 索引值是 0
h 索引值是　1
o 索引值是　2
o 索引值是　3
o 索引值是　4

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

示例

//访问字符串的字节
package　main
import　"fmt"
func　main()　{
　　　　//创建和初始化一个字符串
　　　　str := "Welcome to w3codebox"
　　　　//访问给定字符串的字节
　　　　for　c　:=　0;　c　<　len(str);　c++　{
　　　　　　　　fmt.Printf("\n字符　=　%c　字节　=　%v",　str[c],　str[c])
　　　　}
}

输出：

字符　=　W　字节　=　87
字符　=　e　字节　=　101
字符　=　l　字节　=　108
字符　=　c　字节　=　99
字符　=　o　字节　=　111
字符　=　m　字节　=　109
字符　=　e　字节　=　101
字符　=　　　字节　=　32
字符　=　t　字节　=　116
字符　=　o　字节　=　111
字符　=　　　字节　=　32
字符　=　n　字节　=　110
字符　=　h　字节　=　104
字符　=　o　字节　=　111
字符　=　o　字节　=　111
字符　=　o　字节　=　111

如何从切片创建字符串？：在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)　
}

输出：

String　1:　　Geeks
String　2:　　Geeks

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

示例

//查找字符串的长度
package　main
import　("
　　　　"fmt"
　　　　"unicode/utf8"
)
func　main()　{
　　　　//创建和初始化字符串
　　　　//使用简写声明
　　　　mystr　:=　"Welcome　to　w3codebox　??????"
　　　　//查找字符串的长度
　　　　//使用len()函数
　　　　length1　:=　len(mystr)
　　　　//使用RuneCountInString()函数
　　　　length2　:=　utf8.RuneCountInString(mystr)
　　　　//显示字符串的长度
　　　　fmt.Println("string:",　mystr)
　　　　fmt.Println("Length　1:",　length1)
　　　　fmt.Println("Length　2:",　length2)
}

输出：

string:　Welcome　to　w3codebox　??????
Longueur　1:　31
Longueur　2:　31

Comparaison de chaîne Go Division de slice Go