字符串相關(guān)方法
- 獲取字符串長度
- 注意: Go語言編碼方式是UTF-8,在UTF-8中一個漢字占3個字節(jié)
package main
import "fmt"
func main() {
str1 := "lnj"
fmt.Println(len(str1)) // 3
str2 := "lnj李南江"
fmt.Println(len(str2)) // 12
}
- 如果字符串中包含中文, 又想精確的計算字符串中字符的個數(shù)而不是占用的字節(jié), 那么必須先將字符串轉(zhuǎn)換為rune類型數(shù)組
- Go語言中byte用于保存字符, rune用于保存漢字
package main
import "fmt"
func main() {
str := "lnj李南江"
// 注意byte占1個字節(jié), 只能保存字符不能保存漢字,因?yàn)橐粋€漢字占用3個字節(jié)
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李南江
}
}
- 查找子串在字符串中出現(xiàn)的位置
- 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() {
// 查找`字符`在字符串中第一次出現(xiàn)的位置, 找不到返回-1
res := strings.IndexByte("hello 李南江", 'l')
fmt.Println(res) // 2
// 查找`漢字`OR`字符`在字符串中第一次出現(xiàn)的位置, 找不到返回-1
res = strings.IndexRune("hello 李南江", '李')
fmt.Println(res) // 6
res = strings.IndexRune("hello 李南江", 'l')
fmt.Println(res) // 2
// 查找`漢字`OR`字符`中任意一個在字符串中第一次出現(xiàn)的位置, 找不到返回-1
res = strings.IndexAny("hello 李南江", "wml")
fmt.Println(res) // 2
// 會把wmhl拆開逐個查找, w司忱、m救赐、h侍芝、l只要任意一個被找到, 立刻停止查找
res = strings.IndexAny("hello 李南江", "wmhl")
fmt.Println(res) // 0
// 查找`子串`在字符串第一次出現(xiàn)的位置, 找不到返回-1
res = strings.Index("hello 李南江", "llo")
fmt.Println(res) // 2
// 會把lle當(dāng)做一個整體去查找, 而不是拆開
res = strings.Index("hello 李南江", "lle")
fmt.Println(res) // -1
// 可以查找字符也可以查找漢字
res = strings.Index("hello 李南江", "李")
fmt.Println(res) // 6
// 會將字符串先轉(zhuǎn)換為[]rune, 然后遍歷rune切片逐個取出傳給自定義函數(shù)
// 只要函數(shù)返回true,代表符合我們的需求, 既立即停止查找
res = strings.IndexFunc("hello 李南江", custom)
fmt.Println(res) // 6
// 倒序查找`子串`在字符串第一次出現(xiàn)的位置, 找不到返回-1
res := strings.LastIndex("hello 李南江", "l")
fmt.Println(res) // 3
}
func custom(r rune) bool {
fmt.Printf("被調(diào)用了, 當(dāng)前傳入的是%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
// 底層實(shí)現(xiàn)就是調(diào)用strings.Index函數(shù)
res := strings.Contains( "hello 李南江", "llo")
fmt.Println(res) // true
// 查找`漢字`OR`字符`在字符串中是否存在, 存在返回true, 不存在返回false
// 底層實(shí)現(xiàn)就是調(diào)用strings.IndexRune函數(shù)
res = strings.ContainsRune( "hello 李南江", 'l')
fmt.Println(res) // true
res = strings.ContainsRune( "hello 李南江", '李')
fmt.Println(res) // true
// 查找`漢字`OR`字符`中任意一個在字符串中是否存在, 存在返回true, 不存在返回false
// 底層實(shí)現(xiàn)就是調(diào)用strings.IndexAny函數(shù)
res = strings.ContainsAny( "hello 李南江", "wmhl")
fmt.Println(res) // true
// 判斷字符串是否已某個字符串開頭
res = strings.HasPrefix("lnj-book.avi", "lnj")
fmt.Println(res) // true
// 判斷字符串是否已某個字符串結(jié)尾
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() {
// 比較兩個字符串大小, 會逐個字符地進(jìn)行比較ASCII值
// 第一個參數(shù) > 第二個參數(shù) 返回 1
// 第一個參數(shù) < 第二個參數(shù) 返回 -1
// 第一個參數(shù) == 第二個參數(shù) 返回 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
// 判斷兩個字符串是否相等, 可以判斷字符和中文
// 判斷時會忽略大小寫進(jìn)行判斷
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
}
- 字符串轉(zhuǎn)換
- 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() {
// 將字符串轉(zhuǎn)換為小寫
res := strings.ToLower("ABC")
fmt.Println(res) // abc
// 將字符串轉(zhuǎn)換為大寫
res = strings.ToUpper("abc")
fmt.Println(res) // ABC
// 將字符串轉(zhuǎn)換為標(biāo)題格式, 大部分`字符`標(biāo)題格式就是大寫
res = strings.ToTitle("hello world")
fmt.Println(res) // HELLO WORLD
res = strings.ToTitle("HELLO WORLD")
fmt.Println(res) // HELLO WORLD
// 將單詞首字母變?yōu)榇髮? 其它字符不變
// 單詞之間用空格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]
// 按照指定字符串切割原字符串, 并且指定切割為幾份
// 如果最后一個參數(shù)為0, 那么會范圍一個空數(shù)組
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]
// 將字符串轉(zhuǎn)換成切片傳遞給函數(shù)之后由函數(shù)決定如何切割
// 類似于IndexFunc
arr8 := strings.FieldsFunc("a,b,c", custom)
fmt.Println(arr8) // [a b c]
// 將字符串切片按照指定連接符號轉(zhuǎn)換為字符串
sce := []string{"aa", "bb", "cc"}
str1 := strings.Join(sce, "-")
fmt.Println(str1) // aa-bb-cc
// 返回count個s串聯(lián)的指定字符串
str2 := strings.Repeat("abc", 2)
fmt.Println(str2) // abcabc
// 第一個參數(shù): 需要替換的字符串
// 第二個參數(shù): 舊字符串
// 第三個參數(shù): 新字符串
// 第四個參數(shù): 用新字符串 替換 多少個舊字符串
// 注意點(diǎn): 傳入-1代表只要有舊字符串就替換
// 注意點(diǎn): 替換之后會生成新字符串, 原字符串不會受到影響
str3 := "abcdefabcdefabc"
str4 := strings.Replace(str3, "abc", "mmm", -1)
fmt.Println(str3) // abcdefabcdefabc
fmt.Println(str4) // mmmdefmmmdefmmm
}
func custom(r rune) bool {
fmt.Printf("被調(diào)用了, 當(dāng)前傳入的是%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
// 按照方法定義規(guī)則,去除字符串兩端符合規(guī)則內(nèi)容
str5 := strings.TrimFunc("!!!abc!!!def!!!", custom)
fmt.Println(str5) // abc!!!def
// 按照方法定義規(guī)則,去除字符串左端符合規(guī)則內(nèi)容
str6 := strings.TrimLeftFunc("!!!abc!!!def!!!", custom)
fmt.Println(str6) // abc!!!def!!!
// 按照方法定義規(guī)則,去除字符串右端符合規(guī)則內(nèi)容
str7 := strings.TrimRightFunc("!!!abc!!!def!!!", custom)
fmt.Println(str7) // !!!abc!!!def
// 取出字符串開頭的指定字符串
str8 := strings.TrimPrefix("lnj-book.avi", "lnj-")
fmt.Println(str8) // book.avi
// 取出字符串結(jié)尾的指定字符串
str9 := strings.TrimSuffix("lnj-book.avi", ".avi")
fmt.Println(str9) // lnj-book
}
正則表達(dá)式
- 正則表達(dá)式是對字符串操作的一種邏輯公式枕磁，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規(guī)則字符串”，這個“規(guī)則字符串”用來表達(dá)對字符串的一種過濾邏輯。
- 相關(guān)規(guī)則標(biāo)準(zhǔn)詳見
- Go語言中正則表達(dá)式使用步驟
- 1.創(chuàng)建一個正則表達(dá)式匹配規(guī)則對象
- 2.利用正則表達(dá)式匹配規(guī)則對象匹配指定字符串
package main
import (
"strings"
"fmt"
)
func main() {
// 創(chuàng)建一個正則表達(dá)式匹配規(guī)則對象
// reg := regexp.MustCompile(規(guī)則字符串)
// 利用正則表達(dá)式匹配規(guī)則對象匹配指定字符串
// 會將所有匹配到的數(shù)據(jù)放到一個字符串切片中返回
// 如果沒有匹配到數(shù)據(jù)會返回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 {
// 創(chuàng)建一個正則表達(dá)式匹配規(guī)則對象
reg := regexp.MustCompile("^1[1-9]{10}")
// 利用正則表達(dá)式匹配規(guī)則對象匹配指定字符串
res := reg.FindAllString(str, -1)
if(res == nil){
return false
}
return true
}
package main
import (
"strings"
"fmt"
)
func main() {
res2 = findEmail("123@qq.com")
fmt.Println(res2) // true
res2 = findEmail("ab?de@qq.com")
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
}
時間和日期函數(shù)
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āng)前的時間是: %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("當(dāng)前的時間是:", dateStr)
}
package main
import (
"fmt"
"time"
)
func main() {
var t time.Time = time.Now()
// 2006/01/02 15:04:05這個字符串是Go語言規(guī)定的, 各個數(shù)字都是固定的
// 字符串中的各個數(shù)字可以只有組合, 這樣就能按照需求返回格式化好的時間
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)
}
- 時間常量
- 一般用于指定時間單位, 和休眠函數(shù)配合使用
- 例如: 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")
}
}
- 獲取當(dāng)前時間戳
- Unix秒
- UnixNano納秒
- 一般用于配合隨機(jī)函數(shù)使用, 作為隨機(jī)函數(shù)隨機(jī)種子
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
// 獲取1970年1月1日距離當(dāng)前的時間(秒)
fmt.Println(t.Unix())
// 獲取1970年1月1日距離當(dāng)前的時間(納秒)
fmt.Println(t.UnixNano())
}
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
// 創(chuàng)建隨機(jī)數(shù)種子
rand.Seed(time.Now().UnixNano())
// 生成一個隨機(jī)數(shù)
fmt.Println(rand.Intn(10))
}
