GO语言学习笔记2——常用包使用

包的使用实际上在官网有详细的文档，但是首先要熟悉一下GO有哪些常用的包，也避免偶尔绕路。

包

golang官网有150标准包，几乎覆盖所有基本库
github 包
- 安装github包： go get github.com/xxxx/xxxx

strings和strconv使用

strings.HasPrefix(s string, prefix) bool
- 判断字符串是否以prefix开头
- 例如判断url是否以http://开头，如果不是则加上
strings.HasSuffix(s string, suffix string)bool
- 判断字符串s是否以suffix结尾
- 例如判断一个路径是否以“/”结尾，如果不是，则加上/
strings.Index(s string, str string) int
- 判断str在s中首次出现的位置，如果没有出现，则返回-1
strings.LastIndex(s string, str string) int
- 判断str在s中最后出现的位置，如果没有出现，则返回-1
strings.Replace(str string, old string, new string, n int)
- 字符串替换
strings.Count(str string, substr string) int
- 字符串计数
strings.Repeat(str string, count int) string
- 重复count次str
strings.ToLower(str string)string
- 转为小写
strings.ToUpper(str string) string
- 转为大写
strings.TrimSpace(str string)
去掉首位空白字符
strings.Trim(str string, cut string)
去掉首位cut字符
strings.TrimLeft(str string, cut string)
去掉字符串首cut字符
strings.TrimRight(str string, cut string)
去掉字符串尾cut字符
strings.Field(str string)
返回str空格分隔的所有子串的slice
strings.Split(str string, split string)
- 返回以split str分隔的所有子串的slice
strings.Join(s1 []string, sep string)
- 用sep把s1中所有的元素链接起来
strconv.Itoa(i int)
- 把一个整数i转成字符串
strconv.Atoi(str string)(int, error)
- 把一个字符串转成整数

Time使用

time包
time.Time类型，用来表示时间
获取当前时间
now:=time.Now()

单位大小

const(
	Nanosecond Duration = 1
	Microsecond = 1000 * Nanosecond
	Millisecond = 1000 * Microsecond
	Second = 1000 * Millsecond
	Minute = 60 * second
	Hour = 60 * Minute
)

1	start := time.Now().UnixNano() //生成纳秒时间

格式化时间

now := time.Now()
fmt.Println(now.Format("2006/1/02 15:04"))
fmt.Println(now.Format("02/1/2006 15:04"))
fmt.Println(now.Format("2006/1/02"))

小练习

终端输入两个超过int64的大数相加，将结果打印出来。
- 字符串数字模拟相加
- 自己实现一遍再看答案

答案

package main
import (
	"bufio"
	"fmt"
	"os"
	"strings"
)
func StrNumAdd(str1, str2 string) string {
	index1 := len(str1) - 1
	index2 := len(str2) - 1
	left := 0
	res := ""
	for index1 >= 0 && index2 >= 0 {
		a := str1[index1] - '0'
		b := str2[index2] - '0'
		sum := int(a) + int(b) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		ch := sum%10 + '0'
		res = fmt.Sprintf("%c%s", ch, res)
		index1 -= 1
		index2 -= 1
	}
	for index1 >= 0 {
		a := str1[index1] - '0'
		sum := int(a) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		ch := sum%10 + '0'
		res = fmt.Sprintf("%c%s", ch, res)
		index1 -= 1
	}
	for index2 >= 0 {
		b := str2[index2] - '0'
		sum := int(b) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		ch := sum%10 + '0'
		res = fmt.Sprintf("%c%s", ch, res)
		index2 -= 1
	}
	if left == 1 {
		res = fmt.Sprintf("1%s", res)
	}
	return res
}
func main() {
	reader := bufio.NewReader(os.Stdin)
	result, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("read err", err)
		return
	}
	strSlice := strings.Split(string(result), "+")
	if len(strSlice) != 2 {
		fmt.Println("please input a+b")
		return
	}
	strNumber1 := strings.TrimSpace(strSlice[0])
	strNumber2 := strings.TrimSpace(strSlice[1])
	sum := StrNumAdd(strNumber1, strNumber2)
	fmt.Println("res:", sum)
}

线程同步

import(“sync”)

锁

并行读没有问题，但并行写，就会出现写冲突，此时需要加锁
互斥锁
- var mu sync.Mutex
读写锁
- var mu sync.RWMutex
编译时加上-race 可以坚持出可能的竞争关系
- 如果有数据并行写竞争，加了-race 编译过的，运行时会报错
- -race选项会把读竞争也算作竞争
互斥锁使用：

var lock sync.Mutex
lock.Lock()
xxxx
lock.Unlock()

读写锁

读多写少时使用

var rwLock sync.RWMutex
rwLock.Lock()
//写操作
rwLock.Unlock()
rwLock.Rlock()
//读操作
rwLock.RUnlock()

原子操作

1	import "sync/atomic"

写
- atomic.AddInt32(&count,1)
读
- fmt.println(atomic.loadInt32(&account))