零值
变量在定义时没有明确的初始化时会赋值为 零值 。
零值是：
~~~
数值类型为 0 ，
布尔类型为 false ，
字符串为 "" （空字符串）。
~~~
Golang 不支持隐式类型转换，即便是从窄向宽转换也不行。
~~~
package main
var b byte = 100
// var n int = b
// ./main.go:5:5: cannot use b (type byte) as type int in assignment
var n int = int(b) // 显式转换
func main() {}
~~~
同样不能将其他类型当 bool 值使用。
~~~
package main
func main() {
a := 100
if a { // Error: non-bool a (type int) used as if condition
println("true")
}
}
~~~
类型转换
类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下：
表达式 T(v) 将值 v 转换为类型 T 。
type_name(expression)
type_name 为类型，expression 为表达式。
实例
将整型转化为浮点型，并计算结果，将结果赋值给浮点型变量：
~~~
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum) / float32(count)
fmt.Printf("mean 的值为: %f\n", mean)
}
~~~
输出结果：
~~~
mean 的值为: 3.400000
~~~
一些关于数值的转换：
~~~
package main
import (
"fmt"
"reflect"
)
func main() {
var i int = 42
fmt.Printf("i value is : %v , type is : %v \n", i, reflect.TypeOf(i))
var f float64 = float64(i)
fmt.Printf("f value is : %v , type is : %v \n", f, reflect.TypeOf(f))
var u uint = uint(f)
fmt.Printf("u value is : %v , type is : %v \n", u, reflect.TypeOf(u))
}
~~~
输出结果：
~~~
i value is : 42 , type is : int
f value is : 42 , type is : float64
u value is : 42 , type is : uint
~~~
或者，更加简单的形式：
~~~
package main
import (
"fmt"
"reflect"
)
func main() {
i := 42
f := float64(i)
u := uint(f)
fmt.Printf("i value is : %v , type is : %v \n", i, reflect.TypeOf(i))
fmt.Printf("f value is : %v , type is : %v \n", f, reflect.TypeOf(f))
fmt.Printf("u value is : %v , type is : %v \n", u, reflect.TypeOf(u))
}
~~~
输出结果：
~~~
i value is : 42 , type is : int
f value is : 42 , type is : float64
u value is : 42 , type is : uint
~~~
类型推导
在定义一个变量却并不显式指定其类型时（使用 := 语法或者 var = 表达式语法）【全局变量不适用】， 变量的类型由（等号）右侧的值推导得出。
当右值定义了类型时，新变量的类型与其相同：
~~~
package main
import (
"fmt"
"reflect"
)
func main() {
var i int
j := i // j 也是一个 int
fmt.Printf("i type is : %v\n", reflect.TypeOf(i))
fmt.Printf("j type is : %v\n", reflect.TypeOf(j))
}
~~~
输出结果：
~~~
i type is : int
j type is : int
~~~
但是当右边包含了未指名类型的数字常量时，新的变量就可能是 int 、 float64 或 complex128 。
~~~
package main
import (
"fmt"
"reflect"
)
func main() {
i := 42
f := 3.142
g := 0.867 + 0.5i
fmt.Printf("i type is : %v\n", reflect.TypeOf(i))
fmt.Printf("f type is : %v\n", reflect.TypeOf(f))
fmt.Printf("g type is : %v\n", reflect.TypeOf(g))
}
~~~
输出结果：
~~~
i type is : int
f type is : float64
g type is : complex128
~~~
Go各种类型转换及函数的高级用法
字符串转整形
~~~
将字符串转换为 int 类型
strconv.ParseInt(str,base,bitSize)
str：要转换的字符串
base：进位制（2 进制到 36 进制）
bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
返回转换后的结果和转换时遇到的错误
如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）
ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数
~~~
Atoi 相当于 ParseInt(s, 10, 0)
通常使用这个函数，而不使用 ParseInt
该方法的源码是：
~~~
// Itoa is shorthand for FormatInt(i, 10).
func Itoa(i int) string {
return FormatInt(int64(i), 10)
}
可以看出是FormatInt方法的简单实现。
~~~
~~~
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
i, ok := strconv.ParseInt("1000", 10, 0)
if ok == nil {
fmt.Printf("ParseInt , i is %v , type is %v\n", i, reflect.TypeOf(i))
}
ui, ok := strconv.ParseUint("100", 10, 0)
if ok == nil {
fmt.Printf("ParseUint , ui is %v , type is %v\n", ui, reflect.TypeOf(i))
}
oi, ok := strconv.Atoi("100")
if ok == nil {
fmt.Printf("Atoi , oi is %v , type is %v\n", oi, reflect.TypeOf(i))
}
}
~~~
输出结果：
~~~
ParseInt , i is 1000 , type is int64
ParseUint , ui is 100 , type is int64
Atoi , oi is 100 , type is int64
~~~
整形转字符串
~~~
FormatInt int 型整数 i 转换为字符串形式
strconv.FormatInt.(i,base)
FormatUint 将 uint 型整数 i 转换为字符串形式
strconv.FormatUint.(i,base)
base：进位制（2 进制到 36 进制）
大于 10 进制的数，返回值使用小写字母 ‘a’ 到 ‘z’
Itoa 相当于 FormatInt(i, 10)
~~~
~~~
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
var i int64
i = 0x100
str := strconv.FormatInt(i, 10) // FormatInt第二个参数表示进制，10表示十进制。
fmt.Println(str)
fmt.Println(reflect.TypeOf(str))
}
~~~
输出结果：
~~~
256
string
~~~
AppendInt 将 int 型整数 i 转换为字符串形式，并追加到 []byte 的尾部
strconv.AppendInt([]byte, i, base)
AppendUint 将 uint 型整数 i 转换为字符串形式，并追加到 dst 的尾部
strconv.AppendUint([]byte, i, base)
i：要转换的字符串
base：进位制
返回追加后的 []byte
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b := make([]byte, 0)
b = strconv.AppendInt(b, -2048, 16)
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
-800
~~~
字节转32位整形
~~~
package main
import (
"bytes"
"encoding/binary"
"fmt"
)
func main() {
b := []byte{0x00, 0x00, 0x03, 0xe8}
bytesBuffer := bytes.NewBuffer(b)
var x int32
binary.Read(bytesBuffer, binary.BigEndian, &x)
fmt.Println(x)
}
// 其中binary.BigEndian表示字节序，相应的还有little endian。通俗的说法叫大端、小端。
~~~
输出结果：
~~~
1000
~~~
32位整形转字节
~~~
package main
import (
"bytes"
"encoding/binary"
"fmt"
"reflect"
)
func main() {
var x int32
x = 106
bytesBuffer := bytes.NewBuffer([]byte{})
binary.Write(bytesBuffer, binary.BigEndian, x)
b := bytesBuffer.Bytes()
fmt.Println(b)
fmt.Println(reflect.TypeOf(b))
}
~~~
输出结果：
~~~
[0 0 0 106]
[]uint8
~~~
字节转字符串
~~~
package main
import (
"fmt"
"reflect"
)
func main() {
b := []byte{97, 98, 99, 100}
str := string(b)
fmt.Println(str)
fmt.Println(reflect.TypeOf(str))
}
~~~
输出结果：
~~~
abcd
string
~~~
字符串转字节
~~~
package main
import (
"fmt"
)
func main() {
str := "abcd"
b := []byte(str)
fmt.Println(b)
}
~~~
输出结果：
~~~
[97 98 99 100]
~~~
字符串转布尔值 ParseBool
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b, err := strconv.ParseBool("1")
fmt.Printf("string 1 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("t")
fmt.Printf("string t 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("T")
fmt.Printf("string T 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("true")
fmt.Printf("string true 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("True")
fmt.Printf("string True 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("TRUE")
fmt.Printf("string TRUE 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("TRue")
fmt.Printf("string TRue 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("")
fmt.Printf("string '' 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("0")
fmt.Printf("string 0 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("f")
fmt.Printf("string f 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("F")
fmt.Printf("string F 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("false")
fmt.Printf("string false 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("False")
fmt.Printf("string False 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("FALSE")
fmt.Printf("string FALSE 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("FALse")
fmt.Printf("string FALse 转 bool ：%v , err is : %v\n", b, err)
b, err = strconv.ParseBool("abc")
fmt.Printf("string abc 转 bool ：%v , err is : %v\n", b, err)
}
~~~
输出结果：
~~~
string 1 转 bool ：true , err is : <nil>
string t 转 bool ：true , err is : <nil>
string T 转 bool ：true , err is : <nil>
string true 转 bool ：true , err is : <nil>
string True 转 bool ：true , err is : <nil>
string TRUE 转 bool ：true , err is : <nil>
string TRue 转 bool ：false , err is : strconv.ParseBool: parsing "TRue": invalid syntax
string '' 转 bool ：false , err is : strconv.ParseBool: parsing "": invalid syntax
string 0 转 bool ：false , err is : <nil>
string f 转 bool ：false , err is : <nil>
string F 转 bool ：false , err is : <nil>
string false 转 bool ：false , err is : <nil>
string False 转 bool ：false , err is : <nil>
string FALSE 转 bool ：false , err is : <nil>
string FALse 转 bool ：false , err is : strconv.ParseBool: parsing "FALse": invalid syntax
string abc 转 bool ：false , err is : strconv.ParseBool: parsing "abc": invalid syntax
ParseBool 将字符串转换为布尔值
它接受真值：1, t, T, TRUE, true, True
它接受假值：0, f, F, FALSE, false, False.
其它任何值都返回一个错误
~~~
布尔值转换为字符串 FormatBool
~~~
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
t := strconv.FormatBool(true)
f := strconv.FormatBool(false)
fmt.Printf("t is %v , t type is %v\n", t, reflect.TypeOf(t))
fmt.Printf("f is %v , f type is %v\n", f, reflect.TypeOf(f))
}
~~~
输出结果：
~~~
t is true , t type is string
f is false , f type is string
~~~
AppendBool 将布尔类型转换为字符串
然后将结果追加到 []byte 的尾部，返回追加后的 []byte
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
rst := []byte{}
fmt.Printf("[]byte{} is %s\n", rst)
rst = strconv.AppendBool(rst, true)
fmt.Printf("appended true []byte{} is %s\n", rst)
rst = strconv.AppendBool(rst, false)
fmt.Printf("appended false []byte{} is %s\n", rst)
}
~~~
输出结果：
~~~
[]byte{} is
appended true []byte{} is true
appended false []byte{} is truefalse
~~~
将字符串转换为浮点数
strconv.ParseFloat(str,bitSize)
str：要转换的字符串
bitSize：指定浮点类型（32:float32、64:float64）
如果 str 是合法的格式，而且接近一个浮点值，
则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）
如果 str 不是合法的格式，则返回“语法错误”
如果转换结果超出 bitSize 范围，则返回“超出范围”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
s := "0.12345678901234567890"
f, err := strconv.ParseFloat(s, 32)
fmt.Println(f, err)
fmt.Println(float32(f))
fmt.Println("-----")
f, err = strconv.ParseFloat(s, 64)
fmt.Println(f, err)
fmt.Println(float64(f))
fmt.Println("-----")
str := "abcd"
f, err = strconv.ParseFloat(str, 32)
fmt.Println(f, err)
}
~~~
输出结果：
~~~
0.12345679104328156 <nil>
0.12345679
-----
0.12345678901234568 <nil>
0.12345678901234568
-----
0 strconv.ParseFloat: parsing "abcd": invalid syntax
~~~
将浮点数转换为字符串值
~~~
strconv.FormatFloat(f,fmt,prec,bitSize)
f：要转换的浮点数
fmt：格式标记（b、e、E、,f、g、G）
prec：精度（数字部分的长度，不包括指数部分）
bitSize：指定浮点类型（32:float32、64:float64）
格式标记：
‘b’ (-ddddp±ddd，二进制指数)
‘e’ (-d.dddde±dd，十进制指数)
‘E’ (-d.ddddE±dd，十进制指数)
‘f’ (-ddd.dddd，没有指数)
‘g’ (‘e’:大指数，’f’:其它情况)
‘G’ (‘E’:大指数，’f’:其它情况)
如果格式标记为 ‘e’，’E’和’f’，则 prec 表示小数点后的数字位数
如果格式标记为 ‘g’，’G’，则 prec 表示总的数字位数（整数部分+小数部分）
~~~
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
f := 100.12345678901234567890123456789
fmt.Println(strconv.FormatFloat(f, 'b', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'e', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'E', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'f', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'g', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'G', 5, 32))
fmt.Println(strconv.FormatFloat(f, 'b', 30, 32))
fmt.Println(strconv.FormatFloat(f, 'e', 30, 32))
fmt.Println(strconv.FormatFloat(f, 'E', 30, 32))
fmt.Println(strconv.FormatFloat(f, 'f', 30, 32))
fmt.Println(strconv.FormatFloat(f, 'g', 30, 32))
fmt.Println(strconv.FormatFloat(f, 'G', 30, 32))
}
~~~
输出结果：
~~~
13123382p-17
1.00123e+02
1.00123E+02
100.12346
100.12
100.12
13123382p-17
1.001234588623046875000000000000e+02
1.001234588623046875000000000000E+02
100.123458862304687500000000000000
100.1234588623046875
100.1234588623046875
~~~
AppendFloat 将浮点数 f 转换为字符串值，并将转换结果追加到 []byte 的尾部
返回追加后的 []byte
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
f := 100.12345678901234567890123456789
b := make([]byte, 0)
b = strconv.AppendFloat(b, f, 'f', 5, 32)
b = append(b, " "...)
b = strconv.AppendFloat(b, f, 'e', 5, 32)
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
100.12346 1.00123e+02
~~~
Quote 将字符串 s 转换为“双引号”引起来的字符串
其中的特殊字符将被转换为“转义字符”
不可显示的字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Println(strconv.Quote(`C:\Windows`))
}
~~~
输出结果：
~~~
"C:\\Windows"
~~~
AppendQuote 将字符串 s 转换为“双引号”引起来的字符串，
并将结果追加到 []byte 的尾部，返回追加后的 []byte
其中的特殊字符将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
s := `C:\Windows`
b := make([]byte, 0)
b = strconv.AppendQuote(b, s)
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
"C:\\Windows"
~~~
QuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串
“非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
asc := strconv.QuoteToASCII("Hello 世界！")
fmt.Println(asc)
}
~~~
输出结果：
~~~
"Hello \u4e16\u754c\uff01"
~~~
AppendQuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串，
并将结果追加到 []byte 的尾部，返回追加后的 []byte
非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
s := "Hello 世界！"
b := make([]byte, 0)
b = strconv.AppendQuoteToASCII(b, s)
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
"Hello \u4e16\u754c\uff01"
~~~
QuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串
特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
str := strconv.QuoteRune('哈')
fmt.Println(str)
}
~~~
输出结果：
~~~
'哈'
~~~
AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串，
并将结果追加到 []byte 的尾部，返回追加后的 []byte
特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b := make([]byte, 0)
b = strconv.AppendQuoteRune(b, '哈')
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
'哈'
~~~
QuoteRuneToASCII 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串
“非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
asc := strconv.QuoteRuneToASCII('哈')
fmt.Println(asc)
}
~~~
输出结果：
~~~
'\u54c8'
~~~
AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串，
并将结果追加到 []byte 的尾部，返回追加后的 []byte
“非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b := make([]byte, 0)
b = strconv.AppendQuoteRuneToASCII(b, '哈')
fmt.Printf("%s\n", b)
}
~~~
输出结果：
~~~
'\u54c8'
~~~
CanBackquote 判断字符串 s 是否可以表示为一个单行的“反引号”字符串
字符串中不能含有控制字符（除了 \t）和“反引号”字符，否则返回 false
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b := strconv.CanBackquote("C:\\Windows\n")
fmt.Printf("\\n is %v\n", b)
b = strconv.CanBackquote("C:\\Windows\r")
fmt.Printf("\\r is %v\n", b)
b = strconv.CanBackquote("C:\\Windows\f")
fmt.Printf("\\f is %v\n", b)
b = strconv.CanBackquote("C:\\Windows\t")
fmt.Printf("\\t is %v\n", b)
b = strconv.CanBackquote("C:\\Windows`")
fmt.Printf("` is %v\n", b)
}
~~~
输出结果：
~~~
\n is false
\r is false
\f is false
\t is true
` is false
~~~
UnquoteChar 将 s 中的第一个字符“取消转义”并解码
s：转义后的字符串
quote：字符串使用的“引号符”（用于对引号符“取消转义”）
value： 解码后的字符
multibyte：value 是否为多字节字符
tail： 字符串 s 除去 value 后的剩余部分
error： 返回 s 中是否存在语法错误
参数 quote 为“引号符”
如果设置为单引号，则 s 中允许出现 \' 字符，不允许出现单独的 ' 字符
如果设置为双引号，则 s 中允许出现 \" 字符，不允许出现单独的 " 字符
如果设置为 0，则不允许出现 \' 或 \" 字符，可以出现单独的 ' 或 " 字符
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
s := `\"大\\家\\好！\"`
c, mb, sr, _ := strconv.UnquoteChar(s, '"')
fmt.Printf("%-3c %v\n", c, mb)
for ; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr, '"') {
fmt.Printf("%-3c %v\n", c, mb)
}
}
~~~
输出结果：
~~~
" false
" false
大 true
\ false
家 true
\ false
好 true
！ true
~~~
Unquote 将“带引号的字符串” s 转换为常规的字符串（不带引号和转义字符）
s 可以是“单引号”、“双引号”或“反引号”引起来的字符串（包括引号本身）
如果 s 是单引号引起来的字符串，则返回该该字符串代表的字符
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
sr, err := strconv.Unquote("\"大\t家\t好！\"")
fmt.Println(sr, err)
sr, err = strconv.Unquote(`'大家好！'`)
fmt.Println(sr, err)
sr, err = strconv.Unquote("'好'")
fmt.Println(sr, err)
sr, err = strconv.Unquote("大\\t家\\t好！")
fmt.Println(sr, err)
}
~~~
输出结果：
~~~
大 家 好！ <nil>
invalid syntax
好 <nil>
invalid syntax
~~~
IsPrint 判断 Unicode 字符 r 是否是一个可显示的字符
可否显示并不是你想象的那样，比如空格可以显示，而\t则不能显示
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Println(strconv.IsPrint('a'))
fmt.Println(strconv.IsPrint('好'))
fmt.Println(strconv.IsPrint(' '))
fmt.Println(strconv.IsPrint('\t'))
fmt.Println(strconv.IsPrint('\n'))
fmt.Println(strconv.IsPrint(0))
}
~~~
输出结果：
~~~
true
true
true
false
false
false
~~~
- 序言
- 目录
- 环境搭建
- Linux搭建golang环境
- Windows搭建golang环境
- Mac搭建golang环境
- 介绍
- 1.Go语言的主要特征
- 2.golang内置类型和函数
- 3.init函数和main函数
- 4.包
- 1.工作空间
- 2.源文件
- 3.包结构
- 4.文档
- 5.编写 Hello World
- 6.Go语言 “ _ ”（下划线）
- 7.运算符
- 8.命令
- 类型
- 1.变量
- 2.常量
- 3.基本类型
- 1.基本类型介绍
- 2.字符串String
- 3.数组Array
- 4.类型转换
- 4.引用类型
- 1.引用类型介绍
- 2.切片Slice
- 3.容器Map
- 4.管道Channel
- 5.指针
- 6.自定义类型Struct
- 编码格式转换
- 流程控制
- 1.条件语句（if）
- 2.条件语句 （switch）
- 3.条件语句 （select）
- 4.循环语句 （for）
- 5.循环语句 （range）
- 6.循环控制Goto、Break、Continue
- 函数
- 1.函数定义
- 2.参数
- 3.返回值
- 4.匿名函数
- 5.闭包、递归
- 6.延迟调用 （defer）
- 7.异常处理
- 8.单元测试
- 压力测试
- 方法
- 1.方法定义
- 2.匿名字段
- 3.方法集
- 4.表达式
- 5.自定义error
- 接口
- 1.接口定义
- 2.执行机制
- 3.接口转换
- 4.接口技巧
- 面向对象特性
- 并发
- 1.并发介绍
- 2.Goroutine
- 3.Chan
- 4.WaitGroup
- 5.Context
- 应用
- 反射reflection
- 1.获取基本类型
- 2.获取结构体
- 3.Elem反射操作基本类型
- 4.反射调用结构体方法
- 5.Elem反射操作结构体
- 6.Elem反射获取tag
- 7.应用
- json协议
- 1.结构体转json
- 2.map转json
- 3.int转json
- 4.slice转json
- 5.json反序列化为结构体
- 6.json反序列化为map
- 终端读取
- 1.键盘（控制台）输入fmt
- 2.命令行参数os.Args
- 3.命令行参数flag
- 文件操作
- 1.文件创建
- 2.文件写入
- 3.文件读取
- 4.文件删除
- 5.压缩文件读写
- 6.判断文件或文件夹是否存在
- 7.从一个文件拷贝到另一个文件
- 8.写入内容到Excel
- 9.日志（log）文件
- server服务
- 1.服务端
- 2.客户端
- 3.tcp获取网页数据
- 4.http初识-浏览器访问服务器
- 5.客户端访问服务器
- 6.访问延迟处理
- 7.form表单提交
- web模板
- 1.渲染终端
- 2.渲染浏览器
- 3.渲染存储文件
- 4.自定义io.Writer渲染
- 5.模板语法
- 时间处理
- 1.格式化
- 2.运行时间
- 3.定时器
- 锁机制
- 互斥锁
- 读写锁
- 性能比较
- sync.Map
- 原子操作
- 1.原子增(减)值
- 2.比较并交换
- 3.导入、导出、交换
- 加密解密
- 1.md5
- 2.base64
- 3.sha
- 4.hmac
- 常用算法
- 1.冒泡排序
- 2.选择排序
- 3.快速排序
- 4.插入排序
- 5.睡眠排序
- 设计模式
- 创建型模式
- 单例模式
- 抽象工厂模式
- 工厂方法模式
- 原型模式
- 结构型模式
- 适配器模式
- 桥接模式
- 合成/组合模式
- 装饰模式
- 外观模式
- 享元模式
- 代理模式
- 行为性模式
- 职责链模式
- 命令模式
- 解释器模式
- 迭代器模式
- 中介者模式
- 备忘录模式
- 观察者模式
- 状态模式
- 策略模式
- 模板模式
- 访问者模式
- 数据库操作
- golang操作MySQL
- 1.mysql使用
- 2.insert操作
- 3.select 操作
- 4.update 操作
- 5.delete 操作
- 6.MySQL事务
- golang操作Redis
- 1.redis介绍
- 2.golang链接redis
- 3.String类型 Set、Get操作
- 4.String 批量操作
- 5.设置过期时间
- 6.list队列操作
- 7.Hash表
- 8.Redis连接池
- golang操作ETCD
- 1.etcd介绍
- 2.链接etcd
- 3.etcd存取
- 4.etcd监听Watch
- golang操作kafka
- 1.kafka介绍
- 2.写入kafka
- 3.kafka消费
- golang操作ElasticSearch
- 1.ElasticSearch介绍
- 2.kibana介绍
- 3.写入ElasticSearch
- NSQ
- 安装
- 生产者
- 消费者
- beego框架
- 1.beego框架环境搭建
- 2.参数配置
- 1.默认参数
- 2.自定义配置
- 3.config包使用
- 3.路由设置
- 1.自动匹配
- 2.固定路由
- 3.正则路由
- 4.注解路由
- 5.namespace
- 4.多种数据格式输出
- 1.直接输出字符串
- 2.模板数据输出
- 3.json格式数据输出
- 4.xml格式数据输出
- 5.jsonp调用
- 5.模板处理
- 1.模板语法
- 2.基本函数
- 3.模板函数
- 6.请求处理
- 1.GET请求
- 2.POST请求
- 3.文件上传
- 7.表单验证
- 1.表单验证
- 2.定制错误信息
- 3.struct tag 验证
- 4.XSRF过滤
- 8.静态文件处理
- 1.layout设计
- 9.日志处理
- 1.日志处理
- 2.logs 模块
- 10.会话控制
- 1.会话控制
- 2.session 包使用
- 11.ORM 使用
- 1.链接数据库
- 2. CRUD 操作
- 3.原生 SQL 操作
- 4.构造查询
- 5.事务处理
- 6.自动建表
- 12.beego 验证码
- 1.验证码插件
- 2.验证码使用
- beego admin
- 1.admin安装
- 2.admin开发
- beego 热升级
- gin框架
- 安装使用
- 项目
- 秒杀项目
- 日志收集
- 面试题
- 面试题一
- 面试题二
- 错题集
- Go语言陷阱和常见错误
- 常见语法错误
- 初级
- 中级
- 高级
- Go高级应用
- goim
- goim 启动流程
- goim 工作流程
- goim 结构体
- gopush
- gopush工作流程
- gopush启动流程
- gopush业务流程
- gopush应用
- gopush新添功能
- rpc
- HTTP RPC
- TCP RPC
- JSON RPC
- 常见RPC开源框架
- pprof
- pprof介绍
- pprof应用
- 封装 websocket
- zookeeper
- 基本操作测试
- 简单的分布式server
- Zookeeper命令行使用
- cgo
- Go语言 demo
- 用Go语言计算一个人的年龄，生肖，星座
- 超简易Go语言实现的留言板代码
- 信号处理模块，可用于在线加载配置，配置动态加载的信号为SIGHUP
- 阳历和阴历相互转化的工具类 golang版本
- 错误总结