Apakah maksud str dalam bahasa go?

Dalam bahasa Go, str merujuk kepada "rentetan", yang merupakan jujukan bait yang tidak boleh diubah. Rentetan boleh mengandungi sebarang data, tetapi biasanya digunakan untuk mengandungi teks yang boleh dibaca Rentetan ialah jujukan aksara UTF-8 (apabila aksara itu ialah aksara dalam jadual kod ASCII, ia menduduki 1 bait dan aksara lain adalah berdasarkan. Memerlukan 2-4 bait). Rentetan ialah jenis nilai, dan nilainya tidak boleh diubah, iaitu, setelah teks dibuat, kandungan teks tidak boleh diubah suai lagi. Secara lebih mendalam, rentetan ialah tatasusunan bait panjang tetap.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Dalam bahasa go, str merujuk kepada "rentetan".

Rentetan ialah urutan bait yang tidak boleh diubah Satu rentetan boleh mengandungi data sewenang-wenangnya, tetapi biasanya digunakan untuk mengandungi teks yang boleh dibaca dalam jadual kod ASCII, mereka menduduki 1 bait, dan aksara lain menduduki 2-4 bait seperti yang diperlukan).

Pelaksanaan dalaman rentetan dalam bahasa Go menggunakan pengekodan UTF-8, dan setiap aksara UTF-8 boleh diakses dengan mudah melalui jenis rune. Sudah tentu, bahasa Go juga menyokong akses aksara demi aksara dalam kod ASCII tradisional.

UTF-8 ialah format pengekodan yang digunakan secara meluas dan pengekodan standard untuk fail teks, termasuk XML dan JSON. Disebabkan ketidakpastian panjang bait yang diduduki oleh pengekodan ini, rentetan dalam bahasa Go juga mungkin menduduki 1 hingga 4 bait seperti yang diperlukan, yang berbeza daripada bahasa pengaturcaraan lain seperti C++, Java atau Python (Java sentiasa menggunakan 2 bait). Bahasa Go melakukan ini bukan sahaja untuk mengurangkan penggunaan ruang memori dan cakera keras, tetapi juga tidak perlu mengekod dan menyahkod teks menggunakan set aksara UTF-8 seperti bahasa lain.

String ialah jenis nilai, dan nilainya tidak boleh diubah, iaitu, selepas mencipta teks tertentu, kandungan teks ini tidak boleh diubah suai lagi, rentetan ialah tatasusunan bait panjang tetap .

Tentukan rentetan

Anda boleh menggunakan petikan berganda "" untuk mentakrif rentetan dan aksara melarikan diri boleh digunakan dalam rentetan untuk mencapai baris rehat. Lekukan dan kesan lain, aksara melarikan diri yang biasa digunakan termasuk:

• n: aksara suapan baris

• r: carriage return aksara

• t: kekunci tab

• u atau U: aksara Unikod

• \: The backslash itu sendiri

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

Hasil larian ialah:

Pengendali perbandingan am (==, !=, =, >) melaksanakan perbandingan rentetan dengan membandingkan bait dalam ingatan, jadi hasil perbandingan ialah susunan pengekodan semula jadi rentetan. Panjang dalam bait yang diduduki oleh rentetan boleh diperoleh melalui fungsi len(), seperti len(str).

Kandungan rentetan (bait tulen) boleh diperolehi melalui kaedah pengindeksan standard Indeks ditulis dalam kurungan segi empat sama [ ], dan indeks mula mengira dari 0:

• Bait pertama rentetan str:

  str[0]

• bait ke-i:

  str[i - 1]

• 1 Bait Terakhir:

  str[len(str)-1]

Perlu diingat bahawa skim penukaran ini hanya sah untuk rentetan ASCII tulen.

Nota: Tidak sah untuk mendapatkan alamat bait dalam rentetan, seperti

. &str[i]

Karakter penyambung rentetan "+"

Dua rentetan s1 dan s2 boleh disambung dengan s := s1 + s2 bersama-sama. Menambahkan s2 pada penghujung s1 dan menjana rentetan s baharu.

Anda boleh menyambung berbilang baris rentetan dalam kod dengan cara berikut:

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

Petua: Oleh kerana pengkompil akan melengkapkan koma bernoktah secara automatik di hujung baris, Oleh itu, tanda tambah "+" yang digunakan untuk menggabungkan rentetan mesti diletakkan di hujung baris pertama.

Anda juga boleh menggunakan "+=" untuk menyambung rentetan:

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

Tentukan rentetan berbilang baris

Dalam bahasa Go, menggunakan petikan berganda untuk menulis rentetan ialah salah satu ungkapan biasa rentetan Ia dipanggil literal rentetan jenis ini tidak boleh menjangkau baris rentetan berbilang baris dalam kod sumber, anda mesti menggunakan

kutu belakang Kod adalah seperti berikut: `

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

Hasil jalankan kod:

Kunci belakang

ialah kekunci di sebelah kiri 1 kekunci pada papan kekunci Rentetan antara dua kutu belakang akan diberikan kepada pembolehubah str sebagaimana adanya. `

Dengan cara ini, baris baharu antara tanda belakang akan dianggap sebagai baris baharu dalam rentetan, tetapi semua aksara melarikan diri akan menjadi tidak sah dan teks akan dikeluarkan seperti sedia ada.

Rentetan berbilang baris biasanya digunakan untuk kod sumber terbenam dan data terbenam Kodnya adalah seperti berikut:

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

Atas ialah kandungan terperinci Apakah maksud str dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!