判断前后缀
HasPrefix() 判断字符串 s 是否以 prefix 开头： strings.HasPrefix(s, prefix string) bool HasSuffix() 判断字符串 s 是否以 suffix 结尾： strings.HasSuffix(s, suffix string) bool
example：
package main
import (
"fmt"
"strings"
)
func main() {
pre := "Thi"
str1 := "This is a Go program!"
fmt.Println(strings.HasPrefix(str1, pre))
fmt.Println(strings.HasSuffix(str1, "ram"))
}
字符串包含
Contains(s string, substr string) bool
example
package main
import (
"fmt"
"strings"
)
func main() {
substr := "is"
str1 := "This is a Go program!"
fmt.Println(strings.Contains(str1, substr))
}
字符串索引
//返回的int是按字节数，若s中不存在str返回-1
strings.Index(s, str string) int strings.LastIndex(s, str string) int strings.IndexRune(s string, r rune) int
example
func test_3() {
str1 := "this is 米大米"
fmt.Println(strings.Index(str1, "is")) //2
fmt.Println(strings.LastIndex(str1, "is"))//5
fmt.Println(strings.IndexRune(str1, '大'))//11
}
字符串替换
//将s中出现的old子字符串替换为new字符串，共替换n个；若n=-1则替换全部的old字符串为new字符串。
strings.Replace(s string, old string, new string, n int) string
example
func test() {
str6 := "aaa aa bb cc aa"
fmt.Println(strings.Replace(str6, "aa", "A", 3)) //Aa A bb cc A
fmt.Println(strings.Replace(str6, "a", "AA", 3)) //AAAAAA aa bb cc aa
统计字符串出现的次数
strings.Count(s string, substr string) int
func test() {
str2 := "abcdefaaaa"
fmt.Println(strings.Count(str2, "aa")) //2
}
生成重复字符串
strings.Repeat(s string, count int) string
example
package main
import (
"fmt"
"strings"
)
func main() {
s := "This is a go program!"
fmt.Println(strings.Repeat(s, 2)) //This is a go program!This is a go program!
}
修改字符串大小
strings.ToLower(s string) string strings.ToUpper(s string) string
example
package main
import (
"fmt"
"strings"
)
func main() {
s := "This is a Go program!"
fmt.Println(strings.ToLower(s)) //this is a go program!
fmt.Println(strings.ToUpper(s)) //THIS IS A GO PROGRAM!
}
修剪字符串
strings.TrimSpace(s string) string //剔除字符串开头和结尾的空白符号;如果你想要剔除指定字符 strings.Trim(s string cutset string) string //修剪s两端出现的cutset，必须是在两端 strings.TrimLeft(s string, cutset string) string //修剪左端出现的cutset strings.TrumRight(s string, cutset string) string //修剪右端出现的cutset
example
package main
import (
"fmt"
"strings"
)
func main() {
s := "ThisThis is a Go program!This"
fmt.Println(strings.Trim(s, "This")) // is a Go program!
fmt.Println(strings.TrimLeft(s, "This"))//is a Go program!This
fmt.Println(strings.TrimRight(s, "This"))//ThisThis is a Go program!
}
分割字符串
//用1个或多个空白符号来作为动态长度的分隔符将字符串分割成若干小块，并返回一个 slice，如果字符串只包含空白符号，则返回一个长度为 0 的 slice。
strings.Fields(s string) []string
//用于自定义分割符号来对指定字符串进行分割，同样返回slice。 strings.Split(s string, sep string) []string
example
func test_5() {
str := " a b a c d a "
fmt.Printf("%v", strings.Fields(str)) //[a b a c d a]会自动去除两端的空格
fmt.Printf("%v", strings.Split(str, "a")) //[ b c d ]会保留空格
str2 := "/a/b//c/"
fmt.Printf("%v", strings.Split(str2, "/")) //[ a b c ]
}
func test_5() {
str := " a b a c d a "
fmt.Printf("%v", strings.Fields(str)) //[a b a c d a]会自动去除两端的空格
fmt.Printf("%v", strings.Split(str, "a")) //[ b c d ]会保留空格
str2 := "/a/b//c/"
fmt.Printf("%v", strings.Split(str2, "/")) //[ a b c ]
}
strings.Reader类型（从字符串中读取内容）
type Reader struct {
s string // 要读取的字符串
i int64 // 当前读取的偏移量位置，从 i 处开始读取数据
prevRune int // 读取的前一个字符的偏移量位置，小于 0 表示之前未读取字符
}
// 创建一个从 s 读取数据的 Reader。本函数类似 bytes.NewBufferString，但是更有效率，且为只读的
func NewReader(s string) *Reader
// 返回 r 包含的字符串还没有被读取的部分的长度
func (r *Reader) Len() int
// 从 r 中读取最多 len(b) 字节数据并写入 b，返回读取的字节数和可能遇到的任何错误。如果无可读数据返回 0 个字节，且返回值 err 为 io.EOF
func (r *Reader) Read(b []byte) (n int, err error)
// 将索引位置 off 之后的所有数据写入到 b 中，返回读取的字节数和读取过程中遇到的错误
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
// 读取并返回一个字节。如果没有可用的数据，会返回错误
func (r *Reader) ReadByte() (b byte, err error)
// 撤消前一次的 ReadByte 操作，即偏移量向前移动一个字节，UnreadByte 操作前必须要有 ReadByte 操作
func (r *Reader) UnreadByte() error
// 读取并返回一个字符写入到 ch 中，size 为 ch 的字节大小，err 返回读取过程遇到的错误
func (r *Reader) ReadRune() (ch rune, size int, err error)
// 撤销前一次的 ReadRune 操作，即偏移量向前移动一个字符，UnreadRune 操作前必须要有 ReadRune 操作
func (r *Reader) UnreadRune() error
// 设置下一次读的位置。offset 为相对偏移量，而 whence 决定相对位置：0 为相对文件开头，1 为相对当前位置，2 为相对文件结尾
// 返回新的偏移量（相对开头）和可能的错误
func (r *Reader) Seek(offset int64, whence int) (int64, error)
// 将底层数据切换为 s，同时复位所有标记（读取位置等信息）
func (r *Reader) Reset(s string)
// 从 r 中读取数据写入接口 w 中，返回读取的字节数和可能遇到的任何错误
func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
源码分析
package strings
import (
"errors"
"io"
"unicode/utf8"
)
type Reader struct {
s string
i int64 // current reading index
prevRune int // index of previous rune; or < 0
}
func (r *Reader) Len() int { //返回的是未读取的长度
if r.i >= int64(len(r.s)) {
return 0
}
return int(int64(len(r.s)) - r.i)
}
func (r *Reader) Size() int64 { return int64(len(r.s)) } //返回的是底层字符串的总长度
func (r *Reader) Read(b []byte) (n int, err error) { //读取剩余字符串内容到切片b中
if r.i >= int64(len(r.s)) {
return 0, io.EOF
}
r.prevRune = -1
n = copy(b, r.s[r.i:]) //注意这里使用的是copy函数，当b的存储大小小于剩余内容长度时只能复制一部分
r.i += int64(n)
return
}
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) { //从off开始读取内容到b中
// cannot modify state - see io.ReaderAt
if off < 0 {
return 0, errors.New("strings.Reader.ReadAt: negative offset")
}
if off >= int64(len(r.s)) {
return 0, io.EOF
}
n = copy(b, r.s[off:])
if n < len(b) {
err = io.EOF
}
return
}
func (r *Reader) ReadByte() (byte, error) { //读取一个字节的内容
r.prevRune = -1
if r.i >= int64(len(r.s)) {
return 0, io.EOF
}
b := r.s[r.i]
r.i++
return b, nil
}
func (r *Reader) UnreadByte() error { //撤销上次ReadByte操作
if r.i <= 0 {
return errors.New("strings.Reader.UnreadByte: at beginning of string")
}
r.prevRune = -1
r.i--
return nil
}
func (r *Reader) ReadRune() (ch rune, size int, err error) { //读取一个rune字符
if r.i >= int64(len(r.s)) {
r.prevRune = -1
return 0, 0, io.EOF
}
r.prevRune = int(r.i)
if c := r.s[r.i]; c < utf8.RuneSelf {
r.i++
return rune(c), 1, nil
}
ch, size = utf8.DecodeRuneInString(r.s[r.i:])
r.i += int64(size)
return
}
func (r *Reader) UnreadRune() error { //撤销上次的ReadRune操作
if r.i <= 0 {
return errors.New("strings.Reader.UnreadRune: at beginning of string")
}
if r.prevRune < 0 {
return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune")
}
r.i = int64(r.prevRune)
r.prevRune = -1
return nil
}
func (r *Reader) Seek(offset int64, whence int) (int64, error) {
r.prevRune = -1
var abs int64
switch whence { //offset 为相对偏移量，而 whence 决定相对位置：0 为相对文件开头，1 为相对当前位置，2 为相对文件结尾
case io.SeekStart:
abs = offset
case io.SeekCurrent:
abs = r.i + offset
case io.SeekEnd:
abs = int64(len(r.s)) + offset
default:
return 0, errors.New("strings.Reader.Seek: invalid whence")
}
if abs < 0 {
return 0, errors.New("strings.Reader.Seek: negative position")
}
r.i = abs
return abs, nil
}
func (r *Reader) Reset(s string) { *r = Reader{s, 0, -1} } // 将底层数据切换为 s，同时复位所有标记（读取位置等信息）
func NewReader(s string) *Reader { return &Reader{s, 0, -1} }//生成一个Reader
func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
r.prevRune = -1
if r.i >= int64(len(r.s)) {
return 0, nil
}
s := r.s[r.i:]
m, err := io.WriteString(w, s)
if m > len(s) {
panic("strings.Reader.WriteTo: invalid WriteString count")
}
r.i += int64(m)
n = int64(m)
if m != len(s) && err == nil {
err = io.ErrShortWrite
}
return
}
标签：string,fmt,int64,func,Reader,strings From： https://www.cnblogs.com/dadishi/p/17055372.html