Go的测试文件写法：
1、源码文件以_test结尾：xxx_test.go
2、测试方法名以 Test 开头：func TestXXX(t *testing.T){...}
Go的25个关键字或保留字
| break | default | func | interface | select |
|---|---|---|---|---|
| case | defer | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrough | if | range | type |
| continue | for | import | return | var |
Go 的 36 个预定义标识符
| append | bool | byte | cap | close | complex | complex64 | complex128 | uint16 |
|---|---|---|---|---|---|---|---|---|
| copy | false | float32 | float64 | imag | int | int8 | int16 | uint32 |
| int 32 | int64 | iota | len | make | new | nil | panic | uint64 |
| println | real | recover | string | true | uint | uint8 | uintptr |
Go 的数据类型
- 布尔型
- 数字类型
- 整数型
- uint8 无符号 8 位整数型(0 到 255)
- uint16 无符号 16 位整数型(0 到 65535)
- uint32 无符号 32 位整数型(0 到 4294967295)
- uint64 无符号 64 位整数型(0 到 18446744073709551615)
- int8 有符号 8 位整数(-128 到 127)
- int16 有符号 16 位整数(-32768 到 32767)
- int32 有符号 32 位整数(-2147483648 到 2147483647)
- int64 有符号 64 位整数(-923372036854775808 到 923372036854775807)
- 浮点型
- float32 IEEE-754 32位浮点型数
- float64 IEEE-754 64位浮点型数
- complex64 32 位实数和虚数
- complex128 64 位实数和虚数
- 其他数字类型
- byte 类似 uint8
- rune 类似 int32
- uint 32或64位
- int 与 uint 一样大小
- uintptr 无符号整型，用于存放一个指针
- 整数型
- 字符串类型
- 派生类型
- 指针类型(Pointer)
- 数组类型
- 结构化类型(struct)
- Channel 类型
- 函数类型
- 切片类型
- 接口类型(interface)
- Map 类型
Go与其他主要变成语言的差异
- 赋值可以进行自动类型推断
- 在一个赋值语句中可以对多个变量进行同时赋值
变量声明方法：
// 第一种书写方法变量声明 var 变量名 类型 = 值
var a int = 1
var b int = 1
// 第二种书写方法 这种写法在
var (
a int =1
b int = 1
)
// 第三种书写方法 这种方法用了go的类型推断，和Python相似
a :=1
b :=1
a,b,c := 1,2,"str"
实现一个小demo
斐波那锲
package main
import (
"fmt"
"testing"
)
func TestFibList(t *testing.T){
var a int = 1
var b int = 1
fmt.Println(a)
for i :=0; i < 5; i++{
fmt.Println(" ",b)
tmp := a
a = b
b = tmp + a
}
fmt.Println()
}
交换两个变量的值
func TestExchange(t *testing.T){
a := 1
b := 1
tmp := a
a = b
b = tmp
}
// 第二种方法(这种方法必须是两个变量的类型相同)
a,b = b,a
_ 实际上是一个只写变量，你不能得到他的值，这样做是因为Go语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
package main
import "fmt"
func main(){
numb,_,str1 := numbers()
fmt.Println(numb,str1) // 这里如果打印_就会报错
}
func numbers()(int,int,string){ // 这里的第二个括号中是返回的数据类型
a,b,c := 1,2,"str"
return a,b,c
}
// 输出结果：
2 str
常量
常量的定义格式：
const identifier [type] = value
const a string = "abc" // 显示类型定义
const b = "abc" // 隐式类型定义
// 多个相同类型的声明
const name1,name2 = "abc","ace"
常量名一般默认是全大写
举个栗子：
package main
import "fmt"
func main(){
const LENGTH int = 10
const WIDTH int = 5
var area int
const a,b,c = 1, false, "str" // 这个是个多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a,b,c)
}
// 运行结果
面积为 : 50
1 false str
iota
iota 特殊常量，可以认为是一个可以被编译器修改的常量
iota 在 const 关键字出现时将被重置为0(这个重置为0是在 const 内部的第一行之前，如果是在别的行，那就是恢复为几减一，如const中第七个数，再次出现iota则会恢复为6)，const 中每新增一行常量声明将使 iota 计数一次( iota 可以理解成 const 语句块中的行索引)。
// 第一种写法
const(
a = iota
b = iota
c = iota
)
// 第二种写法
const(
a = iota
b
c
)
// 运行结果：
a = 0, b = 1, c = 2
举个栗子：
package main
import "fmt"
func main(){
const(
a = iota // 这里是 0
b
c
d = "ha" // 独立值，哈iota没关系，但是iota在这里会+1
e // "ha" iota+=1
f = 100 // 同样是独立值 iota+=1
g // 100 iota+=1
h = iota // iota 恢复计数
i
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
Go不支持隐式类型转换
// 错误的例子
package main
import "testing"
func TestImplicit(t *testing.T){
var a int32 = 1
var b int64
b = a
t.Log(a,b)
}
// 修改上面的错误
package main
import "testing"
func TestImplicit(t *testing.T){
var a int32 = 1
var b int64
b = int64(a)
t.Log(a,b)
}
// 自写类型
package main
import "testing"
type MyInt int64 // 这个就是自写类型
func TestImplicit(t *testing.T){
var a int32 = 1
var b int64
b = int64(a)
var c MyInt
c = MyInt(a) // 这里自写类型转换
t.Log(a,b,c)
}
string转成int：
int, err := strconv.Atoi(string)
string转成int64：
int64, err := strconv.ParseInt(string, 10, 64)
int转成string：
string := strconv.Itoa(int)
int64转成string：
string := strconv.FormatInt(int64,10)