Was bedeutet str in der Go-Sprache?

In der Go-Sprache bezieht sich str auf „String“, eine unveränderliche Bytefolge. Eine Zeichenfolge kann beliebige Daten enthalten, wird jedoch normalerweise zur Aufnahme von lesbarem Text verwendet. Eine Zeichenfolge ist eine Folge von UTF-8-Zeichen (wenn das Zeichen ein Zeichen in der ASCII-Codetabelle ist, belegt es 1 Byte und andere Zeichen basieren darauf). Benötigt 2-4 Bytes). String ist ein Werttyp, und der Wert ist unveränderlich. Das heißt, sobald ein Text erstellt wurde, kann der Inhalt des Texts nicht mehr geändert werden. Genauer gesagt ist ein String ein Byte-Array mit fester Länge.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

In der Go-Sprache bezieht sich str auf „String“.

Eine Zeichenfolge ist eine unveränderliche Bytefolge. Eine Zeichenfolge kann beliebige Daten enthalten, wird jedoch normalerweise zur Aufnahme von lesbarem Text verwendet. Eine Zeichenfolge ist eine Folge von UTF-8-Zeichen (wenn die Zeichen ASCII-Codes sind). Byte, andere Zeichen belegen je nach Bedarf 2-4 Byte).

Die interne Implementierung von Zeichenfolgen in der Go-Sprache verwendet die UTF-8-Codierung, und auf jedes UTF-8-Zeichen kann einfach über den Runentyp zugegriffen werden. Natürlich unterstützt die Go-Sprache auch den zeichenweisen Zugriff im herkömmlichen ASCII-Code.

UTF-8 ist ein weit verbreitetes Kodierungsformat und die Standardkodierung für Textdateien, einschließlich XML und JSON. Aufgrund der Unsicherheit über die Länge der von dieser Codierung belegten Bytes können Zeichenfolgen in der Go-Sprache je nach Bedarf auch 1 bis 4 Bytes belegen, was sich von anderen Programmiersprachen wie C++, Java oder Python (Java immer) unterscheidet verwendet 2 Bytes). Die Go-Sprache reduziert dadurch nicht nur die Speicher- und Festplattenspeichernutzung, sondern erfordert auch keine Kodierung und Dekodierung von Text mithilfe des UTF-8-Zeichensatzes wie bei anderen Sprachen.

String ist ein Werttyp und der Wert ist unveränderlich, das heißt, nach dem Erstellen eines bestimmten Textes kann der Inhalt dieses Textes nicht mehr geändert werden. Genauer gesagt ist ein String ein Byte-Array fester Länge.

Strings definieren

Sie können doppelte Anführungszeichen „“ verwenden, um Strings zu definieren, um Zeilenumbrüche, Einrückungen und andere Effekte zu erzielen:

• n: Zeilenvorschubzeichenn：换行符

• 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: Wagenrücklaufzeichen

t: Tabulatortaste🎜🎜🎜u oder U: Unicode-Zeichen 🎜🎜🎜\: Backslash selbst 🎜

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 Das Ergebnis ist : 🎜🎜 🎜🎜 Allgemeine Vergleichsoperatoren (==, !=, =, >) implementieren den String-Vergleich durch den Vergleich von Bytes im Speicher, sodass das Ergebnis des Vergleichs ein Zeichen ist. Die natürliche Codierungsreihenfolge von Strings. Die von einer Zeichenfolge belegte Länge in Bytes kann über die Funktion len() ermittelt werden, z. B. len(str). 🎜🎜Der Inhalt der Zeichenfolge (reine Bytes) kann über die Standard-Indizierungsmethode abgerufen werden. Schreiben Sie den Index in eckige Klammern [], und der Index beginnt bei 0 zu zählen: 🎜🎜🎜🎜Das erste Byte der Zeichenfolge str: str[0]🎜🎜🎜i-tes Byte: str[i - 1]🎜🎜🎜letztes 1 Byte: str[len(str)-1]🎜🎜Es ist zu beachten, dass dieses Konvertierungsschema nur für reine ASCII-Strings gültig ist. 🎜🎜🎜Hinweis: Es ist illegal, die Adresse eines bestimmten Bytes in einer Zeichenfolge abzurufen, z. B. &str[i]. 🎜🎜🎜🎜🎜String-Spleißzeichen „+“🎜🎜🎜🎜Zwei Strings s1 und s2 können durch s := s1 + s2 miteinander verbunden werden. Hängt s2 an das Ende von s1 an und generiert eine neue Zeichenfolge s. 🎜🎜Sie können mehrere Zeilen mit Zeichenfolgen im Code wie folgt zusammenfügen: 🎜

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

🎜🎜Tipps: Da der Compiler automatisch Semikolons am Ende der Zeile vervollständigt, muss das Pluszeichen „+“, das zum Zusammenfügen von Zeichenfolgen verwendet wird, an stehen das Ende der ersten Zeile. 🎜🎜🎜Sie können auch „+=" verwenden, um Zeichenfolgen zu verbinden: 🎜

//字符串是不可变的
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) 
    */
  
}

🎜🎜🎜Mehrzeilige Zeichenfolgen definieren 🎜🎜🎜🎜In der Go-Sprache ist die Verwendung doppelter Anführungszeichen zum Schreiben von Zeichenfolgen ein üblicher Ausdruck für Zeichenfolgen. Einer wird als Zeichenfolge bezeichnet Literal. Dieses Literal mit doppelten Anführungszeichen kann sich nicht über mehrere Zeilen erstrecken. Wenn Sie eine mehrzeilige Zeichenfolge in den Quellcode einbetten möchten, müssen Sie diese in Anführungszeichen umkehren. Der Code lautet wie folgt: 🎜

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

🎜Code-Ausführungsergebnis: 🎜🎜🎜🎜Der Backtick ` ist die Taste links von der 1-Taste auf der Tastatur. Die Zeichenfolge zwischen den beiden Backticks wird unverändert der str-Variablen zugewiesen. 🎜🎜Auf diese Weise werden Zeilenumbrüche zwischen Backticks als Zeilenumbrüche in der Zeichenfolge behandelt, alle Escape-Zeichen sind jedoch ungültig und der Text wird unverändert ausgegeben. 🎜🎜Mehrzeilige Zeichenfolgen werden im Allgemeinen für eingebetteten Quellcode und eingebettete Daten usw. verwendet. Der Code lautet wie folgt: 🎜

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视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonWas bedeutet str in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!