1 fmt
…
2 os
…
3 io
…
4 strconv
4.1 ParseBool()
package main
import (
"fmt"
"strconv"
)
func main() {
// 根据传入的bool值转成string类型数据
// FormatBool(b bool) string
var isOk bool = true
boolString := strconv.FormatBool(isOk)
fmt.Printf("bool 类型的数据转成字符串类型：%v type %T\n", boolString, boolString)
// bool 类型的数据转成字符串类型：true type string
}
4.2 ParseFloat()
package main
import (
"fmt"
"strconv"
)
func main() {
// float类型转成字符串
// FormatFloat(f float64, fmt byte, prec, bitSize int) string
/*
函数将浮点数表示为字符串并返回。
bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'
（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'
（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。
prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、
'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表
示f。
*/
num := 8.265646565
floatString := strconv.FormatFloat(float64(num), 'f', -1, 64)
fmt.Printf("数据换前：%v 算换后：%v 转换后的类型 %T\n", num, floatString, floatString)
// 数据换前：8.265646565 算换后：8.265646565 转换后的类型 string
}
4.3 ParseInt()
package main
import (
"fmt"
"strconv"
)
func main() {
// 字符串转Int类型数据
// ParseInt(s string, base int, bitSize int) (i int64, err error)
/*
返回字符串表示的整数值，接受正负号。
s 目标字符串
base 制定当前字符串是那种进制
bitsize 保存结果的bit位数
return int64 的数据 err
*/
g_string := "10001001"
parseInt1, _ := strconv.ParseInt(g_string, 2, 64)
fmt.Printf("字符串 10001001 二进制 转成 10 进制的数据 --> %v 类型是：%T\n", parseInt1, parseInt1)
// 字符串 10001001 二进制 转成 10 进制的数据 --> 137 类型是：int64
g_string2 := "-AA"
parseInt2, _ := strconv.ParseInt(g_string2, 16, 64)
fmt.Printf("字符串 -AA 16进制 转成 10 进制的数据 --> %v 类型是：%T\n", parseInt2, parseInt2)
// 字符串 AA 16进制 转成 10 进制的数据 --> -170 类型是：int64
// 16进制数 AA 转成 10 进制数据 170
}
4.4 ParseUint()
package main
import (
"fmt"
"strconv"
)
func main() {
// 字符串转Int类型数据
// ParseUint(s string, base int, bitSize int) (i uint64, err error)
// 和 ParseInt 一样，只是不能接受正负号
/*
s 目标字符串
base 制定当前字符串是那种进制
bitsize 保存结果的bit位数
return int64 的数据 err
*/
g_string := "10001001"
parseInt1, _ := strconv.ParseUint(g_string, 2, 64)
fmt.Printf("字符串 10001001 二进制 转成 10 进制的数据 --> %v 类型是：%T\n", parseInt1, parseInt1)
// 字符串 10001001 二进制 转成 10 进制的数据 --> 137 类型是：int64
g_string2 := "AA"
parseInt2, _ := strconv.ParseUint(g_string2, 16, 64)
fmt.Printf("字符串 AA 16进制 转成 10 进制的数据 --> %v 类型是：%T\n", parseInt2, parseInt2)
// 字符串 AA 16进制 转成 10 进制的数据 --> -170 类型是：int64
// 16进制数 AA 转成 10 进制数据 170
}
4.5 FormatBool()
package main
import (
"fmt"
"strconv"
)
func main() {
// 根据传入的bool值转成string类型数据
// FormatBool(b bool) string
var isOk bool = true
boolString := strconv.FormatBool(isOk)
fmt.Printf("bool 类型的数据转成字符串类型：%v type %T\n", boolString, boolString)
// bool 类型的数据转成字符串类型：true type string
}
4.6 FormatFloat()
package main
import (
"fmt"
"strconv"
)
func main() {
// float类型转成字符串
// FormatFloat(f float64, fmt byte, prec, bitSize int) string
/*
函数将浮点数表示为字符串并返回。
bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'
（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'
（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。
prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、
'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表
示f。
*/
num := 8.265646565
floatString := strconv.FormatFloat(float64(num), 'f', -1, 64)
fmt.Printf("数据换前：%v 算换后：%v 转换后的类型 %T\n", num, floatString, floatString)
// 数据换前：8.265646565 算换后：8.265646565 转换后的类型 string
}
4.7 FormatInt()
package main
import (
"fmt"
"strconv"
)
func main() {
// int类型的数据转成字符串类型数据
// FormatInt(i int64, base int) string
// 返回i的base进制的字符串表示。base 必须在2到36之间
// ，结果中会使用小写字母'a'到'z'表示大于10的数字
// 装成base 进制的字符串形式
// 传入的数据必须先转成 int64l类型的
num := -999
intString := strconv.FormatInt(int64(num),2)
fmt.Printf("数字 -999 转成2进制的数据：%v 类型：%T\n",intString,intString)
// 数字 -999 转成2进制的数据：-1111100111 类型：string
}
4.8 FormatUint()
package main
import (
"fmt"
"strconv"
)
func main() {
// Uint转成string
// FormatUint(i uint64, base int) string
num := 999
uintString := strconv.FormatUint(uint64(num), 2)
fmt.Printf("数字 -999 转成2进制的数据：%v 类型：%T\n", uintString, uintString)
// 数字 -999 转成2进制的数据：1111100111 类型：string
}
5 bufio
…
6 bytes
…
7 strings
7.1 HasPrefix()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断 字符串的前缀是不是指定的字符串
// HasPrefix(s,prefix string) bool
/*
s 目标字符串
prefix 判断的字符串
return bool
*/
g_string := "shafjdhfgjsha;2yoias"
// 前缀是否是feng
isPrefix := strings.HasPrefix(g_string, "feng")
fmt.Println("字符串g_string的前缀是否是feng --> ", isPrefix)
// 字符串g_string的前缀是否是feng --> false
}
7.2 HasSuffix()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断字符串的后缀是不是指定字符串
// HasSuffix(s,suffix string) bool
/*
s 目标字符串
suffix 判断的字符串
return bool
*/
g_string := "gsljajks,kjdhas224"
// 判断字符串后缀是不是6566
isSuffix := strings.HasSuffix(g_string, "6566")
fmt.Println("字符串g_string的后缀是不是6566 ——> ", isSuffix)
// 字符串g_string的后缀是不是6566 ——> false
}
7.3 Contains()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断字符串是否包含子串
// Contains(s,Substr string) bool
/*
s 目标字符串
Substr 字符串
return bool
*/
g_string := "我爱我的家乡，和我的祖国！"
// 判断 字符串是否包含子串 “家乡，和我的”
isContains := strings.Contains(g_string, "家乡，和我的")
fmt.Println("字符串g_string 是否包含 '家乡，和我的' --> ", isContains)
// 字符串g_string 是否包含 '家乡，和我的' --> true
}
7.4 ContainsAny()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断字符串是否包含子串中的任意一个字符
// ContainsAny(s,Substr string) bool
/*
s 目标字符串
Substr 子字符串
return bool
*/
g_string := "我爱我的家乡，和我的祖国！"
// 判断 字符串是否包含子串 “家乡，和我的”
isContains := strings.ContainsAny(g_string, "家佳士得")
fmt.Println("字符串g_string 是否包含 '家佳士得'的任意一个字符 --> ", isContains)
// 字符串g_string 是否包含 '家佳士得'的任意一个字符 --> true
}
7.5 Count()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断 字符串中含有多少个自子串--- 不重复的 111 只能算一个 11
// Count(s,Seq string) int
/*
s 目标字符串
seq 子串
return int 含有子串的数量
*/
g_string := "436.3131111.116793.45632.5"
// 判断字符串中含有多少个子串 11
hasCount := strings.Count(g_string,"11")
fmt.Printf("字符串g_string含有 %v 个子串 ‘11’\n",hasCount)
// 字符串g_string含有 3 个子串 ‘11’
}
7.6 Index()
package main
import (
"fmt"
"strings"
)
func main() {
// 判断 字符串第一次出现子串的下标 没有返回 -1
// Index(s,Seq string) int
/*
s 目标字符串
seq 子串
return int 子串出现的位置
*/
g_string := "436.3131111.116793.45632.5"
// 判断字符串第一次子串 11的位置
seqIndex := strings.Index(g_string, "11")
fmt.Println("字符串g_string第一次出现个子串 ‘11’的位置是 --> ", seqIndex)
// 字符串g_string第一次出现个子串 ‘11’的位置是 --> 7
seqIndexNot := strings.Index(g_string, "999")
fmt.Println("字符串g_string第一次出现个子串 ‘999’的位置是 --> ", seqIndexNot)
// 字符串g_string第一次出现个子串 ‘999’的位置是 --> -1
}
7.7 IndexByte()
package main
import (
"fmt"
"strings"
)
func main() {
// 查询字符串中 一个字符第一次出现的位置 没有出现 -1
// IndexByte(s,char ) int
/*
s 目标字符串
seq 子串
return int 子串出现的位置
*/
g_string := "436.3131111.116793.45632.5"
indexByte := strings.IndexByte(g_string,'9')
fmt.Println("字符 9 在字符串中第一次出现的位置 -> ",indexByte)
// 字符 9 在字符串中第一次出现的位置 -> 16
}
7.8 LastIndex()
package main
import (
"fmt"
"strings"
)
func main() {
// 子字符串 在 目标字符串最后一次出现的位置
// LastIndex(s,seq string) int
/*
s 目标字符串
seq 子串
return int 子串出现的位置
*/
g_string := "436.3131111.116793.45632.5"
lastIndex := strings.LastIndex(g_string, "11")
fmt.Println("子字符串“11” 在 g_string 最后一次出现的位置 --> ", lastIndex)
// 子字符串“11” 在 g_string 最后一次出现的位置 --> 12
}
7.9 Title()
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串中每个单词的首字母大写
// Title(s string) string
/*
s 目标字符串
retuen string 单词大写后的字符串
*/
g_string := "this is Chinawwo!"
title :=strings.Title(g_string)
fmt.Print("单词首字母大写后g_string --> ",title)
// 单词首字母大写后g_string --> This Is Chinawwo!
}
7.10 ToUpper()
package main
import (
"fmt"
"strings"
)
func main() {
// 将所有的字母都转成大写
// ToUpper(s string) string
g_string := "this Is China"
toUpper := strings.ToUpper(g_string)
fmt.Println("字符都转成大写后的字符串 ——> ",toUpper)
// 字符都转成大写后的字符串 ——> THIS IS CHINA
}
7.11 ToLower()
package main
import (
"strings"
"fmt"
)
func main(){
// 将所有的字母都转成小写
// ToLower(s string) string
g_string := "thIS Is China"
toLower := strings.ToLower(g_string)
fmt.Println("字符都转成小写后的字符串 ——> ",toLower)
// 字符都转成小写后的字符串 ——> this is china
}
7.12 Repeat()
package main
import (
"fmt"
"strings"
)
func main() {
// 重复字符串制定次数
// Repeat(s string, count int) string
g_string := "you ! "
repeatString := strings.Repeat(g_string, 5)
fmt.Println("字符串 g_string 重复 5次的结果是 --> ", repeatString)
// 字符串 g_string 重复 5次的结果是 --> you ! you ! you ! you ! you !
}
7.13 Replace()
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串的替换
// Replace(s, old, new string, n int) string
/*
s 目标字符串
old 被替换的字符串
new 替换成的字符串
n 替换次数 n<0 全部替换
*/
g_string := "This is a pig is cd is cc!"
replaceOne := strings.Replace(g_string, "is", "OO", 1)
fmt.Println("字符串被替换一次后的结果 --> ", replaceOne)
// 字符串被替换一次后的结果 --> ThOO is a pig is cd is cc!
replaceAll := strings.Replace(g_string, "is", "OO", -1)
// 也可以使用 ReplaceAll()
fmt.Println("字符串被全部替换后的结果 --> ", replaceAll)
// 字符串被全部替换后的结果 --> ThOO OO a pig OO cd OO cc!
}
7.14 Trim()
package main
import (
"fmt"
"strings"
)
func main() {
// 去除 前后的制定的字符串
// Trim(s string,cute string) string
g_string := "11111this is empty 1 1111"
trim := strings.Trim(g_string, "1")
fmt.Println("去除前后制定的字符串后 --> ", trim)
// 去除前后制定的字符串后 --> this is empty 1
// 去除字符串前后的空格
// TrimSpace(s string) string
g2_string := " do you knon 11 "
trimSpace := strings.TrimSpace(g2_string)
fmt.Println("去除前后空格后的的数据 --> ", trimSpace)
// 去除前后空格后的的数据 --> do you knon 11
// 去除左边的字符串
// TrimLeft(s string, cutset string) string
gl_string := "CCCCCCdo you knon 11CCC"
trimLeft := strings.TrimLeft(gl_string, "C")
fmt.Println("gl_string去除左边的字符串后 --> ", trimLeft)
// gl_string去除左边的字符串后 --> do you knon 11CCC
// 去除右边的字符串
// TrimLeft(s string, cutset string) string
gr_string := "CCCCCCdo you knon 11CCC"
trimRight := strings.TrimRight(gr_string, "C")
fmt.Println("gl_string去除右边的字符串后 --> ", trimRight)
// gl_string去除右边的字符串后 --> CCCCCCdo you knon 11
}
7.15 Fields()
package main
import (
"strings"
"fmt"
)
func main() {
// 返回字符串按照空白进行切割的后的切片
// Fields(s string) []string
/*
s 目标字符串
return []string 字符串的切片
*/
g_string := " GGG cc HH LL AQEWQ "
fields := strings.Fields(g_string)
fmt.Println("字符串按照1-n 个空格进行分割得到的切片是 --> ",fields)
// 字符串按照1-n 个空格进行分割得到的切片是 --> [GGG cc HH LL AQEWQ]
}
7.16 Split()
package main
import (
"fmt"
"strings"
)
func main() {
// 关于字符串切割操作
// Split(s,seq strings) []string --- 会切割所有符合结果的
/*
s 目标字符串
seq 用于切割的字符串
return []string 字符串切片
*/
gs_string := "hgjhg222kjgjh222hj222jkk2jh2jjj2"
split := strings.Split(gs_string, "2")
fmt.Println("gs_string 字符串按照 “2”切割后的数据 --> ", split)
// [hgjhg kjgjh hj jkk jh jjj ] -- 含有空格 空格也是一部分
// SplitN(s,seq string,n int) []string
/*
s 目标字符串
seq 切割的子串
n 返回切片元素个数 n = 0 返回nil n <0 尽可能的多切割
return []string 字符串的切片
*/
splitn := strings.SplitN(gs_string, "22", 3)
fmt.Println("字符串切割 2次后的数据 -->", splitn)
// 字符串切割 3次后的数据 --> [hgjhg 2kjgjh 2hj222jkk2jh2jjj2]
//
}
7.17 Join()
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串拼接 将写字符串 按照某个方式拼接
// Join(a []string, sep string) string
/*
a 要拼接字符串的 切片
seq 拼接的字符串
return string 返回一个字符串
*/
var name = []string{"111", "222", "333", "444", "555", "666"}
joinString := strings.Join(name,"===")
fmt.Println("切片拼接后的字符串 -> ",joinString)
// 切片拼接后的字符串 -> 111===222===333===444===555===666
}
8 time
…
9 math/rand
…
10 math
…
11 sort
…
12 sync
…
13 net
…
14 net/http
…
15 encoding/json
…
16 log
…
17 flag
…
18 image
…
19 path
…
20 reflect
…
21 regexp
…
782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
