vlambda博客
学习文章列表

哈喽，大家好，我是 Go大叔，专注分享 Go 语言知识，一起进入 Go 的大门。

大叔和身边一群大牛都无限看好 Go 语言，现在开始搞 Go 语言，过两年大概就是第一批吃螃蟹的人。

欢迎大家来到『Go 语言入门到精通』这个专栏，今天是专栏第 21 篇，大叔主要和大家分享一下 Go语言字符串与正则表达式相关的知识点。

字符串相关方法

• 获取字符串长度
• 注意: Go语言编码方式是UTF-8,在UTF-8中一个汉字占3个字节

package main
import "fmt"
func main() {
 str1 := "lnj"
 fmt.Println(len(str1)) // 3
 str2 := "lnj李南江"
 fmt.Println(len(str2)) // 12
}

• 如果字符串中包含中文, 又想精确的计算字符串中字符的个数而不是占用的字节, 那么必须先将字符串转换为rune类型数组
• Go语言中byte用于保存字符, rune用于保存汉字

package main
import "fmt"
func main() {
 str := "lnj李南江"
 // 注意byte占1个字节, 只能保存字符不能保存汉字,因为一个汉字占用3个字节
 arr1 := []byte(str) // 12
 fmt.Println(len(arr1))
 for _, v := range arr1{
  fmt.Printf("%c", v) // lnj李南江
 }

 // Go语言中rune类型就是专门用于保存汉字的
 arr2 := []rune(str)
 fmt.Println(len(arr2)) // 6
 for _, v := range arr2{
  fmt.Printf("%c", v) // lnj李南江
 }
}

• 查找子串在字符串中出现的位置

  + func Index(s, sep string) int
  + func IndexByte(s string, c byte) int
  + func IndexRune(s string, r rune) int
  + func IndexAny(s, chars string) int
  + func IndexFunc(s string, f func(rune) bool) 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

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 查找`字符`在字符串中第一次出现的位置, 找不到返回-1
 res := strings.IndexByte("hello 李南江", 'l')
 fmt.Println(res) // 2

 // 查找`汉字`OR`字符`在字符串中第一次出现的位置, 找不到返回-1
 res = strings.IndexRune("hello 李南江", '李')
 fmt.Println(res) // 6
 res = strings.IndexRune("hello 李南江", 'l')
 fmt.Println(res) // 2

 // 查找`汉字`OR`字符`中任意一个在字符串中第一次出现的位置, 找不到返回-1
 res = strings.IndexAny("hello 李南江", "wml")
 fmt.Println(res) // 2
 // 会把wmhl拆开逐个查找, w、m、h、l只要任意一个被找到, 立刻停止查找
 res = strings.IndexAny("hello 李南江", "wmhl")
 fmt.Println(res) // 0
 // 查找`子串`在字符串第一次出现的位置, 找不到返回-1
 res = strings.Index("hello 李南江", "llo")
 fmt.Println(res) // 2
 // 会把lle当做一个整体去查找, 而不是拆开
 res = strings.Index("hello 李南江", "lle")
 fmt.Println(res) // -1
 // 可以查找字符也可以查找汉字
 res = strings.Index("hello 李南江", "李")
 fmt.Println(res) // 6

 // 会将字符串先转换为[]rune, 然后遍历rune切片逐个取出传给自定义函数
 // 只要函数返回true,代表符合我们的需求, 既立即停止查找
 res = strings.IndexFunc("hello 李南江", custom)
 fmt.Println(res) // 6

 // 倒序查找`子串`在字符串第一次出现的位置, 找不到返回-1
 res := strings.LastIndex("hello 李南江", "l")
 fmt.Println(res) // 3
}
func custom(r rune) bool {
 fmt.Printf("被调用了, 当前传入的是%c\n", r)
 if r == 'o' {
  return true
 }
 return false
}

• 判断字符串中是否包含子串

  + func Contains(s, substr string) bool
  + func ContainsRune(s string, r rune) bool
  + func ContainsAny(s, chars string) bool
  + func HasPrefix(s, prefix string) bool
  + func HasSuffix(s, suffix string) bool

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 查找`子串`在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.Index函数
 res := strings.Contains( "hello 李南江", "llo")
 fmt.Println(res) // true

 // 查找`汉字`OR`字符`在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.IndexRune函数
 res = strings.ContainsRune( "hello 李南江", 'l')
 fmt.Println(res) // true
 res = strings.ContainsRune( "hello 李南江", '李')
 fmt.Println(res) // true

 // 查找`汉字`OR`字符`中任意一个在字符串中是否存在, 存在返回true, 不存在返回false
 // 底层实现就是调用strings.IndexAny函数
 res = strings.ContainsAny( "hello 李南江", "wmhl")
 fmt.Println(res) // true

 // 判断字符串是否已某个字符串开头
 res = strings.HasPrefix("lnj-book.avi", "lnj")
 fmt.Println(res) // true

 // 判断字符串是否已某个字符串结尾
 res = strings.HasSuffix("lnj-book.avi", ".avi")
 fmt.Println(res) // true
}

• 字符串比较

  + func Compare(a, b string) int
  + func EqualFold(s, t string) bool

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 比较两个字符串大小, 会逐个字符地进行比较ASCII值
 // 第一个参数 >  第二个参数 返回 1
 // 第一个参数 <  第二个参数 返回 -1
 // 第一个参数 == 第二个参数 返回 0
 res := strings.Compare("bcd", "abc")
 fmt.Println(res) // 1
 res = strings.Compare("bcd", "bdc")
 fmt.Println(res) // -1
 res = strings.Compare("bcd", "bcd")
 fmt.Println(res) // 0

 // 判断两个字符串是否相等, 可以判断字符和中文
 // 判断时会忽略大小写进行判断
 res2 := strings.EqualFold("abc", "def")
 fmt.Println(res2) // false
 res2 = strings.EqualFold("abc", "abc")
 fmt.Println(res2) // true
 res2 = strings.EqualFold("abc", "ABC")
 fmt.Println(res2) // true
 res2 = strings.EqualFold("李南江", "李南江")
 fmt.Println(res2) // true
}

• 字符串转换

  + 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
  

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 将字符串转换为小写
 res := strings.ToLower("ABC")
 fmt.Println(res) // abc
 
 // 将字符串转换为大写
 res = strings.ToUpper("abc")
 fmt.Println(res) // ABC

 // 将字符串转换为标题格式, 大部分`字符`标题格式就是大写
 res = strings.ToTitle("hello world")
 fmt.Println(res) // HELLO WORLD
 res = strings.ToTitle("HELLO WORLD")
 fmt.Println(res) // HELLO WORLD

 // 将单词首字母变为大写, 其它字符不变
 // 单词之间用空格OR特殊字符隔开
 res = strings.Title("hello world")
 fmt.Println(res) // Hello World
}

• 字符串拆合

  + func Split(s, sep string) []string
  + func SplitN(s, sep string, n int) []string
  + func SplitAfter(s, sep string) []string
  + func SplitAfterN(s, sep string, n int) []string
  + func Fields(s string) []string
  + func FieldsFunc(s string, f func(rune) bool) []string
  + func Join(a []string, sep string) string
  + func Repeat(s string, count int) string
  + func Replace(s, old, new string, n int) string

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 按照指定字符串切割原字符串
 // 用,切割字符串
 arr1 := strings.Split("a,b,c", ",")
 fmt.Println(arr1) // [a b c]
 arr2 := strings.Split("ambmc", "m")
 fmt.Println(arr2) // [a b c]

 // 按照指定字符串切割原字符串, 并且指定切割为几份
 // 如果最后一个参数为0, 那么会范围一个空数组
 arr3 := strings.SplitN("a,b,c", ",", 2)
 fmt.Println(arr3) // [a b,c]
 arr4 := strings.SplitN("a,b,c", ",", 0)
 fmt.Println(arr4) // []

 // 按照指定字符串切割原字符串, 切割时包含指定字符串
 arr5 := strings.SplitAfter("a,b,c", ",")
 fmt.Println(arr5) // [a, b, c]

 // 按照指定字符串切割原字符串, 切割时包含指定字符串, 并且指定切割为几份
 arr6 := strings.SplitAfterN("a,b,c", ",", 2)
 fmt.Println(arr6) // [a, b,c]

 // 按照空格切割字符串, 多个空格会合并为一个空格处理
 arr7 := strings.Fields("a  b c    d")
 fmt.Println(arr7) // [a b c d]

 // 将字符串转换成切片传递给函数之后由函数决定如何切割
 // 类似于IndexFunc
 arr8 := strings.FieldsFunc("a,b,c", custom)
 fmt.Println(arr8) // [a b c]

 // 将字符串切片按照指定连接符号转换为字符串
 sce := []string{"aa", "bb", "cc"}
 str1 := strings.Join(sce, "-")
 fmt.Println(str1) // aa-bb-cc


 // 返回count个s串联的指定字符串
 str2 := strings.Repeat("abc", 2)
 fmt.Println(str2) // abcabc

 // 第一个参数: 需要替换的字符串
 // 第二个参数: 旧字符串
 // 第三个参数: 新字符串
 // 第四个参数: 用新字符串 替换 多少个旧字符串
 // 注意点: 传入-1代表只要有旧字符串就替换
 // 注意点: 替换之后会生成新字符串, 原字符串不会受到影响
 str3 := "abcdefabcdefabc"
 str4 := strings.Replace(str3, "abc", "mmm", -1)
 fmt.Println(str3) // abcdefabcdefabc
 fmt.Println(str4) // mmmdefmmmdefmmm
}
func custom(r rune) bool {
 fmt.Printf("被调用了, 当前传入的是%c\n", r)
 if r == ',' {
  return true
 }
 return false
}

• 字符串清理

  + 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
  + func TrimPrefix(s, prefix string) string
  + func TrimSuffix(s, suffix string) string
  

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 去除字符串两端指定字符
 str1 := strings.Trim("!!!abc!!!def!!!", "!")
 fmt.Println(str1) // abc!!!def
 // 去除字符串左端指定字符
 str2 := strings.TrimLeft("!!!abc!!!def!!!", "!")
 fmt.Println(str2) // abc!!!def!!!
 // 去除字符串右端指定字符
 str3 := strings.TrimRight("!!!abc!!!def!!!", "!")
 fmt.Println(str3) // !!!abc!!!def
 // // 去除字符串两端空格
 str4 := strings.TrimSpace("   abc!!!def ")
 fmt.Println(str4) // abc!!!def

 // 按照方法定义规则,去除字符串两端符合规则内容
 str5 := strings.TrimFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str5) // abc!!!def
 // 按照方法定义规则,去除字符串左端符合规则内容
 str6 := strings.TrimLeftFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str6) // abc!!!def!!!
 //  按照方法定义规则,去除字符串右端符合规则内容
 str7 := strings.TrimRightFunc("!!!abc!!!def!!!", custom)
 fmt.Println(str7) // !!!abc!!!def

 // 取出字符串开头的指定字符串
 str8 := strings.TrimPrefix("lnj-book.avi", "lnj-")
 fmt.Println(str8) // book.avi

 // 取出字符串结尾的指定字符串
 str9 := strings.TrimSuffix("lnj-book.avi", ".avi")
 fmt.Println(str9) // lnj-book
}

正则表达式

• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
• 相关规则标准详见
• 百度百科
• Go语言官方文档regexp包
• Go语言中正则表达式使用步骤
• 1.创建一个正则表达式匹配规则对象
• 2.利用正则表达式匹配规则对象匹配指定字符串

package main
import (
 "strings"
 "fmt"
)
func main() {
 // 创建一个正则表达式匹配规则对象
 // reg := regexp.MustCompile(规则字符串)
 // 利用正则表达式匹配规则对象匹配指定字符串
 // 会将所有匹配到的数据放到一个字符串切片中返回
 // 如果没有匹配到数据会返回nil
 // res := reg.FindAllString(需要匹配的字符串, 匹配多少个)

 str := "Hello 李南江 1232"
 reg := regexp.MustCompile("2")
 res := reg.FindAllString(str, -1)
 fmt.Println(res) // [2 2]
 res = reg.FindAllString(str, 1)
 fmt.Println(res) // [2]
}

• 匹配电话号码

package main
import (
 "strings"
 "fmt"
)
func main() {
 res2 := findPhoneNumber("13554499311")
 fmt.Println(res2) // true

 res2 = findPhoneNumber("03554499311")
 fmt.Println(res2) // false

 res2 = findPhoneNumber("1355449931")
 fmt.Println(res2) // false
}
func findPhoneNumber(str string) bool {
 // 创建一个正则表达式匹配规则对象
 reg := regexp.MustCompile("^1[1-9]{10}")
 // 利用正则表达式匹配规则对象匹配指定字符串
 res := reg.FindAllString(str, -1)
 if(res == nil){
  return  false
 }
 return  true
}

• 匹配Email

package main
import (
 "strings"
 "fmt"
)
func main() {
 res2 = findEmail("[email protected]")
 fmt.Println(res2) // true

 res2 = findEmail("[email protected]")
 fmt.Println(res2) // false

 res2 = findEmail("123@qqcom")
 fmt.Println(res2) // false
}
func findEmail(str string) bool {
 reg := regexp.MustCompile("^[a-zA-Z0-9_]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+")
 res := reg.FindAllString(str, -1)
 if(res == nil){
  return  false
 }
 return  true
}

时间和日期函数

• 获取当前时间

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 // 2018-09-27 17:25:11.653198 +0800 CST m=+0.009759201
 fmt.Println(t)
}

• 获取年月日时分秒

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 fmt.Println(t.Year())
 fmt.Println(t.Month())
 fmt.Println(t.Day())
 fmt.Println(t.Hour())
 fmt.Println(t.Minute())
 fmt.Println(t.Second())
}

• 格式化时间

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 fmt.Printf("当前的时间是: %d-%d-%d %d:%d:%d\n", t.Year(), 
  t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())

 var dateStr = fmt.Sprintf("%d-%d-%d %d:%d:%d", t.Year(), 
  t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
fmt.Println("当前的时间是:", dateStr)
}

package main

import (
 "fmt"
 "time"
)
func main()  {
 var t time.Time = time.Now()
 // 2006/01/02 15:04:05这个字符串是Go语言规定的, 各个数字都是固定的
 // 字符串中的各个数字可以只有组合, 这样就能按照需求返回格式化好的时间
 str1 := t.Format("2006/01/02 15:04:05")
 fmt.Println(str1)
 str2 := t.Format("2006/01/02")
 fmt.Println(str2)
 str3 := t.Format("15:04:05")
 fmt.Println(str3)
}

• 时间常量
• 一般用于指定时间单位, 和休眠函数配合使用
• 例如: 100毫秒, 100 *time.Millisecond

const (
 Nanosecond  Duration = 1    // 纳秒
 Microsecond          = 1000 * Nanosecond // 微秒
 Millisecond          = 1000 * Microsecond // 毫秒
 Second               = 1000 * Millisecond // 秒
 Minute               = 60 * Second // 分钟
 Hour                 = 60 * Minute // 小时
)

package main

import (
 "fmt"
 "time"
)
func main()  {
 for{
  // 1秒钟打印一次
  time.Sleep(time.Second * 1)
  // 0.1秒打印一次
  //time.Sleep(time.Second * 0.1)
  time.Sleep(time.Millisecond * 100)
  fmt.Println("Hello LNJ")
 }
}

• 获取当前时间戳
• Unix秒
• UnixNano纳秒
• 一般用于配合随机函数使用, 作为随机函数随机种子

package main

import (
 "fmt"
 "time"
)

func main()  {
 t := time.Now()
 // 获取1970年1月1日距离当前的时间(秒)
 fmt.Println(t.Unix())
 // 获取1970年1月1日距离当前的时间(纳秒)
 fmt.Println(t.UnixNano())
}

package main

import (
 "fmt"
 "math/rand"
 "time"
)
func main()  {
 // 创建随机数种子
 rand.Seed(time.Now().UnixNano())
 // 生成一个随机数
 fmt.Println(rand.Intn(10))
}

一个人走的太慢，一群人才能走的更远。

最后，分享不易，喜欢大叔的文章，记得分享、点赞、在看、三连支持！