Go标准包(七):context(上下文)

2021-04-07

编程 Go

3027 words 7 mins read

1.什么是上下文?

从Go 1.7开始,标准库引入context(上下文)，他主要用来在goroutine之间传递上下文信息(同步信号、超时时间、截止时间、Key-Val值对)。

Go标准包(六):bufio(有缓冲的IO)

2021-04-06

编程 Go

2935 words 6 mins read

1.介绍

bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，使用这个包可以大幅提高文件读写的效率。

1.如何提高效率?

1.写入流程梳理:

Go标准包(五):ioutil(IO操作函数集)

2021-04-05

编程 Go

1423 words 3 mins read

1.介绍

在Go语言中，io包主要声明的是对I/O操作的基本接口，而io/ioutil包则实现了对应的方法，方便我们直接使用。

2.方法列表

方法名	描述
`NopCloser`	对`Reader`进行封装，返回一个`ReadCloser`
`ReadAll`	对 `Reader` 进行读取，直到发生错误或者遇到 `EOF` 为止，然后返回被读取的数据。
`ReadFile`	读取指定文件的内容，并返回。
`ReadDir`	读取指定的目录，并返回排序后的目录列表(根据名称排序)
`TempDir`	在指定目录新创建一个临时目录，并返回该目录的路径
`TempFile`	在指定目录新创建一个临时文件，以可读写的方式打开它，并返回 `*os.File` 指针
`WriteFile`	将给定的数据写入到指定文件里面。如果文件不存在，则去创建它；如果文件已经存在，则再写入之前会先清空文件中已有的内容。

3.`ReadAll`

3.1 方法签名

1

func ReadAll(r io.Reader) ([]byte, error)

ReadAll从r读取数据直到EOF或error，返回读取内容([]byte)和错误(error)。读取成功时err返回nil。因为本函数定义为读取r直到EOF，它不会将读取返回的EOF视为应报告的错误。

Go标准包(四):fmt(格式化输出)

2021-04-04

编程 Go

2539 words 6 mins read

1.输出控制台

1.1 `Printf`

Printf根据format参数生成格式化的字符串并写入标准输出。返回写入的字节数和遇到的任何错误。

1.`format`格式

动词	功能
`%v`	按值的本来值输出
`%+v`	在 %v 基础上，对结构体字段名和值进行展开
`%#v`	输出 Go 语言语法格式的值
`%T`	输出 Go 语言语法格式的类型和值
`%%`	输出 % 本体
`%b`	整型以二进制方式显示
`%o`	整型以八进制方式显示
`%d`	整型以十进制方式显示
`%x`	整型以十六进制方式显示
`%X`	整型以十六进制、字母大写方式显示
`%U`	Unicode 字符
`%f`	浮点数
`%p`	指针，十六进制方式显示
`%c`	数值对应的 Unicode 编码字符
`%s`	直接输出字符串或者[]byte
`%t`	输出值的 true 或 false

2.打印字符串

1
2
3
4
5
6
7


str := "hello word"
fmt.Printf("%%s-> %s \n",str)
fmt.Printf("%%v-> %v \n",str)
/**输出
%s-> hello word 
%v-> hello word 
*/

3.打印布尔类型

1

fmt.Printf("%%t-> %t \n", b)

4.打印浮点型

格式	描述
`%f`	默认宽度，默认精度
`%9f`	宽度9，默认精度
`%.2f`	默认宽度，精度2
`%9.2f`	宽度9，精度2
`%9.f`	宽度9，精度0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


f := 1.234567890
fmt.Printf("默认宽度，默认精度:%f \n", f)
fmt.Printf("宽度9，默认精度:%9f \n", f)
fmt.Printf("默认宽度，精度2:%.2f \n", f)
fmt.Printf("宽度9，精度2:%9.2f \n", f)
fmt.Printf("宽度9，精度0 :%9.f \n", f)
/**输出
默认宽度，默认精度:1.234568 
宽度9，默认精度: 1.234568 
默认宽度，精度2:1.23 
宽度9，精度2:     1.23 
宽度9，精度0 :        1 
*/

5.打印整数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 定义一个整数变量
a := 54321
fmt.Printf("十进制:%d\n",a)
fmt.Printf("二进制:%b\n",a)
fmt.Printf("八进制:%o\n",a)
fmt.Printf("十六进制:%x\n",a)
fmt.Printf("十六进制,字母大写:%X\n",a)
/**输出
十进制:54321
二进制:1101010000110001
八进制:152061
十六进制:d431
十六进制,字母大写:D431
*/

6.打印指针

1
2
3


str := "hello"
fmt.Printf("打印指针:%p\n", &str)
//输出: 打印指针:0xc000098d50

7.打印变量类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 数组
arr := []int{1, 2, 3, 4, 5, 6}
fmt.Printf("arr类型: %T\n", arr)
// 映射
map1 := map[string]int{
	"张三": 20,
	"李四": 23,
}
fmt.Printf("map1类型: %T\n", map1)
// 匿名结构体
fruit := struct {
	name  string
	price float64
}{"香蕉", 4.99}
fmt.Printf("fruit类型: %T\n", fruit)
/**输出
arr类型: []int
map1类型: map[string]int
fruit类型: struct { name string; price float64 }
*/

8.打印结构体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 定义一个匿名结构体
people := struct {
	name, home, school string
}{"张三", "北京", "北京大学"}
fmt.Printf("%v\n", people)
fmt.Printf("%+v\n", people)
fmt.Printf("%#v\n", people)
/**输出
{张三 北京 北京大学}
{name:张三 home:北京 school:北京大学}
struct { name string; home string; school string }{name:"张三", home:"北京", school:"北京大学"}
*/

9.打印`Unicode`

1
2
3
4
5
6


fmt.Printf("%U\n", 'A')
fmt.Printf("%c\n", 65)
/**输出
U+0041
A
*/

1.2 `Print`

Print: 采用默认格式将其参数格式化并写入标准输出。如果两个相邻的参数都不是字符串，会在它们的输出之间添加空格。

Go标准包(三):time(时间包)

2021-04-03

编程 Go

2477 words 5 mins read

1.获取时间

1.1 当前时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


unix := time.Now().Unix()
fmt.Printf("当前时间戳(单位秒): %v \n",unix)
nano := time.Now().UnixNano()
fmt.Printf("当前时间戳(单位纳秒): %v\n",nano)
format := time.Now().Format("2006-01-02 15:04:05")
fmt.Printf("当前时间(Y-m-d H:i:s): %v\n",format)
format2 := time.Now().Format("20060102150405")
fmt.Printf("当前时间(YmdHis): %v\n",format2)
/**
当前时间戳(单位秒): 1616251448 
当前时间戳(单位纳秒): 1616251448041163000
当前时间(Y-m-d H:i:s): 2021-03-20 22:44:08
当前时间(YmdHis): 20210320224408
*/

1.2 当前年、月、日、时、分、秒、星期几

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


format := time.Now().Format("2006-01-02 15:04:05")
fmt.Printf("当前时间(Y-m-d H:i:s): %v\n",format)
fmt.Printf("当前年: %v\n", time.Now().Year())
fmt.Printf("当前月: %v\n", time.Now().Month())
fmt.Printf("当前日: %v\n", time.Now().Day())
fmt.Printf("当前小时: %v\n", time.Now().Hour())
fmt.Printf("当前分钟: %v\n", time.Now().Minute())
fmt.Printf("当前秒: %v\n", time.Now().Second())
fmt.Printf("当前星期几: %v\n", time.Now().Weekday())
/**输出
当前时间(Y-m-d H:i:s): 2021-03-21 17:32:24
当前年: 2021
当前月: March
当前日: 21
当前小时: 17
当前分钟: 32
当前秒: 24
当前星期几: Sunday
*/

1.3 获取时分秒

1
2
3
4


now := time.Now()
hour, min, sec := now.Clock()
fmt.Printf("时间:%v   huor: %v min:%v sec:%v \n",now,hour,min,sec)
//时间:2021-03-22 23:18:43.245006 +0800 CST m=+0.000108086   huor: 23 min:18 sec:43

1.4 创建指定时间

1
2
3


date := time.Date(2020,8,23,13,53,32,0,time.Local)
fmt.Printf("类型: %T , %v ",date,date)
// 输出:类型: time.Time , 2020-08-23 13:53:32 +0800 CST 

1.5 获取所属第几周

1
2
3
4


// 获取当前时间是，今年的第几周
week, w := time.Now().ISOWeek()
fmt.Printf("year: %v w:%v \n",week,w)
// year: 2021 w:12 

1.6 获取x年的第几天

1
2
3


num := time.Now().YearDay()
fmt.Printf("今天是今年的第 %v 天 \n",num)
// 今天是今年的第 81 天 

2.字符串转时间

2.1 字符串转时间类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


str := "1616319808"
unix, _ := strconv.ParseInt(str,10,64)
format := time.Unix(unix, 0)
fmt.Printf("字符串时间戳-> 类型:%T 值:%v \n",format,format)
// 字符串时间,
strDate := "2019-04-10 12:54:03"
// 注意layout格式需要和字符串时间格式一致
location, _ := time.Parse("2006-01-02 15:04:05", strDate)
fmt.Printf("字符串时间-> 类型:%T 值:%v \n",location,location)
/**
字符串时间戳-> 类型:time.Time 值:2021-03-21 17:43:28 +0800 CST 
字符串时间-> 类型:time.Time 值:2019-04-10 12:54:03 +0000 UTC 
*/

2.2 格式化时间

Format根据layout指定的格式返回t代表的时间点的格式化文本表示；Format中内置了几个固定的layout常量。

Go标准包(二):strconv(字符串转换)

2021-04-02

编程 Go

2835 words 6 mins read

1.转换成其他类型（Parse类函数）

1.1 转换成整型(Atoi)

1.语法

1

func Atoi(s string) (int, error)

2.使用示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main
import (
	"fmt"
	"strconv"
)
func main() {
	// 将字符串转成整型
	s := "666"
	sInt,err := strconv.Atoi(s)
	if err == nil {
		fmt.Printf("将字符串:%s 转成整型:%d 类型: %T \n",s,sInt,sInt)
	}
}
//将字符串:666 转成整型:666 类型: int

1.2 解析成整型(ParseInt)

1.语法

1

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base:表示进制(2到36)。如果base=0,则根据字符串前缀判断,0x:表示十六进制、0:表示八进制、其他代表十进制。

Go标准包(一):strings(字符串操作)

2021-04-01

编程 Go

8397 words 17 mins read

1.字符串查找

strings是Go内置的标准包,主要用于字符串查找、替换、比较等。常用方法如下:

1.1 方法列表

方法名	描述
`Count(s, substr string)int`	返回字符串s包含字符串substr的个数
`Contains(s, substr string)bool`	判断字符串s是否包含substr字符串
`ContainsAny(s, chars string)bool`	判断字符串s是否包含chars字符串中的任意一个字符
`ContainsRune(s string, r rune)bool`	判断字符串s是否包含unicode的码值r
`LastIndex(s, substr string)int`	返回字符串s中字符串substr最后一次出现的位置
`Index(s, substr string)int`	返回字符串s中字符串substr首次出现的位置
`IndexByte(s string, c byte)int`	返回字符串s中字符c首次出现的位置
`IndexRune(s string, r rune)int`	返回unicode的码值r在字符串s中首次出现的位置
`IndexAny(s, chars string)int`	返回字符串chars中的任意一个字符unicode码值, 在s中首次出现的位置
`LastIndexAny(s, chars string)int`	返回字符串chars中的任意一个字符unicode码值, 在s中最后一次出现的位置
`LastIndexByte(s string, c byte)int`	返回字符串s中字符c最后一次出现的位置
`HasPrefix(s, prefix string)bool`	判断字符串s是否有前缀prefix
`HasSuffix(s, suffix string)bool`	判断字符串s是否有后缀suffix
`IndexFunc(s string, f func(r)bool)int`	返回字符串s中满足函数f(r)==true, 字符首次出现的位置
`LastIndexFunc(s string, f func(r)bool)int`	返回字符串s中满足函数f(r)==true , 字符最后一次出现的位置

1.2 使用示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76


package main

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

func main() {
	// 返回字符串s包含字符串substr的个数
	s := "hello word"
	fmt.Printf("字符串:%s,o出现数量: %d\n",s,strings.Count(s,"o"))
	// 判断字符串s是否包含substr字符串
	fmt.Printf("字符串:%s 是否包含%s ? %t \n",s,"word",strings.Contains(s,"word"))
	fmt.Printf("字符串:%s 是否包含%s ? %t \n",s,"go",strings.Contains(s,"go"))
	// 判断字符串s是否包含chars字符串中的任意一个字符
	fmt.Printf("字符串:%s 是否包含%s中的任意一个字符 ? %t \n",s,"go",strings.ContainsAny(s,"go"))
	fmt.Printf("字符串:%s 是否包含%s中的任意一个字符 ? %t \n",s,"gg",strings.ContainsAny(s,"gg"))
	// 判断字符串s是否包含unicode的码值r
	r := 'w'
	fmt.Printf("字符串:%s 是否包含unicode的码值%c? %t \n",s,r,strings.ContainsRune(s,r))
	fmt.Printf("字符串:%s 是否包含unicode的码值%d? %t \n",s,119,strings.ContainsRune(s,119))
	// 返回字符串s中字符串substr最后一次出现的位置
	fmt.Printf("在字符串%s中,字符串%s最后一次出现的位置? %d \n",s,"o",strings.LastIndex(s,"o"))
	// 返回字符串s中字符串substr首次出现的位置
	fmt.Printf("在字符串%s中,字符串%s首次出现的位置? %d \n",s,"o",strings.Index(s,"o"))
	// 返回字符串s中字符c首次出现的位置
	var b byte = 'l'
	fmt.Printf("在字符串%s中,字符%c首次出现的位置? %d \n",s,b,strings.IndexByte(s,b))
	// 返回字符串s中字符c最后一次出现的位置
	fmt.Printf("在字符串%s中,字符%c最后一次出现的位置? %d \n",s,b,strings.LastIndexByte(s,b))

	// 返回unicode的码值r在字符串s中首次出现的位置
	fmt.Printf("在字符串%s中,unicode的码值%d(%c)首次出现的位置? %d \n",s,104,104,strings.IndexRune(s,104))
	// 返回字符串chars中的任意一个字符unicode码值,在s中首次出现的位置
	s3 := "rd"
	fmt.Printf("返回字符串%s中的任意一个字符unicode码值(%s)首次出现的位置? %d \n",s,s3,strings.LastIndexAny(s,s3))

	// 判断字符串s是否有前缀prefix
	a := "VIP001"
	fmt.Printf("字符串:%s 是否有前缀%s ? %t \n",a,"vip",strings.HasPrefix(a,"vip"))
	fmt.Printf("字符串:%s 是否有前缀%s ? %t \n",a,"VIP",strings.HasPrefix(a,"VIP"))

	// 判断字符串s是否有后缀suffix
	sn := "K011_Mn"
	fmt.Printf("字符串:%s 是否有后缀%s ? %t \n",sn,"MN",strings.HasSuffix(sn,"MN"))
	fmt.Printf("字符串:%s 是否有后缀%s ? %t \n",sn,"Mn",strings.HasSuffix(sn,"Mn"))
	// 返回字符串s中满足函数f(r)==true,字符首次出现的位置 (判断第一个汉字的位置)
	f := func(c rune) bool {
		return unicode.Is(unicode.Han,c)
	}
	s4 := "go!中国人"
	fmt.Printf("字符串:%s 首次出现汉字的位置%d \n",s4,strings.IndexFunc(s4,f))
	fmt.Printf("字符串:%s 最后一次出现汉字的位置%d \n",s4,strings.LastIndexFunc(s4,f))
}
/** 输出
  字符串:hello word,o出现数量: 2
  字符串:hello word 是否包含word ? true 
  字符串:hello word 是否包含go ? false 
  字符串:hello word 是否包含go中的任意一个字符 ? true 
  字符串:hello word 是否包含gg中的任意一个字符 ? false 
  字符串:hello word 是否包含unicode的码值w? true 
  字符串:hello word 是否包含unicode的码值119? true 
  在字符串hello word中,字符串o最后一次出现的位置? 7 
  在字符串hello word中,字符串o首次出现的位置? 4 
  在字符串hello word中,字符l首次出现的位置? 2 
  在字符串hello word中,字符l最后一次出现的位置? 3 
  在字符串hello word中,unicode的码值104(h)首次出现的位置? 0 
  返回字符串hello word中的任意一个字符unicode码值(rd)首次出现的位置? 9 
  字符串:VIP001 是否有前缀vip ? false 
  字符串:VIP001 是否有前缀VIP ? true 
  字符串:K011_Mn 是否有后缀MN ? false 
  字符串:K011_Mn 是否有后缀Mn ? true 
  字符串:go!中国人 首次出现汉字的位置3 
  字符串:go!中国人 最后一次出现汉字的位置9 
*/

2. 字符串分割

2.1 方法列表

方法名	描述
`Fields(s string)[]string`	将字符串s以空白字符分割，返回切片
`FieldsFunc(s string, f func(r) bool)[]string`	将字符串s以满足`f(r)==true`的字符分割，分割后返回切片
`Split(s,sep string)[]string`	将字符串s以sep作为分割符进行分割，分割后字符最后去掉sep,返回切片
`SplitAfter(s,sep string)[]string`	将字符串s以sep作为分割符进行分割，分割后字符最后加上sep,返回切片
`SplitAfterN(s,sep string, n int)[]string`	将字符串s以sep作为分割符进行分割，分割后字符最后加上sep,n决定分割成切片长度
`SplitN(s,sep string, n int)[]string`	将字符串s以sep作为分割符进行分割，分割后字符最后去掉sep,n决定分割成切片长度

2.2 使用示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


package main
import (
	"fmt"
	"strings"
	"unicode"
)
func main() {
	s := "Go! Go! 中国人!"
	// 将字符串s以空白字符分割，返回切片
	slice := strings.Fields(s)
	fmt.Printf("将字符串:【%s】以空白字符分割，返回切片:%v \n",s,slice)
	// 将字符串s以满足f(r)==true的字符分割，分割后返回切片。
	// 以特殊符号分割
    f := func(r rune) bool{
    	// 不是字母，也不是数字
    	return !unicode.IsLetter(r) && !unicode.IsNumber(r)
	}
	ss := "张三@19*BeiJing&高中生|男(打球"
	slice2 := strings.FieldsFunc(ss,f)
	fmt.Printf("将字符串:【%s】 以满足f(r)==true【不是数字和字母都是分隔符】的字符分割，返回切片:%v \n",ss,slice2)

	// 将字符串s以sep作为分割符进行分割，分割后字符最后去掉sep
	s2 := "@123@张@AB@001"
	sep1 := "@"
	slic1 := strings.Split(s2,sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，分割后最后去掉:%s 返回切片: %v 切片长度: %d \n",s2,sep1,sep1,slic1,len(slic1))

	// 将字符串s以sep作为分割符进行分割，分割后字符最后加上sep,返回切片
	slic2 := strings.SplitAfter(s2,sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，分割后最后加上:%s 返回切片: %v 切片长度: %d \n",s2,sep1,sep1,slic2,len(slic2))
	// 将字符串s以sep作为分割符进行分割，分割后字符最后加上sep,n决定分割成切片长度
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后加上%s \n",s2,sep1,0,strings.SplitAfterN(s2,sep1,0),sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后加上%s \n",s2,sep1,1,strings.SplitAfterN(s2,sep1,1),sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后加上%s \n",s2,sep1,5,strings.SplitAfterN(s2,sep1,5),sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后加上%s \n",s2,sep1,6,strings.SplitAfterN(s2,sep1,6),sep1)
	// 将字符串s以sep作为分割符进行分割，分割后字符最后去掉sep,n决定分割成切片长度
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后去掉%s \n",s2,sep1,1,strings.SplitN(s2,sep1,1),sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后去掉%s \n",s2,sep1,3,strings.SplitN(s2,sep1,3),sep1)
	fmt.Printf("将字符串:【%s】以%s进行分割，指定分割切片长度%d: %v 分割后去掉%s \n",s2,sep1,5,strings.SplitN(s2,sep1,5),sep1)
}
/** 输出
将字符串:【Go! Go! 中国人!】以空白字符分割，返回切片:[Go! Go! 中国人!] 
将字符串:【张三@19*BeiJing&高中生|男(打球】 以满足f(r)==true【不是数字和字母都是分隔符】的字符分割，返回切片:[张三 19 BeiJing 高中生 男 打球] 
将字符串:【@123@张@AB@001】以@进行分割，分割后最后去掉:@ 返回切片: [ 123 张 AB 001] 切片长度: 5 
将字符串:【@123@张@AB@001】以@进行分割，分割后最后加上:@ 返回切片: [@ 123@ 张@ AB@ 001] 切片长度: 5 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度0: [] 分割后加上@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度1: [@123@张@AB@001] 分割后加上@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度5: [@ 123@ 张@ AB@ 001] 分割后加上@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度6: [@ 123@ 张@ AB@ 001] 分割后加上@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度1: [@123@张@AB@001] 分割后去掉@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度3: [ 123 张@AB@001] 分割后去掉@ 
将字符串:【@123@张@AB@001】以@进行分割，指定分割切片长度5: [ 123 张 AB 001] 分割后去掉@ 
*/

3.大小写切换

3.1 方法列表

方法名	描述
`Title(s string)string`	将字符串s每个单词首字母大写
`ToLower(s string)string`	将字符串s转换成小写返回
`ToLowerSpecial(c unicode.SpecialCase,s string)string`	将字符串s中所有字符串按c指定的映射转换成小写返回
`ToTitle(s string)string`	将字符串s转换成大写返回
`ToTitleSpecial(c unicode.SpecialCase,s string) string`	将字符串s中所有的字符按c指定的映射转换成大写返回
`ToUpper(s string)string`	将字符串s转换成大写返回
`ToUpperSpecial(c unicode.SpecialCase,s string) string`	将字符串s中所有的字符按c指定的映射转换成大写返回

3.2 使用示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main
import (
	"fmt"
	"strings"
)
func main() {

	str := "hello word"
	str1 := "HELLO WORD"
	// Title(s string) string: 每个单词首字母大写
	fmt.Printf("Title->将字符串%s 每个单词首字母大写: %s\n",str,strings.Title(str))
	// ToLower(s string) string : 将字符串s转换成小写返回
	fmt.Printf("ToLower->将字符串%s 转换成小写返回: %s\n",str1,strings.ToLower(str1))
	// ToTitle(s string)string: 将字符串s转换成大写返回
	fmt.Printf("ToTitle->将字符串%s 转换成大写返回: %s\n",str,strings.ToTitle(str))
	// ToUpper(s string)string: 将字符串s转换成大写返回
	fmt.Printf("ToUpper->将字符串%s 转换成大写返回: %s\n",str,strings.ToUpper(str))
}
/**输出
Title->将字符串hello word 每个单词首字母大写: Hello Word
ToLower->将字符串HELLO WORD 转换成小写返回: hello word
ToTitle->将字符串hello word 转换成大写返回: HELLO WORD
ToUpper->将字符串hello word 转换成大写返回: HELLO WORD
*/

3.3 ToTitle和ToUpper的区别

大部分情况下， ToUpper 与 ToTitle 返回值相同，但在处理某些unicode编码字符则不同,示例如下:

Go工具(一):gvm

2021-03-01

编程 Go

913 words 2 mins read

1. 什么是Gvm

Go 语言版本管理器（Gvm）是管理 Go 语言环境的开源工具。Gvm 「pkgsets」 支持安装多个版本的 Go 并管理每个项目的模块。它最初由 Josh Bussdieker 开发，Gvm 与 Ruby RVM 类似，允许你为每个项目或一组项目创建一个开发环境，分离不同的 Go 版本和包依赖关系，来提供更大的灵活性，以防不同版本造成的问题。Gvm 主要有以下几个特性：

Go实操(四):遍历使用

2021-02-04

编程 Go

1578 words 4 mins read

1. 遍历字符串(string)

1.1 统计长度后遍历

1
2
3
4
5
6
7
8


func ForString() {
	str := "hello word"
	//1.统计长度后遍历
	length := len(str)
	for i := 0; i < length; i++{
		fmt.Printf("字符: %c ",str[i]) 
	}
}

1.2 转为byte后遍历

1
2
3
4
5
6
7


func ForString() {
	str := "hello word"
	strByte := []byte(str)
	for _,v := range strByte{
		fmt.Printf("字符: %c ",v)
	}
}

2. 遍历数组(array)

2.1 遍历一维数组

1
2
3
4
5
6
7


func ForArray() {
	//遍历一维数组
	arr := [5]int{1, 2, 3, 4, 5}
	for _, v := range arr {
		fmt.Printf("元素: %v ", v)
	}
}

2.2 遍历二维数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func ForArray() {
	//遍历二维数组
	arr2 := [2][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}
	fmt.Println(arr2)
	for _, arr := range arr2{
		for _, v := range arr{
			fmt.Printf("v: %v ", v)
		}
	}
}

3. 遍历切片(slice)

3.1 遍历一维切片

1
2
3
4
5
6
7


func ForSlice() {
	//遍历一维切片
	slice := []string{"张三", "李四", "王五", "费六"}
	for _, v := range slice {
		fmt.Println("姓名:", v)
	}
}

3.2 遍历二维切片

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func ForSlice() {
	//遍历多维切片
	slice2 := [][]string{
		{"张三", "李四", "王五", "费六"},
		{"小花", "小兰", "小雨", "小丽"},
	}
	for _, slice := range slice2{
		// 循环嵌套
		for _,name := range slice{
			fmt.Println("姓名:", name)
		}
	}
}

4. 遍历映射（map）

4.1 遍历一维map

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


type Student struct {
	ClassName string
	Fraction  int
}
func ForMap() {
	m := map[string]Student{
		"张三": Student{"一A年级", 68},
		"李速": Student{"一B年级", 72},
		"小丽": Student{"一A年级", 65},
	}
	for name, stu := range m {
		fmt.Println("姓名:", name, "班级:", stu.ClassName, "分数:", stu.Fraction)
	}

}

4.2 遍历多维map

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


type Student struct {
	ClassName string
	Fraction  int
}

func ForMap() {
	// 遍历多维map
	m2 := map[int]map[string]Student{}
	m2[1] = map[string]Student{
		"李速": Student{"一B年级", 72},
	}
	m2[2] = map[string]Student{
		"张三": Student{"一A年级", 68},
	}
	m2[3] = map[string]Student{
		"小丽": Student{"一A年级", 65},
	}

	for sort, m := range m2 {
		for name,stu := range m {
			fmt.Println("排名:",sort,"姓名:", name, "班级:", stu.ClassName, "分数:", stu.Fraction)
		}
	}
}

5.遍历结构（struct）

5.1 常结构遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


type People struct {
	Name string
	Age int
	Sex string
}

func ForStruct()  {
	boy := People{"李四", 20, "男"}
	v := reflect.ValueOf(boy)
	t := reflect.TypeOf(boy)
	for i := 0; i < t.NumField() ; i++  {
		fmt.Println("字段名:",t.Field(i).Name,"字段值:",v.Field(i).Interface())
	}
}
/**
输出:
*/

5.2 嵌套结构遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


type People struct {
	Name string
	Age  int
	Sex  string
}

type Girl struct {
	Like string
	People
}

func ForStruct() {
	//嵌套结构体
	g := Girl{"唱歌", People{"小花", 18, "女"}}
	gv := reflect.ValueOf(g)
	gt := reflect.TypeOf(g)
	for i := 0; i < gv.NumField(); i++ {
		//判断是否是结构体
		if gv.Field(i).Type().Kind() == reflect.Struct {
			structFiled := gv.Field(i).Type()
			for j := 0; j < structFiled.NumField(); j++ {
				fmt.Println("嵌套结构==>", "字段名:", structFiled.Field(i).Name, "字段值:", gv.Field(i).Field(j).Interface())
			}
			continue
		}
		fmt.Println("外层结构==>", "字段名:", gt.Field(i).Name, "字段值:", gv.Field(i).Interface())
	}
}

Go实操(三):Map使用

2021-02-03

编程 Go

114 words 1 min read

1.创建

1

countryMap = make(map[string]string)

2.插入

1
2


/* map 插入 key-value  */
countryMap["ShengRI"] = "1988-04-09"

3.取值

1
2
3
4


/* 使用 key 输出 map 值 */
for country := range countryMap {
fmt.Println("Capital of",country,"is",countryMap[country])
}

4.key是否存在

1
2
3
4
5
6
7
8


/* 查看元素在集合中是否存在 */
captial, ok := countryMap["ShengRI"]
/* 如果 ok 是 true, 则存在，否则不存在 */
if(ok){
   fmt.Println("Capital of United States is", captial)
} else {
   fmt.Println("is not ok")
}

1.什么是上下文?

1.介绍

1.如何提高效率?

1.介绍

2.方法列表

3.ReadAll

3.1 方法签名

1.输出控制台

1.1 Printf

1.format格式

2.打印字符串

3.打印布尔类型

4.打印浮点型

5.打印整数

6.打印指针

7.打印变量类型

8.打印结构体

9.打印Unicode

1.2 Print

1.获取时间

1.1 当前时间

1.2 当前年、月、日、时、分、秒、星期几

1.3 获取时分秒

1.4 创建指定时间

1.5 获取所属第几周

1.6 获取x年的第几天

2.字符串转时间

2.1 字符串转时间类型

2.2 格式化时间

1.转换成其他类型（Parse类函数）

1.1 转换成整型(Atoi)

1.语法

2.使用示例

1.2 解析成整型(ParseInt)

1.语法

1.字符串查找

1.1 方法列表

1.2 使用示例

2. 字符串分割

2.1 方法列表

2.2 使用示例

3.大小写切换

3.1 方法列表

3.2 使用示例

3.3 ToTitle和ToUpper的区别

1. 什么是Gvm

1. 遍历字符串(string)

1.1 统计长度后遍历

1.2 转为byte后遍历

2. 遍历数组(array)

2.1 遍历一维数组

2.2 遍历二维数组

3. 遍历切片(slice)

3.1 遍历一维切片

3.2 遍历二维切片

4. 遍历映射（map）

4.1 遍历一维map

4.2 遍历多维map

5.遍历结构（struct）

5.1 常结构遍历

5.2 嵌套结构遍历

1.创建

2.插入

3.取值

4.key是否存在

3.`ReadAll`

1.1 `Printf`

1.`format`格式

9.打印`Unicode`

1.2 `Print`