GO语言
01GO基础-001GO语言简介
01GO基础-002语言环境安装
01GO基础-003Go 语言结构
01GO基础-004Go 语言基础语法1
01GO基础-004Go 语言基础语法2
01GO基础-004Go 语言基础语法3
01GO基础-005Go 语言数据类型
01GO基础-006Go 语言变量
01GO基础-007Go 语言常量
01GO基础-008Go 语言运算符
01GO基础-009条件语句
01GO基础-010循环语句
01GO基础-011函数
01GO基础-012变量作用域
01GO基础-013数组
01GO基础-014指针
01GO基础-015结构体
01GO基础-016切片
01GO基础-017范围(Range)
01GO基础-018Map
01GO基础-019递归函数
01GO基础-020类型转换
01GO基础-021接口
01GO基础-022异常处理
01GO基础-023并发
01GO基础-024strings
01GO基础-025可变参数
01GO基础-026接口2
01GO基础-027异常处理2
01GO基础-028sync包详解
01GO基础-029Context
02GO进阶001包
02GO进阶002init()函数
02GO进阶003包的注意点
02GO进阶003使用go module导入本地包
02GO进阶004 time包
02GO进阶005 file操作
02GO进阶006 io操作
02GO进阶007 os包(文件 I/O、文件属性、目录与链接、创建和移除链接)
02GO进阶008复制文件
02GO进阶009断点续传
02GO进阶010 bufio包
02GO进阶011ioutil包
02GO进阶012遍历文件夹
02GO进阶013并发编程介绍
02GO进阶014Goroutine协程
02GO进阶015 GPM
02GO进阶016 runtime包
02GO进阶017 Channel
02GO进阶018 Goroutine池
02GO进阶019 定时器
02GO进阶020 select
02GO进阶021并发安全和锁
02GO进阶022sync
02GO进阶023原子操作
02GO进阶024 GMP原理与调度
02GO进阶025爬虫小案例
02GO进阶026 面向对象-匿名字段
02GO进阶026 面向对象-接口
02GO进阶027网络编程-互联网协议介绍
02GO进阶027网络编程-socket
02GO进阶027网络编程-http编程
02GO进阶027网络编程-websocket编程
02GO进阶028数据操作-MYSQL
02GO进阶028数据操作-REDIS
02GO进阶028数据操作-RTCD
02GO进阶028数据操作-ZOOKEEPER
02GO进阶028数据操作-KAFKA
02GO进阶028数据操作-RabbitMQ
02GO进阶028数据操作-ElasticSearch
02GO进阶028数据操作-NSQ
02GO进阶028数据操作-memcached
02GO进阶028数据操作-GORM
02GO进阶029beego框架-安装
02GO进阶029beego框架-快速入门
02GO进阶029beego框架-MVC架构介绍-controller设计-参数配置
02GO进阶029beego框架-MVC架构介绍-controller设计-路由设置
02GO进阶029beego框架-MVC架构介绍-controller设计-控制器函数
02GO进阶029beego框架-MVC架构介绍-controller设计-XSRF过滤
02GO进阶029beego框架-MVC架构介绍-controller设计-请求数据处理
02GO进阶029beego框架-MVC架构介绍-controller设计-Session控制
02GO进阶029beego框架-MVC架构介绍-controller设计-过滤器
02GO进阶029beego框架-MVC架构介绍-controller设计-Flash数据
02GO进阶029beego框架-MVC架构介绍-controller设计-URL构建
02GO进阶029beego框架-MVC架构介绍-controller设计-多种格式数据输出
02GO进阶029beego框架-MVC架构介绍-controller设计-表单数据验证
02GO进阶029beego框架-MVC架构介绍-controller设计-错误处理
02GO进阶029beego框架-MVC架构介绍-controller设计-日志处理
02GO进阶029beego框架-MVC架构介绍-model设计-概述
02GO进阶029beego框架-MVC架构介绍-model设计-CRUD操作
02GO进阶029beego框架-MVC架构介绍-model设计-高级查询
02GO进阶029beego框架-MVC架构介绍-model设计-原生SQL查询
02GO进阶029beego框架-MVC架构介绍-model设计-构造查询
02GO进阶029beego框架-MVC架构介绍-model设计-事务处理
02GO进阶029beego框架-MVC架构介绍-model设计-模型定义
02GO进阶029beego框架-MVC架构介绍-model设计-命令模式
02GO进阶029beego框架-MVC架构介绍-model设计-测试用例
02GO进阶029beego框架-MVC架构介绍-view设计-beego 模板语法指南
02GO进阶029beego框架-MVC架构介绍-view设计-模板处理
02GO进阶029beego框架-MVC架构介绍-view设计-其他
本文档使用 MrDoc 发布
-
+
首页
01GO基础-024strings
strings标准库包主要涉及字符串的基本操作。 常见字符串的操作有: 字符串求长度 求子串 是否存在某个字符或者子串 子串出现的次数(字符串匹配) 字符串分割(切分)成[]string 字符串是否存在某个前缀或后缀 字符或者子串在字符串中首次出现的位置或最后一次出现的位置 通过某个字符串将[]string进行拼接 字符串重复次数 字符串中子串替换 大小写转换 ...等等一些基本操作。 由于string类型可以看成是一种特殊的slice类型,因此获取长度可以用内置的函数len;同时支持 切片 操作,因此,子串获取很容易。 说明:这里说的字符是rune类型,即一个UTF-8字符(Unicode代码点)。 ------------ ## 子串 ### 是否存在某个字符或子串 ```go // 子串substr在s中,返回true func Contains(s, substr string) bool // chars中任何一个Unicode代码点在s中,返回true func ContainsAny(s, chars string) bool // Unicode代码点r在s中,返回true func ContainsRune(s string, r rune) bool ``` 示例代码:ContainsAny 函数说明 ```go fmt.Println(strings.ContainsAny("team", "i")) //false fmt.Println(strings.ContainsAny("failure", "u & i")) //true fmt.Println(strings.ContainsAny("in failure", "s g")) //true fmt.Println(strings.ContainsAny("foo", "")) //false fmt.Println(strings.ContainsAny("", "")) //false ``` 第二个参数 chars 中任意一个字符(Unicode Code Point)如果在第一个参数 s 中存在,则返回true。 上述三个函数的源码都是调用函数Index(子串出现的位置函数),然后和0比较返回true或false。如,contains函数: ```go func Contains(s, substr string) bool { return Index(s, substr) >= 0 } ``` ### 字符或子串在字符串中出现的位置 ```go //返回子串sep在字符串s中第一次出现的索引值,不在的话返回-1. func Index(s, sep string) int //chars中任何一个Unicode代码点在s中首次出现的位置,不存在返回-1 func IndexAny(s, chars string) int //查找字符 c 在 s 中第一次出现的位置,其中 c 满足 f(c) 返回 true func IndexFunc(s string, f func(rune) bool) int //rune类型是int32别名,UTF-8字符格式编码。 //返回字符c在s中第一次出现的位置 func IndexByte(s string, c byte) int //byte是字节类型 // Unicode 代码点 r 在 s 中第一次出现的位置 func IndexRune(s string, r rune) int //查找最后一次出现的位置 func LastIndex(s, sep string) int func LastIndexByte(s string, c byte) int func LastIndexAny(s, chars string) int func LastIndexFunc(s string, f func(rune) bool) int ``` 示例:IndexFunc 的例子。 ```go fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool { if c > 'u' { return true } return false })) //输出:4 匿名函数传递 因为 y 的 Unicode 代码点大于 u 的代码点。带入匿名函数进行比较 ``` ### 子串出现次数 ```go func Count(s, sep string) int //子串在s字符串中出现的次数 ``` (1)、特别说明一下的是当 sep 为空时,Count 的返回值是:utf8.RuneCountInString(s) + 1 (2)、Count 是计算子串在字符串中出现的无重叠的次数 ### 字符串是否有某个前缀或后缀 ```go // s 中是否以 prefix 开始 func HasPrefix(s, prefix string) bool { return len(s) >= len(prefix) && s[0:len(prefix)] == prefix } // s 中是否以 suffix 结尾 func HasSuffix(s, suffix string) bool { return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix } ``` ### golang语言中的rune类型 转载链接:http://ju.outofmemory.cn/entry/245284 Rune 是int32 的别名。用UTF-8 进行编码。这个类型在什么时候使用呢?例如需要遍历字符串中的字符。可以循环每个字节(仅在使用US ASCII 编码字符串时与字符等价,而它们在Go中不存在!)。因此为了获得实际的字符,需要使用rune类型。在UTF-8 世界的字符有时被称作runes。通常,当人们讨论字符时,多数是指8 位字符。UTF-8 字符可能会有32 位,称作rune。 例如 s:="Go编程" fmt.Println(len(s)) 输出结果应该是8 因为中文字符是用3个字节存的。 len(string(rune('编'))) 的结果是3 如果想要获得我们想要的情况的话,需要先转换为rune切片再使用内置的len函数 fmt.Println(len([]rune(s))) 结果就是 4 了。 所以用string存储 unicode 的话,如果有中文,按下标是访问不到的,因为你只能得到一个 byte 。 要想访问中文的话,还是要用rune切片,这样就能按下表访问。 ------------ 字符串转换 ```go func ToUpper(s string) string func ToLower(s string) string func ToTitle(s string) string func ToUpperSpecial(_case unicode.SpecialCase, s string) string func ToLowerSpecial(_case unicode.SpecialCase, s string) string func ToTitleSpecial(_case unicode.SpecialCase, s string) string func Title(s string) string ``` ------------ 字符串比较 ```go func Compare(a, b string) int //返回不相等-1或者 相等0 func EqualFold(s, t string) bool ``` ------------ 字符串清理 ```go func Trim(s string, cutset string) string //去除字符串的头尾子字符串 func TrimLeft(s string, cutset string) string func TrimRight(s string, cutset string) string func TrimFunc(s string, f func(rune) bool) string //函数 func TrimLeftFunc(s string, f func(rune) bool) string func TrimRightFunc(s string, f func(rune) bool) string func TrimSpace(s string) string //字符串前后空格 fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) 输出:a lone gopher func TrimPrefix(s, prefix string) string func TrimSuffix(s, suffix string) string ``` 代码示例: ```go func main(){ var s = "aaasddfgaaaa" fun := func (c rune) bool { if c != 'a'{ return false } return true } fmt.Println(strings.TrimFunc(s, fun)) //输出 sddfg } ``` ------------ ## 拆合函数 ### Fields ```go func Fields(s string) []string func FieldsFunc(s string, f func(rune) bool) []string ``` Fields 用一个或多个连续的空格分隔字符串 s,返回子字符串的数组(slice)。如果字符串 s 只包含空格,则返回空列表([]string的长度为0)。其中,空格的定义是 unicode.IsSpace,之前已经介绍过。 由于是用空格分隔,因此结果中不会含有空格或空子字符串。 FieldsFunc 用这样的Unicode代码点 c 进行分隔:满足 f(c) 返回 true。该函数返回[]string。如果字符串 s 中所有的代码点(unicode code points)都满足f(c)或者 s 是空,则 FieldsFunc 返回空slice。也就是说,我们可以通过实现一个回调函数来指定分隔字符串 s 的字符。 示例: ```go fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz ")) fmt.Println(strings.FieldsFunc(" foo bar baz ", unicode.IsSpace)) ``` ### split 这四个函数放在一起讲,是因为是通过同一个内部函数实现的。 ```go func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) } func SplitAfter(s, sep string) []string { return genSplit(s, sep, len(sep), -1) } func SplitN(s, sep string, n int) []string { return genSplit(s, sep, 0, n) } func SplitAfterN(s, sep string, n int) []string { return genSplit(s, sep, len(sep), n) } ``` 它们都调用了 `genSplit` 函数。 这四个函数都是通过 sep 进行分割,返回`[]string`。如果 sep 为空,相当于分成一个个的 UTF-8 字符,如 `Split("abc","")`,得到的是[a b c]。 Split(s, sep) 和 SplitN(s, sep, -1) 等价;SplitAfter(s, sep) 和 SplitAfterN(s, sep, -1) 等价。 那么,Split 和 SplitAfter 有啥区别呢?通过这两句代码的结果就知道它们的区别了: ```go fmt.Printf("%q\n", strings.Split("foo,bar,baz", ",")) // ["foo" "bar" "baz"] fmt.Printf("%q\n", strings.SplitAfter("foo,bar,baz", ",")) // ["foo," "bar," "baz"] ``` 也就是说,Split 会将 s 中的 sep 去掉,而 SplitAfter 会保留 sep。 带 N 的方法可以通过最后一个参数 n 控制返回的结果中的 slice 中的元素个数,当 n < 0 时,返回所有的子字符串;当 n == 0 时,返回的结果是 nil;当 n > 0 时,表示返回的 slice 中最多只有 n 个元素,其中,最后一个元素不会分割,比如: ```go fmt.Printf("%q\n", strings.SplitN("foo,bar,baz", ",", 2)) // ["foo" "bar,baz"] ``` ### Join `func Join(a []string, sep string) string` 将字符串数组(或slice)连接起来可以通过 Join 实现。 假如没有这个库函数,我们自己实现一个,我们会这么实现: ```go func Join(str []string, sep string) string { // 特殊情况应该做处理 if len(str) == 0 { return "" } if len(str) == 1 { return str[0] } buffer := bytes.NewBufferString(str[0]) for _, s := range str[1:] { buffer.WriteString(sep) buffer.WriteString(s) } return buffer.String() } ``` 使用了 bytes 包的 Buffer 类型,避免大量的字符串连接操作(因为 Go 中字符串是不可变的)。 标准库的实现: ```go func Join(a []string, sep string) string { if len(a) == 0 { return "" } if len(a) == 1 { return a[0] } n := len(sep) * (len(a) - 1) for i := 0; i < len(a); i++ { n += len(a[i]) } b := make([]byte, n) //借助 字节切片实现 bp := <strong><span style="color:#ff0000;">copy</span></strong>(b, a[0]) for _, s := range a[1:] { bp += copy(b[bp:], sep) bp += copy(b[bp:], s) } return str ``` 标准库的实现没有用 bytes 包,当然也不会简单的通过 + 号连接字符串。Go 中是不允许循环依赖的,标准库中很多时候会出现代码拷贝,而不是引入某个包。这里 Join 的实现方式挺好,我个人猜测,不直接使用 bytes 包,也是不想依赖 bytes 包(其实 bytes 中的实现也是 copy 方式)。 ### 字符串重复次数 func Repeat(s string, count int) string ------------ ### 字符串替换 // 用 new 替换 s 中的 old,一共替换 n 个。 // 如果 n < 0,则不限制替换次数,即全部替换 func Replace(s, old, new string, n int) string func Map(mapping func(rune) rune, s string) string //满足函数实现的进行替换 ------------ ### Replacer 这是一个结构,没有导出任何字段(字段值小写),实例化通过 ```go // A Replacer replaces a list of strings with replacements. type Replacer struct { r replacer //接口类型 } // replacer is the interface that a replacement algorithm needs to implement. type replacer interface { Replace(s string) string WriteString(w io.Writer, s string) (n int, err error) } ``` `func NewReplacer(oldnew ...string) *Replacer` 函数进行,其中不定参数 oldnew 是 old-new 对,即进行多个替换。 ```go type Replacer struct { ... } // 创建一个替换规则,参数为“查找内容”和“替换内容”的交替形式。 // 替换操作会依次将第 1 个字符串替换为第 2 个字符串,将第 3 个字符串 // 替换为第 4 个字符串,以此类推。 // 替换规则可以同时被多个例程使用。 func NewReplacer(oldnew ...string) *Replacer // 使用替换规则对 s 进行替换并返回结果。 func (r *Replacer) Replace(s string) string // 使用替换规则对 s 进行替换并将结果写入 w。 // 返回写入的字节数和遇到的错误。 func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error) ``` 程序示例: ```go r := strings.NewReplacer("<", "<", ">", ">") fmt.Println(r.Replace("This is <b>HTML</b>!")) // 输出结果是 This is <b>HTML</b>! ``` ------------ ## Reader 看到名字就能猜到,这是实现了 io 包中的接口。它实现了 io.Reader(Read 方法),io.ReaderAt(ReadAt 方法),io.Seeker(Seek 方法),io.WriterTo(WriteTo 方法),io.ByteReader(ReadByte 方法),io.ByteScanner(ReadByte 和 UnreadByte 方法),io.RuneReader(ReadRune 方法) 和 io.RuneScanner(ReadRune 和 UnreadRune 方法)。 Reader 结构如下: ```go type Reader struct { s string // Reader 读取的数据来源 i int // current reading index(当前读的索引位置) prevRune int // index of previous rune; or < 0(前一个读取的 rune 索引位置) } ``` 可见 Reader 结构没有导出任何字段,而是提供一个实例化方法: func NewReader(s string) *Reader 该方法接收一个字符串,返回的 Reader 实例就是从该参数字符串读数据。在后面学习了 bytes 包之后,可以知道 bytes.NewBufferString 有类似的功能,不过,如果只是为了读取,NewReader 会更高效。 ```go func (r *Reader) Read(b []byte) (n int, err error) func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) func (r *Reader) WriteTo(w io.Writer) (n int64, err error) func (r *Reader) Seek(offset int64, whence int) (int64, error) func (r *Reader) ReadByte() (byte, error) func (r *Reader) UnreadByte() error func (r *Reader) ReadRune() (ch rune, size int, err error) func (r *Reader) UnreadRune() error func (r *Reader) Len() int func (r *Reader) Size() int64 func (r *Reader) Reset(s string) ``` 其他方法不介绍了,都是之前接口的实现,有兴趣的可以看看源码实现比较简单易懂,大部分都是根据 i、prevRune 两个属性来控制。 参考网址:http://www.cnblogs.com/golove/p/3236300.html https://books.studygolang.com/The-Golang-Standard-Library-by-Example/chapter02/02.1.html
admin
2024年12月20日 15:21
转发文档
收藏文档
上一篇
下一篇
手机扫码
复制链接
手机扫一扫转发分享
复制链接
Markdown文件
分享
链接
类型
密码
更新密码