go学习记录——第五天

这篇不算完全的记录，要补充一下基本数据结构中关于字符串的包和切片部分的包，顺便补全一下之前说的转义字符和格式化占位符表格。

strings和strcov包

前缀和后缀

HasPrefix()和Hassuffix()用于判断字符串s是否以prefix开头或者以suffix结尾。

1
2
strings.HasPrefix(s, prefix string) bool
strings.HasSuffix(s, suffix string) bool

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string = "This is an example of a string"

	fmt.Printf("T/F? Does the string \"%s\" have prefix %s? ", str, "Th")
	fmt.Printf("%t\n", strings.HasPrefix(str, "Th"))
}

// Output: T/F? Does the string "This is an example of a string" have prefix Th? true

字符串包含关系

Contains()判断字符串s是否包含substr

1
strings.Contains(s, substr string) bool

判断子字符串或字符在父字符串中出现的位置（索引）

Index()返回字符串str在字符串s中的索引（str的第一个字符的索引），-1表示字符串s不包含字符串str。

1
strings.Index(s, str string) int

LastIndex()返回字符串str在字符串s中最后出现位置的（str的第一个字符的索引），-1表示字符串s不包含字符串str。

1
strings.LastIndex(s, str string) int

如果要查询非ASCII编码的字符在父字符串中的位置，用IndexRune()。

1
strings.IndexRune(s string, r rune) int

注意：

  • 在最新版的Go中定义为func IndexRune(s string, r rune) int
  • 实际使用中的第二个参数rune可以是rune或int，例如strings.IndexRune("chicken", 99) 或 strings.IndexRune("chicken", rune('k'))

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string = "Hi, I'm Marc, Hi."

	fmt.Printf("The position of \"Marc\" is: ")
	fmt.Printf("%d\n", strings.Index(str, "Marc"))

	fmt.Printf("The position of the first instance of \"Hi\" is: ")
	fmt.Printf("%d\n", strings.Index(str, "Hi"))
	fmt.Printf("The position of the last instance of \"Hi\" is: ")
	fmt.Printf("%d\n", strings.LastIndex(str, "Hi"))

	fmt.Printf("The position of \"Burger\" is: ")
	fmt.Printf("%d\n", strings.Index(str, "Burger"))
}
/*output
The position of "Marc" is: 8
The position of the first instance of "Hi" is: 0
The position of the last instance of "Hi" is: 14
The position of "Burger" is: -1
*/

字符串替换

Replace()用于将字符串s中的前n个字符串old替换为字符串new，并返回一个新的字符串，如果n = -1则替换掉所有字符串old为new。

1
strings.Replace(str, old, new string, n int) string

统计字符串出现次数

Count()用于统计字符串str中字符串s出现的次数（非重叠）

1
strings.Count(s, str string) int

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string = "Hello, how is it going, Hugo?"
	var manyG = "gggggggggg"

	fmt.Printf("Number of H's in %s is: ", str)
	fmt.Printf("%d\n", strings.Count(str, "H"))

	fmt.Printf("Number of double g's in %s is: ", manyG)
	fmt.Printf("%d\n", strings.Count(manyG, "gg"))
}
/*output
Number of H's in Hello, how is it going, Hugo? is: 2
Number of double g’s in gggggggggg is: 5
*/

重复字符串

Repeat()用于将字符串str重复n次，返回一个新的字符串。

1
strings.Repeat(s, n int) string

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"fmt"
	"strings"
)

func main() {
	var origS string = "Hi there! "
	var newS string

	newS = strings.Repeat(origS, 3)
	fmt.Printf("The new repeated string is: %s\n", newS)
}
/*output
The new repeated string is: Hi there! Hi there! Hi there!
*/

修改字符串的大小写

ToLower()和ToUpper()用于将字符串s中的所有字符转为小写或大写。和python的一样，就多了个To

1
2
strings.ToLower(s) string
strings.ToUpper(s) string

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
	"fmt"
	"strings"
)

func main() {
	var orig string = "Hey, how are you George?"
	var lower string
	var upper string

	fmt.Printf("The original string is: %s\n", orig)
	lower = strings.ToLower(orig)
	fmt.Printf("The lowercase string is: %s\n", lower)
	upper = strings.ToUpper(orig)
	fmt.Printf("The uppercase string is: %s\n", upper)
}
/*output
The original string is: Hey, how are you George?
The lowercase string is: hey, how are you george?
The uppercase string is: HEY, HOW ARE YOU GEORGE?
*/

修剪字符串

strings.TrimSpace(s)剔除字符串开头和结尾的空白符号
strings.Trim(s, "cut")剔除开头和结尾的指定字符，cut参数可以是任意字符
strings.TrimLeft()或string.TrimRight()可以剔除开头或结尾的字符

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import (
    "fmt"
    "strings"
)

func main() {
    // 示例字符串
    str1 := "   Hello, World!   "
    str2 := "!!!Hello, World!!!"
    
    // 使用 TrimSpace 去除开头和结尾的空白符号
    trimmedSpace := strings.TrimSpace(str1)
    fmt.Println("使用 TrimSpace 去除空白符号:", trimmedSpace) // 输出: "Hello, World!"
    
    // 使用 Trim 去除开头和结尾的指定字符
    trimmedCut := strings.Trim(str2, "!")
    fmt.Println("使用 Trim 去除指定字符:", trimmedCut) // 输出: "Hello, World"
    
    // 使用 TrimLeft 去除开头的指定字符
    trimmedLeft := strings.TrimLeft(str2, "!")
    fmt.Println("使用 TrimLeft 去除开头的指定字符:", trimmedLeft) // 输出: "Hello, World!!!"
    
    // 使用 TrimRight 去除结尾的指定字符
    trimmedRight := strings.TrimRight(str2, "!")
    fmt.Println("使用 TrimRight 去除结尾的指定字符:", trimmedRight) // 输出: "!!!Hello, World"
}
/*output
使用 TrimSpace 去除空白符号: Hello, World!
使用 Trim 去除指定字符: Hello, World
使用 TrimLeft 去除开头的指定字符: Hello, World!!!
使用 TrimRight 去除结尾的指定字符: !!!Hello, World
*/

分割字符串

strings.Fields(s)将会利用1个或多个空白符号来作为动态长度的分隔符将字符串分割成若干小块，并返回一个slice，如果字符串只包含空白符，则返回一个长度为0的slice。

strings.Split(s, sep)用自定义符号去对指定字符串进行分割，并返回slice。

这里的split和python的差不多，一个字符串在内一个字符串在外

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
    "fmt"
    "strings"
)

func main() {
    // 使用 strings.Split 按指定分隔符分割字符串
    str1 := "apple,banana,cherry"
    splitResult := strings.Split(str1, ",")
    fmt.Println("使用 strings.Split 结果:", splitResult) // 输出: [apple banana cherry]

    // 使用 strings.Fields 按空白字符分割字符串
    str2 := "  Hello,   World!  This is Go.  "
    fieldsResult := strings.Fields(str2)
    fmt.Println("使用 strings.Fields 结果:", fieldsResult) // 输出: [Hello, World! This is Go.]
}
/*output
使用 strings.Split 结果: [apple banana cherry]
使用 strings.Fields 结果: [Hello, World! This is Go.]
*/

拼接slice到字符串

Join()用于将元素类型为string的slice使用分隔符来拼接成一个字符串

1
strings.Join(sl []string, sep string) string

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "The quick brown fox jumps over the lazy dog"
	sl := strings.Fields(str)
	fmt.Printf("Splitted in slice: %v\n", sl)
	for _, val := range sl {
		fmt.Printf("%s - ", val)
	}
	fmt.Println()
	str2 := "GO1|The ABC of Go|25"
	sl2 := strings.Split(str2, "|")
	fmt.Printf("Splitted in slice: %v\n", sl2)
	for _, val := range sl2 {
		fmt.Printf("%s - ", val)
	}
	fmt.Println()
	str3 := strings.Join(sl2,";")
	fmt.Printf("sl2 joined by ;: %s\n", str3)
}
/*output
Splitted in slice: [The quick brown fox jumps over the lazy dog]
The - quick - brown - fox - jumps - over - the - lazy - dog -
Splitted in slice: [GO1 The ABC of Go 25]
GO1 - The ABC of Go - 25 -
sl2 joined by ;: GO1;The ABC of Go;25
*/

从字符串中读取内容

strings.NewReader(str)用于生成一个Reader并读取字符串中的内容，然后返回指向这个Reader的指针。

Read()从[]byte读取内容

ReadByte()和ReadRune()从字符串中读取下一个byte or rune

类型转换

通过strconv包实现

数字型转字符串型
strconv.Itoa(i int) string 返回数字 i 所表示的字符串类型的十进制数。

strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string 将 64 位浮点型的数字转换为字符串，其中 fmt 表示格式（其值可以是 'b'、'e'、'f' 或 'g'），prec 表示精度，bitSize 则使用 32 表示 float32，用 64 表示 float64。

字符串型转数字型

strconv.Atoi(s string) (i int, err error) 将字符串转换为 int 型。

strconv.ParseFloat(s string, bitSize int) (f float64, err error) 将字符串转换为 float64 型。

bytes包

类型 []byte 的切片十分常见，包 btyes就用来提供这种类型的操作方法。同时包里还包含一个 Buffer 类型。

1
2
3
4
5
import "bytes"

type Buffer struct {
	...
}

首先 buffer 是长度可变的 btyes ，提供了 Read() and Write() 方法，读写位置长度的 bytes 最好使用 buffer

Buffer 的定义是 var buffer bytes.Buffer

或使用函数 func NewBuffer(buf []byte) *Buffer，创建一个 buffer 对象并且初始化好 buf； NewBuffer 最好在从 buf 读取时使用。

通过buffer串联字符串

实例

创建一个 buffer，通过 buffer.WriteString(s) 方法将字符串 s 追加到后面，最后再通过 buffer.String() 方法转换为 string

1
2
3
4
5
6
7
8
9
var buffer bytes.Buffer
for {
	if s, ok := getNextString(); ok { //method getNextString() not shown here
		buffer.WriteString(s)
	} else {
		break
	}
}
fmt.Print(buffer.String(), "\n")

转义字符

转义字符 说明
\a 响铃（警报）
\b 退格
\f 换页
\n 换行
\r 回车
\t 制表符
\v 垂直制表符
\\ 反斜杠
\' 单引号
\" 双引号
\? 问号
\0 空字符（Null 字符）
\xhh 十六进制表示的 ASCII 字符
\uhhhh Unicode 字符，表示为 16 位的十六进制
\Uhhhhhhhh Unicode 字符，表示为 32 位的十六进制

格式化占位符

占位符 说明
%d 十进制整数
%b 二进制整数
%o 八进制整数
%x 十六进制小写字母
%X 十六进制大写字母
%f 浮点数（默认六位小数）
%e 浮点数（科学计数法）
%E 浮点数（科学计数法，大写E）
%g 浮点数（以最简洁形式输出）
%G 浮点数（以最简洁形式输出，大写E）
%s 字符串
%q 字符串（双引号括起来，转义字符）
%c Unicode 字符
%p 指针
%t 布尔值
%% 百分号（Literal %）

今儿就到这吧，再搞下去脑容量不够了🤣

学习记录 > go
#学习记录 #go #strings #strcov #btyes #转义字符 #格式化占位符
go学习记录——第五天
https://www.lx02918.ltd/2024/08/13/go-study-fifth-day/
作者
Seth
发布于
2024年8月13日
许可协议