在上一课中，我们了解到 Go 中的字符使用 UTF-8 进行编码并存储为 byte 或 rune 类型。现在，我们来谈谈字符串，它是字符的集合。一起来了解一下吧。
知识点：
在我们用 Go 学习的第一个程序中，我们打印了字符串 hello, world。
String 是 Go 中的一种基本数据类型，也称为字符串文字。可以理解为字符的集合，占用一块连续的内存块。这块内存可以存储任何类型的数据，比如字母、文本、表情符号等
但是，与其他语言不同，Go 中的字符串是只读的，无法修改。
字符串可以通过多种方式声明。我们来看看第一种方法。创建一个名为 string.go 的新文件：
touch ~/project/string.go
编写以下代码：
package main
import "fmt"
func main() {
// Use the var keyword to create a string variable a
var a string = "labex"
a = "labex" // Assign "labex" to variable a
// Declare variable a and assign its value
var b string = "shiyanlou"
// Type declaration can be omitted
var c = "Monday"
// Use := for quick declaration and assignment
d := "Hangzhou"
fmt.Println(a, b, c, d)
}
上面的代码演示了如何使用 var 关键字和 := 运算符创建字符串。如果用var创建变量时赋值，可以省略类型声明，如创建变量b所示。
预期输出如下：
labex shiyanlou Monday Hangzhou
大多数情况下，我们使用双引号“”来声明字符串。双引号的优点是可以用作转义序列。例如，在下面的程序中，我们使用 n 转义序列来创建新行：
package main
import "fmt"
func main(){
x := "shiyanlou\nlabex"
fmt.Println(x)
}
预期输出如下：
shiyanlou labex
以下是一些常见的转义序列：
| Symbol | Description |
|---|---|
| n | New line |
| r | Carriage return |
| t | Tab |
| b | Backspace |
| \ | Backslash |
| ' | Single quote |
| " | Double quote |
If you want to preserve the original format of the text or need to use multiple lines, you can use backticks to represent them:
package main
import "fmt"
func main() {
// Output Pascal's Triangle
yangHuiTriangle := `
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1`
fmt.Println(yangHuiTriangle)
// Output the ASCII art of "labex"
ascii := `
# ## # # ### # ## ####
# # # ## # # # # # # # #
# # # # # # # # # # # # #
# ##### # # # # # # # ##### # #
# # # # ## # # # # # # #
##### # # # # ## # # # # ### `
fmt.Println(ascii)
}
After running the program, you will see the following output:
Backticks are commonly used in prompts, HTML templates, and other cases where you need to preserve the original format of the output.
In the previous lesson, we learned that English characters and general punctuation marks occupy one byte, while Chinese characters occupy three to four bytes.
Therefore, in Go, we can use the len() function to get the byte length of a string. If there are no characters that occupy multiple bytes, the len() function can be used to approximately measure the length of the string.
If a string contains characters that occupy multiple bytes, you can use the utf8.RuneCountInString function to get the actual number of characters in the string.
Let's see an example. Write the following code to the string.go file:
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
// Declare two empty strings using var and :=
var a string
b := ""
c := "labex"
// Output byte length
fmt.Printf("The value of a is %s, the byte length of a is: %d\n", a, len(a))
fmt.Printf("The value of b is %s, the byte length of b is: %d\n", b, len(b))
fmt.Printf("The value of c is %s, the byte length of c is: %d\n", c, len(c))
// Output string length
fmt.Printf("The length of d is: %d\n", utf8.RuneCountInString(d))
}
The expected output is as follows:
The value of a is , the byte length of a is: 0 The value of b is , the byte length of b is: 0 The value of c is labex, the byte length of c is: 5 The length of d is: 9
In the program, we first declared two empty strings and the string labex. You can see that their byte lengths and actual lengths are the same.
We can use functions from the strconv package to convert between strings and integers:
package main
import (
"fmt"
"strconv"
)
func main() {
// Declare a string a and an integer b
a, b := "233", 223
// Use Atoi to convert an integer to a string
c, _ := strconv.Atoi(a)
// Use Sprintf and Itoa functions respectively
// to convert a string to an integer
d1 := fmt.Sprintf("%d", b)
d2 := strconv.Itoa(b)
fmt.Printf("The type of a: %T\n", a) // string
fmt.Printf("The type of b: %T\n", b) // int
fmt.Printf("The type of c: %T\n", c) // int
fmt.Printf("The type of d1: %T\n", d1) // string
fmt.Printf("The type of d2: %T\n", d2) // string
}
The expected output is as follows:
The type of a: string The type of b: int The type of c: int The type of d1: string The type of d2: string
In the program, we use the Sprintf() function from the fmt package, which has the following format:
func Sprintf(format string, a ...interface{}) string
format is a string with escape sequences, a is a constant or variable that provides values for the escape sequences, and ... means that there can be multiple variables of the same type as a. The string after the function represents that Sprintf returns a string. Here's an example of using this function:
a = Sprintf("%d+%d=%d", 1, 2, 3)
fmt.Println(a) // 1+2=3
In this code snippet, the format is passed with three integer variables 1, 2, and 3. The %d integer escape character in format is replaced by the integer values, and the Sprintf function returns the result after replacement, 1+2=3.
Also, note that when using strconv.Atoi() to convert an integer to a string, the function returns two values, the converted integer val and the error code err. Because in Go, if you declare a variable, you must use it, we can use an underscore _ to comment out the err variable.
When strconv.Atoi() converts correctly, err returns nil. When an error occurs during conversion, err returns the error message, and the value of val will be 0. You can change the value of string a and replace the underscore with a normal variable to try it yourself.
The simplest way to concatenate two or more strings is to use the + symbol. We can also use the fmt.Sprintf() function to concatenate strings. Let's take a look at an example:
package main
import (
"fmt"
)
func main() {
a, b := "lan", "qiao"
// Concatenate using the simplest method, +
c1 := a + b
// Concatenate using the Sprintf function
c2 := fmt.Sprintf("%s%s", a, b)
fmt.Println(a, b, c1, c2) // lan qiao labex labex
}
The expected output is as follows:
lan qiao labex labex
In the program, we also used the Sprintf() function from the fmt package to concatenate strings and print the results.
We can use the strings.TrimSpace function to remove leading and trailing spaces from a string. The function takes a string as input and returns the string with leading and trailing spaces removed. The format is as follows:
func TrimSpace(s string) string
Here is an example:
package main
import (
"fmt"
"strings"
)
func main() {
a := " \t \n labex \n \t hangzhou"
fmt.Println(strings.TrimSpace(a))
}
The expected output is as follows:
labex
hangzhou
To summarize what we've learned in this lesson:
In this lesson, we explained the strings we use in daily life. We've learned about the relationship between strings and characters, mastered string creation and declaration, and gained some knowledge of common string functions.
In the next lesson, we will learn about constants.
? Practice Now: Go String Fundamentals
以上是去编程 |字符串基础知识 |字符编码的详细内容。更多信息请关注PHP中文网其他相关文章！
