go语言常用内置包

作者: 如逆水行舟不进则退 | 来源:发表于2020-09-01 18:48 被阅读0次

go语言常用内置包
Go语言内置的net/http
go语言测试框架
Go标准库flag使用
Go语言常用内置函数
Go语言标准库常用的包以及功能
go 中的slice 合并
19 Golang包以及go mod
Gox语言中下载文件-GX50.1
18.http

strings包的字符串处理函数

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func main() {
    TestContains()
    TestContainsAny()
    TestContainsRune()
    TestCount()
    TestHasPrefix()
    TestHasSuffix()
    TestIndex()
    TestIndexFunc()
    TestLastIndex()
    TestLastIndexFunc()

    res := GetFileSuffix("abc.xyz.lmn.jpg")
    fmt.Println(res)
}

// 判断是否包含子串
func TestContains()  {
  fmt.Println(strings.Contains("seafood", "foo"))
  fmt.Println(strings.Contains("seafood", "bar"))
  fmt.Println(strings.Contains("seafood", ""))
  fmt.Println(strings.Contains("", ""))
  fmt.Println(strings.Contains("steven王2008", "王"))
}

//判断字符串是否包含另一个字符串的任一字符
func TestContainsAny()  {
  fmt.Println(strings.ContainsAny("team","i"))
  fmt.Println(strings.ContainsAny("failure","u & i"))
  fmt.Println(strings.ContainsAny("foo","")) // false
  fmt.Println(strings.ContainsAny("","")) // false
}

// 判断字符串是否包含unicode码值
func TestContainsRune()  {
  fmt.Println(strings.ContainsRune("一丁", '丁'))
  fmt.Println(strings.ContainsRune("一丁", 19969))
}

// 返回字符串包含另一个字符串的个数
func TestCount()  {
  fmt.Println(strings.Count("cheese", "e"))
  fmt.Println(strings.Count("one", "")) // 4
}

// 判断字符串s 是否有前缀字符串
func TestHasPrefix()  {
  fmt.Println(strings.HasPrefix("1000phone news", "1000"))
  fmt.Println(strings.HasPrefix("1000phone news", "1000a"))
}

// 判断字符串是否有后缀字符串
func TestHasSuffix()  {
  fmt.Println(strings.HasSuffix("1000phone news", "news"))
  fmt.Println(strings.HasSuffix("1000phone news", "new"))
}


// 返回字符串中另一字符串首次出现的位置
func TestIndex()  {
  fmt.Println(strings.Index("chicken", "ken")) // 4
  fmt.Println(strings.Index("chicken", "dmr")) // -1 不存在
}

// 返回字符串中的任一unicode码值首次出现的位置
func TestIndexAndy()  {
  fmt.Println(strings.IndexAny("abcABC120", "教育基地A"))
}

// 返回字符串中字符首次出现位置
func TestIndexByte()  {
  fmt.Println(strings.IndexByte("123abc", 'a'))
}

// 判断字符串是否包含unicode码值
func TestIndexRune()  {
  fmt.Println(strings.IndexRune("abcABC120", 'C'))
  fmt.Println(strings.IndexRune("IT 培训教育", '教'))
}

// 返回字符串中满足函数 f(r) == true 字符首次出现的位置
func TestIndexFunc()  {
  f := func(c rune) bool {
    return unicode.Is(unicode.Han, c) // 是否是汉字
  }
  fmt.Println(strings.IndexFunc("Hello123, 中国", f)) // 10
}

// 返回字符串中子串最后一次出现的位置
func TestLastIndex()  {
  fmt.Println(strings.LastIndex("Steven learn english", "e"))
  fmt.Println(strings.Index("go gopher", "go"))
  fmt.Println(strings.LastIndex("go gopher", "go"))
  fmt.Println(strings.LastIndex("go gopher", "rodent")) // -1 不存在

}

// 返回字符串中任意一个unicode 码值最后一次出现的位置
func TestLastIndexAny()  {
  fmt.Println(strings.LastIndexAny("chicken", "aeiouy"))
  fmt.Println(strings.LastIndexAny("crwth", "aeiouy"))
}

// 返回字符串中字符最后一次出现的位置
func TestLastIndexByte()  {
  fmt.Println(strings.LastIndexByte("abcABCA123",'A'))
}

// 返回字符串中满足函数 f(r) == true 字符最后一次出现的位置

func TestLastIndexFunc() {
  f := func(c rune) bool {
    return unicode.Is(unicode.Han, c)
  }
  fmt.Println(strings.LastIndexFunc("Hello,世界", f))
  fmt.Println(strings.LastIndexFunc("Hello,world 中国人", f))  // 一个汉字算3个字符
}

// 获取文件后缀
func GetFileSuffix(str string) string {
  arr := strings.Split(str, ".")
  return arr[len(arr)-1]
}

分割字符串

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func main() {
  TestFields()
  TestFieldsFunc()
  TestSplit()
  TestSplitN()
  TestSplitAfter()
  TestSplitAfterN()
}
// 将字符串以空白字符分割，并返回一个切片
func TestFields()  {
  fmt.Println(strings.Fields(" abc 123 ABC xyz XYZ"))
}

// 将字符串以满足f(r) == true  的字符分割，返回一个切片
func TestFieldsFunc()  {
  f := func(c rune) bool{
    // return c == '='
    return !unicode.IsLetter(c) && !unicode.IsNumber(c)
  }
  fmt.Println(strings.FieldsFunc("abc@123*ABC&xyz%XYZ",f))
}
// 将字符串以sep 作为分隔符进行分割，分割后字符最后去掉sep
func TestSplit()  {
  fmt.Printf("%q \n", strings.Split("a,b,c","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"))

}
// 将字符串s 以sep 作为分隔符进行分割，分割后字符最后去掉sep，n决定返回的切片数
func TestSplitN()  {
  fmt.Printf("%q \n", strings.SplitN("a,b,c",",", 2))
  fmt.Printf("%q \n", strings.SplitN("a,b,c",",", 1))
}
// 将字符串s 以sep作为分隔符进行分割，分割后字符最后附上sep todo sep的解释： sep 是函数的形式参数，多数情况下， seq 参数用来指定字符的分隔符号。
func TestSplitAfter()  {
  fmt.Printf("%q \n", strings.SplitAfter("a,b,c",","))
}

// 将字符串s 以sep作为分隔符进行分割，分割后字符最后附上sep， n决定返回的切片数
func TestSplitAfterN()  {
  fmt.Printf("%q \n", strings.SplitAfterN("a,b,c",",", 2))
}

大小写转换

package main

import (
  "fmt"
  "strings"
)

func main() {
  // 将字符串s每个单词首字母大写返回
  fmt.Println(strings.Title("her royal highness"))
  // 将字符串s转换成大写返回
  fmt.Println(strings.ToTitle("louD noises"))
  // 将字符串s转换成小写返回
  fmt.Println(strings.ToLower("HELLO WORLD"))
  // 将字符串转换为大写返回
  fmt.Println(strings.ToUpper("hello world"))
}

修剪字符串

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func main() {
  // 将字符串s首尾包含在cutset中的任意字符去掉返回
  fmt.Println(strings.Trim("  steven wang   "," "))
  // 将字符串s首尾满足函数 f(r) == true 的字符去掉返回
  f := func(c rune) bool {
    return !unicode.IsLetter(c) && !unicode.IsNumber(c)
  }
  fmt.Println(strings.TrimFunc("! @#%steven wang %$#@", f))

  // 将字符串s左边包含在cutset中的任意字符去掉返回
  fmt.Println(strings.TrimLeft("  steven wang   "," "))

  // 将字符串s左边满足函数 f(r) == true 的字符去掉返回
  fmt.Println(strings.TrimLeftFunc("! @#%steven wang %$#@", f))

  // 将字符串s右边包含在cutset中的任意字符去掉返回
  fmt.Println(strings.TrimRight("  steven wang   "," "))

  // 将字符串s右边满足函数 f(r) == true 的字符去掉返回
  fmt.Println(strings.TrimRightFunc("! @#%steven wang %$#@", f))

  // 将字符串s首尾空白去掉返回
  fmt.Println(strings.TrimSpace("\t\n a long gopher \n \t\r\n"))
  // 将字符串s中前缀字符串prefix去掉返回
  s1 := "Goodbye world"
  s1 = strings.TrimPrefix(s1, "Goodbye")
  fmt.Println(s1)
  // 将字符串s中后缀字符串suffix去掉返回
  s2 := "Goodbye world 1abc"
  s2 = strings.TrimSuffix(s2, "abc")
  fmt.Println(s2)
}

比较字符串

package main

import (
  "fmt"
  "strings"
)

func main() {
  // 按字典顺序比较 a 和 b 字符串大小
  fmt.Println(strings.Compare("abc", "bbc"))
  fmt.Println("abc" < "bcd")
  // 判断s 和 t 两个UTF-8 字符串是否相等，忽略大小写
  fmt.Println(strings.EqualFold("Go", "go"))
  // 将字符串s 重复count 次返回
  fmt.Println("g" + strings.Repeat("o",8) + "le")
  // 替换字符串s 中 old 字符串为new字符串并返回，n<0 时，替换所有old 字符串
  fmt.Println(strings.Replace("王老大 王老二 王老三", "王", "李", 2))
  fmt.Println(strings.Replace("王老大 王老二 王老三", "王", "李", -1))
  // 将a中的所有字符串连接成一个字符串，使用字符串sep 作为分隔符
  s := []string{"abc","ABC","123"}
  fmt.Println(strings.Join(s, ","))
  fmt.Println(strings.Join(s, ""))
}

strconv 包的常用函数
Parse 函数:Parse 类函数主要的功能是将字符串转换为其他类型

package main

import (
  "fmt"
  "strconv"
)

func main() {
// 将字符串类型转换为int类型
a, _ := strconv.Atoi("100")
fmt.Printf("%T, %v \n", a, a+2)
fmt.Println("-------------")
// 解释给定基数(2-36)的字符串 s 并返回相应的值 i
num , _:= strconv.ParseInt("-4e00", 16, 64)//int64, -19968
fmt.Printf("%T, %v \n", num, num)
num , _= strconv.ParseInt("01100001", 2, 64) // int64,97
fmt.Printf("%T, %v \n", num, num)
num , _= strconv.ParseInt("-01100001", 10, 64) //int64, -1100001
fmt.Printf("%T, %v \n", num, num)
num , _= strconv.ParseInt("4e00", 10, 64) // int64, 0
fmt.Printf("%T, %v \n", num, num)
fmt.Println("-------------")

// ParseUint 类似 ParseInt,但是用于无符号数字,带负号则直接是0
num1 , _:= strconv.ParseUint("4e00", 16, 64)//int64, 19968
fmt.Printf("%T, %v \n", num1, num1)
num1 , _= strconv.ParseUint("01100001", 2, 64) // int64,97
fmt.Printf("%T, %v \n", num1, num1)
num1 , _= strconv.ParseUint("-1100001", 10, 64) //int64, 0
fmt.Printf("%T, %v \n", num1, num1)
num1 , _= strconv.ParseUint("4e00", 10, 64) // int64, 0
fmt.Printf("%T, %v \n", num1, num1)
fmt.Println("-------------")

// ParseFloat 将字符串s 转换为float类型
pi := "3.1415926"
num2 , _ := strconv.ParseFloat(pi, 64) // float64, 3.1415926
fmt.Printf("%T, %v \n", num2, num2)
fmt.Println("-------------")

// 将字符串转换为bool类型
flag, _ := strconv.ParseBool("steven")
fmt.Printf("%T, %v \n", flag, flag) // bool, false
fmt.Println("-------------")

}

Format类函数(Format类函数主要的功能是将其他类型格式化成字符串)

package main

import (
  "fmt"
  "strconv"
)

func main() {
  // int 转换成 string
  s := strconv.Itoa(199)
  fmt.Printf("%T, %v, 长度： %d \n", s, s, len(s))
  fmt.Println("---------")

  // 返回给定基数的i的字符串表示
  s1 := strconv.FormatInt(-19968, 16)
  fmt.Printf("%T, %v, 长度： %d \n", s1, s1, len(s1))
  s1 = strconv.FormatInt(-40869,16)
  fmt.Printf("%T, %v, 长度： %d \n", s1, s1, len(s1))
  fmt.Println("---------")
  // 返回给定基数的i的字符串表示
  s2 := strconv.FormatUint(19968, 16)
  fmt.Printf("%T, %v, 长度： %d \n", s2, s2, len(s2))
  s2 = strconv.FormatUint(40869,16)
  fmt.Printf("%T, %v, 长度： %d \n", s2, s2, len(s2))
  fmt.Println("---------")
  // 将浮点数f转换为字符串
  s3 := strconv.FormatFloat(3.1415926, 'g', -1, 64) // 3.1415926
  fmt.Printf("%T, %v, 长度： %d \n", s3, s3, len(s3))
  fmt.Println("---------")

  // bool 转换成 string
  s4 := strconv.FormatBool(true)
  fmt.Printf("%T, %v, 长度： %d \n", s4, s4, len(s4))

}

time 包
使用Format()方法格式化时间时，示例的时间点必须为2006年1月2日15时4分5秒，这是Go语言诞生的时间点。

package main

import (
  "fmt"
  "time"
)

func main() {
  time1 := time.Now()
  time.Sleep(time.Second)
  time2 := time.Now()
  // 返回1个时间段 time2 - time1
  fmt.Println(time2.Sub(time1).Seconds())
  fmt.Println("-----------")
  t := time.Now()
  fmt.Println("1. ", t)
  fmt.Println("2. ", t.Local())
  fmt.Println("3. ", t.UTC())
  fmt.Println("-----------")
  t = time.Date(2018,time.January,1,1,1,1,0,time.Local)
  fmt.Printf("4. 本地时间%s, 国际统一时间： %s \n", t, t.UTC())
  t, _ = time.Parse("2006-01-02 15:04:05", "2018-07-19 05:47:13")
  fmt.Println("5. ", t)
  fmt.Println("-----------")
  fmt.Println("6. ", time.Now().Format("2006-01-02 15:04:05"))
  fmt.Println("7. ", time.Now().String())
  fmt.Println("8. ", time.Now().Unix())
  fmt.Println("9. ", time.Now().UnixNano())
  fmt.Println("10. ", t.Equal(time.Now()))
  fmt.Println("11. ", t.Before(time.Now()))
  fmt.Println("12. ", t.After(time.Now()))
  fmt.Println("-----------")
  year , month, day := time.Now().Date()
  fmt.Println("13. ", year, month, day)
  fmt.Println("14. ", time.Now().Year())
  fmt.Println("15. ", time.Now().Month())
  fmt.Println("16. ", time.Now().Day())
  fmt.Println("17. ", time.Now().Weekday())
  fmt.Println("-----------")
  hour, minute, second := time.Now().Clock()
  fmt.Println("18. ", hour, minute, second)
  fmt.Println("19. ", time.Now().Hour())
  fmt.Println("20. ", time.Now().Minute())
  fmt.Println("21. ", time.Now().Second())
  fmt.Println("22. ", time.Now().Nanosecond())
  fmt.Println("-----------")
  fmt.Println("23. ", time.Now().Sub(time.Now()))
  fmt.Println("24. ", time.Now().Sub(time.Now()).Hours())
  fmt.Println("25. ", time.Now().Sub(time.Now()).Minutes())
  fmt.Println("26. ", time.Now().Sub(time.Now()).Seconds())
  fmt.Println("27. ", time.Now().Sub(time.Now()).Nanoseconds())
  fmt.Println("28. ", "时间间距：", t.Sub(time.Now()).String())
  fmt.Println("-----------")
  d, _ := time.ParseDuration("1h30m")
  fmt.Println("29. ", d)
  fmt.Println("30 ", "交卷时间：", time.Now().Add(d))
  fmt.Println("31. ", "一年一个月零一天之后的日期：",time.Now().AddDate(1,1,1))

}

math 包

package main

import (
  "fmt"
  "math"
)

func main() {
  fmt.Println(math.IsNaN(3.4))
  fmt.Println(math.Ceil(1.00001))
  fmt.Println(math.Floor(1.999))
  fmt.Println(math.Trunc(1.999))
  fmt.Println(math.Abs(-1.3))
  fmt.Println(math.Max(-1.3,0))
  fmt.Println(math.Min(-1.3,0))
  fmt.Println(math.Dim(-12,-19))
  fmt.Println(math.Dim(-12,19))
  fmt.Println(math.Mod(9,4))
  fmt.Println(math.Sqrt(9))
  fmt.Println(math.Cbrt(8))
  fmt.Println(math.Hypot(3,4))
  fmt.Println(math.Pow(2,8))
  fmt.Println(math.Log(1))
  fmt.Println(math.Log2(16))
  fmt.Println(math.Log10(1000))
}

随机数 math/rand 包:
“math/rand”包实现了伪随机数生成器，能够生成整型和浮点型的随机数。使用随机数生成器需要放入种子。可以使用Seed()函数生成一个不确定的种子放入随机数生成器，这样每次运行随机数生成器都会生成不同的序列。如果没有在随机数生成器中放入种子，则默认使用具有确定性状态的种子，此时可以理解为种子的值是一个常数1，即Seed(1)。

package main

import (
  "fmt"
  "math/rand"
  "time"
)

func main() {
  // 1.生成随机数
  // 这样总是生成固定的随机数
  fmt.Println(rand.Int())
  fmt.Println(rand.Intn(10))
  fmt.Println(rand.Float64())
  fmt.Println("------------")
  // 动态随机数种子生成随机资源，产生随机对象来获取随机数
  s1 := rand.NewSource(time.Now().UnixNano())
  r1 := rand.New(s1)
  randNum := r1.Intn(10)
  fmt.Println(randNum)
  fmt.Println("------------")
  // 简写形式：动态变化随机数种子来获取随机数
  rand.Seed(time.Now().UnixNano())
  fmt.Println(rand.Intn(10))
  fmt.Println(rand.Float64())
  // 返回一个取值范围在[0,n)的伪随机int值，如果n<=0会panic
  fmt.Println(rand.Intn(20-10+1) + 10)

  fmt.Println("------------")

  // 2.随机获取应答
  answers := []string{
    "hello",
    "hi",
    "ha ha ha",
    "good morning",
    "really",
  }
  rand.Seed(time.Now().UnixNano())
  randnum := rand.Intn(len(answers))
  fmt.Println("随机回答", answers[randnum])

}

键盘输入
Scanln()函数

package main

import "fmt"

func main() {
  username := ""
  age := 0
  fmt.Scanln(&username,&age)
  fmt.Println("账号信息为：", username, age)
}

猜数字游戏

package main

import (
  "fmt"
  "math/rand"
  "time"
)

func main() {
  // 猜数字游戏
  playGame()

}

func playGame()  {
  // 获取随机数
  target := generateRandNum(10, 100)
  fmt.Println("请输入随机数：")
  fmt.Println("-------------")
  // 记录猜测的次数
  count := 0
  for {
    count ++
    yourNum := 0
    fmt.Scanln(&yourNum)
    if yourNum < target {
      fmt.Println("小了 X")
    } else if yourNum > target {
      fmt.Println("大了 X")
    } else {
      fmt.Println("正确 √")
      fmt.Printf("您一共猜测了 %d 次 \n", count)
      fmt.Println("--------------")
      playGame()
    }
    // 错误提示
    alertInfo(count,target)
  }
}
// 错误提示
func alertInfo(count,target int)  {
  if count >= 6 {
    fmt.Printf("您一共猜了 %d 次都没有猜中", count)
    fmt.Println("正确数字：", target)
    fmt.Println("----------")
    playGame()
  }
}

// 生成随机数
func generateRandNum(min, max int) int  {
  rand.Seed(time.Now().UnixNano())
  return rand.Intn(max-min+1) + min
}