17-Go语言的字符串

作者: 喝酸奶要舔盖__ | 来源:发表于2018-10-01 15:59 被阅读0次

字符串

字符串长度

获取字符串长度
- 字符串在Go语言中的本质是一个切片, 如果想要获取切片的长度, 可以通过len()函数来获取
  所以字符串长度也是用len()函数来获取
- 注意点:
  - len()函数获取字符串长度的时候, 获取的是字节数
  - 在Go语言中中文是按照UTF-8编码的, 所以一个中文占用3个字节
  - 如果想要获取的是中文的个数, 而不是字节数, 那么需要将字符串转换为rune类型的切片才行

package main

import "fmt"

func main() {
    /*
    1.获取字符串长度
    字符串在Go语言中的本质是一个切片, 如果想要获取切片的长度, 可以通过len()函数来获取
    所以字符串长度也是用len()函数来获取

    2.注意点:
    2.1len()函数获取字符串长度的时候, 获取的是字节数
    在Go语言中中文是按照UTF-8编码的, 所以一个中文占用3个字节
    2.2如果想要获取的是中文的个数, 而不是字节数, 那么需要将字符串转换为rune类型的切片才行
    */

    //定义一个字符串
    str1 := "wjh"
    //len()获取字符串长度的时候,获取的是字节数
    fmt.Println(len(str1)) //3

    str2 := "妞子"
    //Go语言中中文是按照UTF-8编码的, 所以一个中文占用3个字节
    fmt.Println(len(str2)) //6

    //想要获取的是中文的个数, 而不是字节数, 那么需要将字符串转换为rune类型的切片才行
    str3 := "加固地"
    var str4 []rune = []rune(str3)
    fmt.Println(len(str4)) //3
}

字符串相关函数

字符串查找函数

查找子串在字符串中出现的位置的函数
1.从左至右查找
func IndexByte(s string, c byte) int
func IndexRune(s string, r rune) int
func IndexAny(s, chars string) int
func Index(s, sep string) int
func IndexFunc(s string, f func(rune) bool) int
2.从右至左查找
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.从左至右查找
    func IndexByte(s string, c byte) int
    func IndexRune(s string, r rune) int
    func IndexAny(s, chars string) int
    func Index(s, sep string) int
    func IndexFunc(s string, f func(rune) bool) int
    2.从右至左查找
    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
    */
    

    //1.func IndexByte(s string, c byte) int
    //函数说明: 查找指定字符在字符串中的位置
    //注意点:  从左至右的查找, 一旦找到了, 就不会继续查找的
    //        只能查找字符, 不能查找中文
    //        如果找到了就返回字符在字符串中的位置, 如果没有找到就会-1
    str1 := "www.it666.com"
    //str2 := "我是珲哥"
    index1 := strings.IndexByte(str1,'7')
    //index2 := strings.IndexByte(str2,"珲")
    fmt.Println(index1)
    //fmt.Println(index2)
    

    //2. func IndexRune(s string, r rune) int
    //函数说明:查找指定字符在字符串中的位置
    // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
    //         可以查找字符, 也可以查找中文
    //         如果找到了就返回字符在字符串中的位置, 如果没有找到就会-1
    //         在返回找到的索引的时候, 如果前面有中文, 那么一个中文按照3个索引计算
    str1 := "www.it666.com"
    str2 := "我是珲哥"
    index1 := strings.IndexRune(str1,'t')
    fmt.Println(index1)//5
    index2 := strings.IndexRune(str2,'珲')
    fmt.Println(index2)//6 中文是按3个索引计算
    

    //3.func IndexAny(s, chars string) int
    //查找指定字符在字符串中的位置
    //注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
    //        查找时不是将第二个参数当做一个整体查找, 是拆开来查找, 返回找到的最前面一个值
    str1 := "www.it666.com"
    str2 := "我是珲哥"
    index1 := strings.IndexAny(str1,"1t6")
    fmt.Println(index1)//4
    index2 := strings.IndexAny(str2, "珲哥")
    fmt.Println(index2)//6
    
    
    //4.func Index(s, sep string) int
    // 2.查找指定字符在字符串中的位置
    // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
    //        查找时会将第二个参数当做一个整体查找
    str1 := "www.it666.com"
    str2 := "我是珲哥"
    index1 := strings.Index(str1,"i66")
    fmt.Println(index1)
    index2 := strings.Index(str2,"珲哥哥")
    fmt.Println(index2)
    

    //5.func IndexFunc(s string, f func(rune) bool) int
    // 2.查找指定字符在字符串中的位置
    // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
    // IndexFunc方法会将字符串转换成一个[]rune, 然后遍历切片,
    // 逐个将切片中的元素传递给自定义的函数, 只要自定义函数返回true就代表找到了
    str1 := "www.it666.com"
    index1 := strings.IndexFunc(str1,constom)
    fmt.Println(index1)
    

    //从右向左查找

    //1.func LastIndex(s, sep string) int
    //注意点: 从右往左查找,把第二个字符串当做一个整体
    str1 := "www.it666.com"
    index1 := strings.LastIndex(str1,"com")
    fmt.Println(index1)
    

    //2.func LastIndexAny(s, chars string) int
    //从右往左查找,把第二个字符串拆分成单个字符查找

    str1 := "www.it666.com"
    index := strings.LastIndexAny(str1,"43i")
    fmt.Println(index)

}
//func(rune) bool
func constom(ch rune) bool{
    if ch == 'i' {
        // 一旦return的是true就代表告诉IndexFunc方法, 找到了我们需要查找的字符
        return true
    }else {
        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() {
    /*
    字符串包含
    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
    */

    //1. func Contains(s, substr string) bool
    // 作用: 判断字符串中是否包含指定的子串
    // 如果包含返回true, 如果不包含返回false
    str1 := "www.it666.com"
    str2 := "67"
    str3 := "我是珲哥"
    str4 := "珲"
    res := strings.Contains(str1,str2)
    res2 := strings.Contains(str3,str4)
    fmt.Println(res)
    fmt.Println(res2)


    //2.func ContainsRune(s string, r rune) bool
    //作用: 判断字符串中是否包含指定的字符
    //如果包含返回true, 如果不包含返回false
    str1 := "www.it666.com"
    str2 := "我是珲哥"
    res := strings.ContainsRune(str1,'i')
    res2 := strings.ContainsRune(str2,'珲')
    fmt.Println(res)
    fmt.Println(res2)

    //3.func ContainsAny(s, chars string) bool
    // 作用: 判断字符串中是否包含指定的子串中任意一个字符
    // 如果包含返回true, 如果不包含返回false
    str1 := "www.it666.com"
    res := strings.ContainsAny(str1,"3i4")
    fmt.Println(res)

    //4.func HasPrefix(s, prefix string) bool
    //函数作用: 判断字符串是否以prefix字符串开头
    str1 := "www.it666.com"
    res := strings.HasPrefix(str1,"ww")
    fmt.Println(res)
    
    //5.func HasSuffix(s, suffix string) bool
    //函数作用: 判断字符串是否以suffix字符串结尾
    str1 := "www.it666.com"
    res := strings.HasSuffix(str1,"com")
    fmt.Println(res)
}

字符串比较函数

字符串比较
func Compare(a, b string) int
func EqualFold(s, t string) bool

package main

import (
    "strings"
    "fmt"
)

func main() {
    /*
    字符串比较
    func Compare(a, b string) int
    func EqualFold(s, t string) bool
    */

    //1. func Compare(a, b string) int
    // 比较两个字符串
    // 如果两个字符串相等, 那么返回0
    // 如果两个字符串不相等
    // 第一个字符串 > 第二个字符串 返回 1
    // 第一个字符串 < 第二个字符串 返回 -1
    str1 := "124"
    str2 := "124"
    res := strings.Compare(str1,str2)
    fmt.Println(res)

    //比较中文
    str3 := "加固滴"
    str4 := "加固滴1"
    res2 := strings.Compare(str3,str4)
    fmt.Println(res2)

    //2.func EqualFold(s, t string) bool
    //EqualFold作用:
    //比较两个字符串是否相等, 相等返回true, 不相等返回false
    str1 := "124"
    str2 := "125"
    res := strings.EqualFold(str1,str2)
    fmt.Println(res)
}

字符串转换函数

字符串转换
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() {
    /*
    字符串转换
    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
     */

    //1.func ToUpper(s string) string
    //小写字母转换成大写字母函数
    str1 := "www.it666.com"
    str2 := strings.ToUpper(str1)
    fmt.Println(str2)

    //2.func ToLower(s string) string
    //大写字母转换成小写字母函数

    str1 := "WJH"
    str2 := strings.ToLower(str1)
    fmt.Println(str2)

    //3.func ToTitle(s string) string
    //返回将所有字母都转为对应的标题版本的拷贝(小写转大写)
    str1 := "www.it666.com"
    str2 := strings.ToTitle(str1)
    fmt.Println(str2) //WWW.IT666.COM

    //4.func Title(s string) string
    //作用: 将单词的首字母大写, 单词之间用空格或者- /隔开
    str1 := "hello world"
    str2 := strings.Title(str1)
    fmt.Println(str2)//Hello World
}

字符串拆分与合并

字符串拆合
1.字符串切割
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
2.按照空格切割字符串
func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []string
3.字符串合并
func Join(a []string, sep string) string

4.重复生成字符串
func Repeat(s string, count int) string

5.替换字符串
func Replace(s, old, new string, n int) string

package main

import (
    "strings"
    "fmt"
)

func main() {
    /*
    字符串拆合
    1.字符串切割
    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
    2.按照空格切割字符串
    func Fields(s string) []string
    func FieldsFunc(s string, f func(rune) bool) []string
    3.字符串合并
    func Join(a []string, sep string) string

    4.重复生成字符串
    func Repeat(s string, count int) string

    5.替换字符串
    func Replace(s, old, new string, n int) string
    */

    //1.字符串切割
    //1.1 func Split(s, sep string) []string
    // 作用: 按照指定字符串切割原有字符串
    // 注意点:切割之后的结果, 不包含指定的字符串
    str1 := "abd/def/jk"
    sce := strings.Split(str1,"/")
    fmt.Println(sce)
    


    //1.2func SplitN(s, sep string, n int) []string
    // 作用: 按照指定字符串切割原有字符串, 切割为指定的份数
    // 注意点: 切割之后的结果, 不包含指定的字符串
    //         n = -1,返回所有的子字符串组成的切片
    str1 := "abd,def,jk"
    sce := strings.SplitN(str1,",",-1)
    fmt.Println(sce)
    

    //1.3func SplitAfter(s, sep string) []string
    // 作用: 按照指定字符串切割原有字符串
    // 注意点: 切割之后的结果, 包含指定的字符串
    str1 := "abd,def,jk"
    sce := strings.SplitAfter(str1,",")
    fmt.Println(sce)
    
    //1.4func SplitAfterN(s, sep string, n int) []string
    // 作用: 按照指定字符串切割原有字符串, 切割为指定的份数
    // 注意点: 切割之后的结果, 包含指定的字符串
    str1 := "abd,def,jk,fn"
    sce := strings.SplitAfterN(str1,",",-1)
    fmt.Println(sce)


    //2.按照空格切割字符串
    //2.1 func Fields(s string) []string
    // 作用: 按照空格切割原有字符串
    // 注意点: 连续的多个空格会按照一个空格来处理
    str := "abc eed    fff lda"
    sce := strings.Fields(str)
    fmt.Println(sce)
    fmt.Println(len(sce))

    //2.2func FieldsFunc(s string, f func(rune) bool) []string
    // 作用: 函数返回true就切片, 返回false就不切割
    str1 := "abc eed    fff lda"
    str2 := "abc-eed-fff-lda"
    sce1 := strings.FieldsFunc(str1,fn)
    sce2 := strings.FieldsFunc(str2,fn)
    fmt.Println(sce1)
    fmt.Println(sce2)

    //3.字符串合并
    //func Join(a []string, sep string) string
    // 作用: 按照指定字符连接切片中的元素
    sce := []string{"www","it666","com"}
    fmt.Println(sce)//[www it666 com]
    str := strings.Join(sce, ".")
    fmt.Println(str) //www.it666.com*/

    //4.重复生成字符串
    //func Repeat(s string, count int) string
    // 作用: 将原有字符串重复指定次数后生成一个新的字符串
    str := "123"
    str1 := strings.Repeat(str,3)
    fmt.Println(str1)

    //5.func Replace(s, old, new string, n int) string
    // 作用: 将原有字符串中的, 指定字符串替换为新的字符串
    //      最后一个参数用于指定替换多少个, 如果传入-1全部都替换
    str := "asd123asd444"
    str1 := strings.Replace(str,"asd","qqq",-1)
    fmt.Println(str1)

}
func fn(ch rune)bool  {
    if ch == ' ' {
        return true
    }else {
        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() {
    /*
    字符串清理
    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
     */

    //1.func Trim(s string, cutset string) string
    // 作用: 返回字符串前后两端去掉指定字符串之后的新字符串
    str1 := "123www.it666.com123"
    str2 := "     www.it666.com   "
    str3 := strings.Trim(str1, "123")
    str4 := strings.Trim(str2, " ")
    fmt.Println(str3)
    fmt.Println(str4)

    //2.func TrimLeft(s string, cutset string) string
    // 作用: 返回字符串前端去掉指定字符串之后的新字符串
    //3.func TrimRight(s string, cutset string) string
    // 作用: 返回字符串后端去掉指定字符串之后的新字符串
    str1 := "123www.it666.com"
    str2 := "www.it666.com123"
    restr1 := strings.TrimLeft(str1,"123")
    restr2 := strings.TrimRight(str2,"123")
    fmt.Println(restr1)
    fmt.Println(restr2)

    //3.func TrimFunc(s string, f func(rune) bool) string
    str := "     www.it666.com   "
    restr := strings.TrimFunc(str,fn)
    fmt.Println(restr)
    


    //4.func TrimSpace(s string) string
    //作用: 去除两端的空格
    str := "     www.it666.com   "
    restr := strings.TrimSpace(str)
    fmt.Println(restr)
    

    //5.func TrimSuffix(s, suffix string) string
    //去除后端指定的字符串,返回新的字符串
    //6.func TrimPrefix(s, prefix string) string
    //去除前端指定的字符串,返回新的字符串
    str := "01-HelloWorld.mp4"
    str1 := strings.TrimSuffix(str,".mp4")
    fmt.Println(str1)

}
func fn(ch rune)bool  {
    if ch == ' ' {
        return true
    }else {
        return false
    }
}

正则表达式

正则表达式基本概念

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合
组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑
Go语言中正则表达式使用步骤
- 创建一个正则表达式匹配规则对象
- 利用正则表达式匹配规则对象匹配指定字符串

package main

import (
    "regexp"
    "fmt"
)

func main() {
    /*
    正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合
    组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

    Go语言中正则表达式使用步骤
    1.创建一个正则表达式匹配规则对象
    2.利用正则表达式匹配规则对象匹配指定字符串
    */

    //需求:去处字符串中的123
    str := "你好123张三123李四"
    //定义正则表达式
    //1.创建一个正则表达式匹配规则对象
    regx,_ := regexp.Compile("123")
    //2.利用正则表达式匹配规则对象匹配指定字符串
    sce := regx.FindAllString(str,-1)
    fmt.Println(sce)
}

筛选电话号码和邮箱

package main

import (
    "regexp"
    "fmt"
)

func main() {
    /*
    1.从字符串中提取电话号码
    2.从字符串中提取邮箱
     */

     //从字符串中提取邮箱
    /*str := "今天天气很好97606813@qq.cn你吃饭了吗?linanjiang@it666.com"
    //创建正则表达式匹配规则
    regx,_ := regexp.Compile("[a-zA-Z0-9_]+@[a-zA-Z0-9]+\\.[a-zA-Z]+")
    //根据正则表达式规则匹配满足的字符串
    res := regx.FindAllString(str,-1)
    fmt.Println(res)*/

    //从字符串中提取电话号码
    str := "李abc13554499311def江15812345678def"
    //创建正则表达式匹配规则
    regx, _ := regexp.Compile("1[0-9]{10}")
    //根据正则表达式规则匹配满足的字符串
    res := regx.FindAllString(str,-1)
    fmt.Println(res)
}

17-Go语言的字符串

字符串

字符串长度

字符串相关函数

正则表达式

正则表达式基本概念

筛选电话号码和邮箱

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读