Go Sprach-String (String)

In der Go-Sprache unterscheiden sich Zeichenketten von anderen Sprachen wie Java, c++、Python usw. Es ist eine breite Zeichenfolje, bei der jeder Buchstabe mit UTF-8Kodierung in einem oder mehreren Bytes dargestellt. Oder mit anderen Worten, eine Zeichenkette ist eine unveränderliche Kette aus beliebigen Bytes (einschließlich Bytes mit dem Wert Null), oder eine Zeichenkette ist ein lesbarer Byte-Schnitt, die Bytes einer Zeichenkette können mit UTF-8Kodierung in Unicode-Text dargestellt.

Da UTF-8Kodierung, Golang-Zeichenketten können Text enthalten, Text ist eine Mischung aus jeder Sprache der Welt, ohne die Seite zu verunreinigen und zu begrenzen. Normalerweise wirdDoppelte Anführungszeichen””Zitat，wie im folgenden Beispiel gezeigt:

//Wie man eine Zeichenkette erstellt
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
//(原始文本)。原始文本不支持转义字符，可以跨越多行，并且可以包含除反引号之外的任何字符。通常，它用于在正则表达式和HTML中编写多行消息。
//Variable mit Zeichenkette
//Verwendung der Kurzschreibweise für die Deklaration
　　　　My_value_1　:= "Welcome to oldtoolbag.com"
　　
　　　　//Verwendung des Schlüsselworts var
　　　　var　My_value_2　string　
　　　　My_value_2　=　"w3codebox"
　　
　　　　//Anzeige des Strings　
　　　　fmt.Println("String　1: ", My_value_1)　
　　　　fmt.Println("String　2: ", My_value_2)　
}

Ausgabe：

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

Hinweis:Eine Zeichenkette kann leer sein, aber nicht nil.

Zeichenkette

In der Go-Sprache werden Zeichenketten auf zwei verschiedene Weisen erstellt:

• Verwendung von doppelten Anführungszeichen (""):Hier wird eine Zeichenkette mit doppelten Anführungszeichen ("") erstellt. Dieser Typ von Zeichenkette unterstützt Escape-Zeichen, wie im folgenden Tisch gezeigt, aber nicht über Zeilen hinweg. Dieser Typ von Zeichenkette wird in Golang-Programmen breit verwendet.
  

  Escape-Zeichen	Beschreibung
  \\\	Backslash (\)
  \000	\xhh3具有给定的8Bit-octale Zeichencode-Punkte-Unicode-Zeichen
  \’	Einzelne Anführungszeichen ('). Sie sind nur in Zeichenfolgen erlaubt
  \”	Doppelte Anführungszeichen (""). Sie sind nur in interpretierten Zeichenfolgen erlaubt
  \a	ASCII Glocke (BEL)
  \b	ASCII Backspace (BS)
  \f	ASCII Seitenumbruch (FF)
  \n	ASCII Zeilenumbruch (LF)
  \r	ASCII Return (CR)
  \t	ASCII Tabulator (TAB)
  \uhhhh	\xhh4具有给定的16位
  	\xhh8具有给定的32位
  \v	ASCII vertikale Tabulator (VT)
  十六进制代码点的Unicode字符。	\xhh2具有给定的8位

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

  Beispiel

  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)
  }

  Ausgabe：

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

关于字符串的要点

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

  Beispiel

  //字符串是不可变的
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　　　　　//Erstellung und Initialisierung eines Strings
  　　　　　　　　//Verwendung der Kurzschreibweise für die Deklaration
  　　　　mystr　:=　"Welcome　to　w3codebox"
  　　
  　　　　fmt.Println("String:", mystr)　
  　　
  　　　　/*　果你试图改变字符串的值，编译器将抛出一个错误,例如,　
  　　　　　cannot assign to mystr[1]　
  　　　　　　　mystr[1]= 'G'　
  　　　　　　　fmt.Println("String:", mystr)　
  　　　　*/
  　　
  }

  Ausgabe：

  String: Welcome to w3codebox

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

  语法：

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

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

  Beispiel

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

  Ausgabe：

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

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

  Beispiel

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

  Ausgabe：

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

• Wie erstellt man einen String aus einem Slice?：In der Programmiersprache Go können Sie aus Byte-Slices Strings erstellen.

  Beispiel

  //Erstellung eines Strings aus einem Slice　
  package　main　
  　　
  import　"fmt"
  　　
  func　main()　{　
  　　
  　　　　//Erstellung und Initialisierung eines Byte-Slices
  　　　　myslice1　:=　[]byte{0x47,　0x65,　0x65,　0x6b,　0x73}　
  　　
  　　　　//Erstellung eines Strings aus einem Slice
  　　　　mystring1　:=　string(myslice1)　
  　　
  　　　　//Anzeige des Strings
  　　　　fmt.Println("String　1:　",　mystring1)　
  　　
  　　　　//Erstellung und Initialisierung eines Rune-Slices　
  　　　　myslice2　:=　[]rune{0x0047,　0x0065,　0x0065,　0x006b,　0x0073}　
  　　
  　　　　//Erstellung eines Strings aus einem Slice
  　　　　mystring2　:=　string(myslice2)　
  　　
  　　　　//Anzeige des Strings
  　　　　fmt.Println("String　2:　",　mystring2)　
  }

  Ausgabe：

  String　1:　　Geeks
  String　2:　　Geeks

• Wie finde ich die Länge eines Strings?：In Go-Strings können zwei Funktionen verwendet werden (eine istlen()，der andere istRuneCountInString()）um die Länge des Strings zu finden. UTF-8Das Paket bietet die Funktion RuneCountInString() an, die die Gesamtzahl der Runen im String zurückgibt.len()Die Funktion gibt die Anzahl der Bytes des Strings zurück.

  Beispiel

  //Suche der Länge eines Strings
  package　main
  import　("
  　　　　"fmt"
  　　　　"unicode/utf8"
  )
  func　main()　{
  　　　　//Erstellung und Initialisierung eines Strings
  　　　　//Verwendung der Kurzschreibweise für die Deklaration
  　　　　mystr　:=　"Welcome　to　w3codebox　??????"
  　　　　//Suche der Länge eines Strings
  　　　　//Verwendung der Funktion len()
  　　　　Länge1　:=　len(mystr)
  　　　　//Verwendung der Funktion RuneCountInString()
  　　　　Länge2　:=　utf8.RuneCountInString(mystr)
  　　　　//Anzeige der Länge eines Strings
  　　　　fmt.Println("string:",　mystr)
  　　　　fmt.Println("Länge　1:",　Länge1)
  　　　　fmt.Println("Länge　2:",　Länge2)
  }

  Ausgabe：

  string:　Welcome　to　w3codebox　??????
  Länge　1:　31
  Länge　2:　31