Golang 学习笔记（03）—— 字符串操作

作者: ChainZhang | 来源:发表于2017-08-14 18:39 被阅读131次

Golang

1、Contains

func Contains(s, substr string) bool这个函数是查找某个字符是否在这个字符串中存在，存在返回true.

package main
import "fmt"
import "strings"

func main(){
    fmt.Println(strings.Contains("chain", "ch"))
    fmt.Println(strings.Contains("ch", "chain"))
    fmt.Println(strings.Contains("chain", ""))    //true
    fmt.Println(strings.Contains("", ""))           //true 这里要特别注意
    fmt.Println(strings.Contains("我是中国人", "我"))     //true
}

运行结果：

2、ContainsAny

func ContainsAny(s, chars string) bool这个是查询字符串中是否包含多个字符.

package main
import "fmt"
import "strings"

func main(){
    fmt.Println(strings.ContainsAny("chain", "b"))        // false
    fmt.Println(strings.ContainsAny("chain", "c & i")) // true
    fmt.Println(strings.ContainsAny("chain", ""))          // false
    fmt.Println(strings.ContainsAny("", ""))             // false
}

运行结果：

3、ContainsRune

func ContainsRune(s string, r rune) bool,这里边当然是字符串中是否包含rune类型，其中rune类型是utf8.RUneCountString可以完整表示全部Unicode字符的类型

package main
import "fmt"
import "strings"

func main(){
 fmt.Println(strings.ContainsRune("chain", rune('c'))) //true
 fmt.Println(strings.ContainsRune("chain", 99))        //true
 fmt.Println(strings.Contains("我是中国人", "我"))     //true
}

运行结果：

其中99是c的Unicode编码

4、Count

func Count(s, sep string) int这个的作用就是输出，在一段字符串中有多少匹配到的字符.

package main
import "fmt"
import "strings"

func main(){
 fmt.Println(strings.Count("chainn", "nn")) //1
 fmt.Println(strings.Count("chainn", "n"))  //2
 fmt.Println(strings.Count("chain", ""))  // before & after each rune result:6
}

运行结果：

5、Index

func Index(s, sep string) int 这个函数是查找字符串，然后返回当前的位置，输入的都是string类型，然后int的位置信息。

package main
import "fmt"
import "strings"

func main(){
  fmt.Println(strings.Index("chain", "h")) //1
  fmt.Println(strings.Index("chainn", "n")) //4
  fmt.Println(strings.Index("chainn", "q")) //4
  fmt.Println(strings.Index("我是中国人", "中"))     // 返回 6
}
}

运行结果：

注意：
index是从0开始计数的

6、IndexAny

func IndexAny(s, chars string) int这个函数是一样的查找，字符串第一次出现的位置，如果不存在就返回-1.

package main
import "fmt"
import "strings"

func main(){
    fmt.Println(strings.IndexAny("chainn", "n")) //4
    fmt.Println(strings.IndexAny("我是中国人", "中")) // 在存在返回 6
    fmt.Println(strings.IndexAny("我是中国人", "和")) // 在存在返回 -1
}

运行结果：

7、IndexByte

func IndexByte(s string, c byte) int,这个函数功能还是查找第一次粗线的位置，只不过这次C是byte类型的，查找到返回位置，找不到返回-1。

package main
import "fmt"
import "strings"

func main(){
    fmt.Println(strings.IndexByte("hello chain", 'c')) //6
    fmt.Println(strings.IndexByte("hello chain", 'b')) //-1
    //fmt.Println(strings.IndexAny("我是中国人", "中")) // 编译报错
}

运行结果：

8、IndexRune

func IndexRune(s string, r rune) int，还是查找位置，只不过这次是rune类型的。

package main
import "fmt"
import "strings"

func main(){
    fmt.Println(strings.IndexRune("chain", rune('c'))) //0
    fmt.Println(strings.IndexRune("chain", 's')) //  -1
    fmt.Println(strings.IndexRune("我是中国人", '中'))   //6
}

运行结果：

9、IndexFunc

func IndexFunc(s string, f func(rune) bool) int这个函数大家一看就知道了，是通过类型的转换来用函数查找位置，我们来代码看下哈。

package main
import "fmt"
import "strings"

func main() {
 fmt.Println(strings.IndexFunc("chaina", split)) //2
 fmt.Println(strings.IndexFunc("chbin", split)) //-1
}
func split(r rune) bool {
 if r == 'a' {
  return true
 }
 return false
}

10、LastIndex

func LastIndex(s, sep string) int 看到这个大家可能也明白了查找的是最后出现的位置，正好跟index相反。

package main
import "fmt"
import "strings"

func main() {
  fmt.Println(strings.LastIndex("chaina", "a")) // 5
}

运行结果：

11、LastIndexAny

func LastIndexAny(s, chars string) int这个跟indexAny正好相反，也是查找最后一个

package main
import "fmt"
import "strings"

func main() {
  fmt.Println(strings.LastIndexAny("chaina", "a")) // 5
}

运行结果：

12、EqualFold

func EnqualFold(s string, t string) bool,两个字符串比较，忽略大小写，返回bool类型。

package main
import "fmt"
import "strings"

func main() {
  fmt.Println(strings.EqualFold("chain", "CHAIN")) // true
  fmt.Println(strings.EqualFold("chain", "CHAI")) // false
}

运行结果：

13、Join

func Join(s []string, seq string) string将字符串数组按照指定的分隔符拼接成字符串。

package main
import "fmt"
import "strings"

func main() {
    s := []string{"foo", "bar", "baz"}
    fmt.Println(strings.Join(s, ", ")) // 返回字符串：foo, bar, baz
}

运行结果：

14、Map

func Map(mapping func(rune)rune, s string) string, 如果mapping方法返回个合法的字符串，改方法返回一个由mapping方法修改过的复制过来的字符串。

package main
import "fmt"
import "strings"

func main() {
     rot13 := func(r rune) rune {
        switch {
        case r >= 'A' && r <= 'Z':
            return 'A' + (r-'A'+13)%26
        case r >= 'a' && r <= 'z':
            return 'a' + (r-'a'+13)%26
        }
        return r
    }
    fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))
}

运行结果：

15、Repeat

func Repeat(s string, count int)string，改方法返回一个新的重复指定次数的字符串。

package main
import "fmt"
import "strings"

func main() {
    fmt.Println("ba" + strings.Repeat("na", 2)) //banana
}

运行结果：

16、Replace

func Replace(s, old, new string, count int)string返回一个新的字符串，参数s是原来的字符串，old是需要被替换掉的字符串，new是要替代old的字符串，count是替换的次数，如果为-1，则为全部替换。

package main
import "fmt"
import "strings"

func main() {
    fmt.Println(strings.Replace("oink oink oink", "k", "ky", 5))
    fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
    fmt.Println(strings.Replace("oink oink oink", "k", "ky", -1))
}

运行结果：

17、Split

func Split(s, seq string)[]string将字符串按照指定的字符串分割生一个字符串数组。

package main
import "fmt"
import "strings"

func main() {
    fmt.Printf("%q\n", strings.Split("a,b,c", ","))
    fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
    fmt.Printf("%q\n", strings.Split(" xyz ", ""))
    fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
}

运行结果：

18、SplitN

func SplitN(s, seq string, count int)[]string将字符串按照指定的字符串分割生一个指定元素数量的字符串数组。该方法返回的数组将不保留分隔符。count参数为-1时效果如Split。

package main
import "fmt"
import "strings"

func main() {
    fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 1))
    fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 2))  
    fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", -1)) 
    fmt.Printf("%q\n", strings.SplitN("home,m_ta,src", ",", 2))   
    fmt.Printf("%q\n", strings.SplitN("#home#m_ta#src", "#", -1)) 
}

运行结果：

19、SplitAfter

func SplitAfter(s, seq string)[]string将字符串按照指定的字符串分割生一个字符串数组。该方法返回的数组将保留分隔符，且至于每个元素的末端。

package main
import "fmt"
import "strings"

func main() {
  fmt.Printf("%q\n", strings.SplitAfter("/home/m_ta/src", "/")) //["/" "home/" "m_ta/" "src"]
}

运行结果：

20、SplitAfterN

func SplitAfterN(s, seq string, count int)[]string将字符串按照指定的字符串分割生一个指定元素数量的字符串数组。该方法返回的数组将保留分隔符，且至于每个元素的末端。count参数为-1时效果如SplitAfter。

package main
import "fmt"
import "strings"

func main() {
    fmt.Printf("%q\n", strings.SplitAfterN("/home/m_ta/src", "/", 2))  //["/" "home/m_ta/src"]
    fmt.Printf("%q\n", strings.SplitAfterN("#home#m_ta#src", "#", -1)) //["/" "home/" "m_ta/" "src"]
}

运行结果：

21、Title

func Title(s string)string该方法返回一个新的字符串，该字符串把原字符串的单词首字母改为大写，对中文没有效果。

package main
import "fmt"
import "strings"

func main() {
    fmt.Println(strings.Title("her royal highness"))
    fmt.Println(strings.Title("her rOYal highness"))
    fmt.Println(strings.Title("我是中国人"))
}

运行结果：

22、ToTitle

func ToTitle(s string)string将字符串转为大写字母。

package main
import "fmt"
import "strings"
func main() {
    fmt.Println(strings.ToTitle("loud noises"))
    fmt.Println(strings.ToTitle("loud 中国"))
}

运行结果：

23、ToLower

func ToLower(s string)string将字符串转为小写字母。

package main
import "fmt"
import "strings"
func main() {
 fmt.Println(strings.ToLower("CHain")) //chain
}

运行结果：

24、ToUpper

func ToUpper(s string)string将字符串转为大写字母。

package main
import "fmt"
import "strings"
func main() {
    fmt.Println(strings.ToUpper("Chain"))
}

运行结果：

25、Trim

func Trim(s, cutset string)string去除字符串中首尾指定的字符。

package main
import "fmt"
import "strings"
func main() {
    fmt.Println( strings.Trim("!!!Chain!!!", "!"))
}

运行结果：

26、TrimLeft

func TrimLeft(s, cutset string)string去除字符串中左侧指定的字符。

package main
import "fmt"
import "strings"
func main() {
    fmt.Println( strings.TrimLeft("!!!Chain!!!", "!"))
}

运行结果：

27、TrimSpace

func TrimSpace(s stirng)string去除字符串中首尾的空白部分。

package main
import "fmt"
import "strings"
func main() {
    fmt.Println( strings.TrimSpace("\t\n a lone gopher \n\t\r\n"))
}

运行结果：

完

转载请注明出处：Golang 学习笔记（03）—— 字符串操作

目录
 上一节：Golang 学习笔记（2）—— 函数
 下一节：Golang 学习笔记（04）—— array, slice, map

网友评论

本文标题：Golang 学习笔记（03）—— 字符串操作

本文链接：https://www.haomeiwen.com/subject/ncfprxtx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

Golang 学习笔记（03）—— 字符串操作

1、Contains

2、ContainsAny

3、ContainsRune

4、Count

5、Index

6、IndexAny

7、IndexByte

8、IndexRune

9、IndexFunc

10、LastIndex

11、LastIndexAny

12、EqualFold

13、Join

14、Map

15、Repeat

16、Replace

17、Split

18、SplitN

19、SplitAfter

20、SplitAfterN

21、Title

22、ToTitle

23、ToLower

24、ToUpper

25、Trim

26、TrimLeft

27、TrimSpace

完

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Golang

程序员

Golang

go语言学习

Go知识库