目录
3 go语言变量类型
1 数字
1.1 int、int8、int16、int32、int64
| int类型 | 表示范围 |
|---|---|
| int | 整数 - 分正负 |
| int8 | 1个字节，表示 -128 ~ +127 |
| int16 | 2个字节，表示 -2的15次方 ~ +2的15次方 |
| int32 | 表示 -2的31次方 ~ +2的31次方 |
| int64 | 表示 -2的63次方 ~ +2的63次方 |
1.2 uint、uint8、uint16、uint32、uint64
| int类型 | 表示范围 |
|---|---|
| uint | 正整数 |
| uint8 | 1个字节，表示 0 ~ 256 |
| uint16 | 2个字节，表示 0 ~ +2的15次方 |
| uint32 | 表示 -2的31次方 ~ +2的31次方 |
| uint64 | 表示 -2的63次方 ~ +2的63次方 |
1.3 浮点型
| 浮点型 | 表示范围 |
|---|---|
| float32 | 小数点后7位 |
| float64 | 小数点后16位（只要足够长默认是64） |
var p1 float32 = 12.12345678901234567890
var p2 float64 = 12.12345678901234567890
fmt.Println(p1) // 12.123457
fmt.Println(p2) // 12.123456789012346
1.4 复数
| 复数 | 表示 |
|---|---|
| complex64 | |
| complex128 |
var a complex64 = 4 + 4i
var b complex64 = 9 + 7i
fmt.Println(a + b) // (13+11i)
1.5 byte和rune
| 名称 | 表示 |
|---|---|
| byte | unit8的别名 - ascii码的1个字符长度 |
| rune | int32的别名 - unicode的1个字符长度 |
python 中len()函数算的是字节长度
2 字符串
string
- 双引号：字符串
- 单引号：表示一个字符 - 默认使用int32字符串
字符串 没有则返回空字符串
数字类型 则返回0
3 布尔类型
| 名称 | |
|---|---|
| true | |
| false |
4 常量
常量：恒定不变的常量，定义后值固定不变，不允许修改，用const关键字定义
- 定义单个
const name string = "duo" // 完整定义后不允许改
const name = "duo"
- 定义多个
// 1 这种方式定义多个，只能为同一类型
const name2,age2 = "duo","12"
// 2 可以定义多个不同类型的常量
const (
loveGod string = "Cupid"
warGod string = "Athens"
godAge int = 100
)
// 3 同时定义多个常量，如果没有赋初值，初值就是上一个的值
const (
a1 = 13
b1 = 12
c
d
e
f
)
fmt.Println(c, d, e, f) //12 12 12 12
5 iota 常量生成器
关键字iota，创建一些列相关的值，省略逐个定义
（1）定义规则
iota声明的常量默认会自增1，iota可理解为const语句块中的行索引
// iota 常量生成器
const (
a1 = 12
b1 = 12
c = iota
d
e
f
)
fmt.Println(c, d, e, f) //2 3 4 5
// 支持位运算
const (
KB = 1 << (10 * iota)
MB
GB
)
fmt.Println(KB, MB, GB) // 1 1024 1048576
iota注意事项：
- ① iota的使用，必须在
const语句块中- ② iota 放在第几行，值就是多少，后续的都会自增
6 语句块、可见规则、作用域范围
6.1 语句块
语句块是指：有由大括号围起来的一个语句序列，比如for循环语句块，if/else判断语句块。在语句块内部声明的变量对外部不可见，块把声明围起来，决定了它的作用域
6.2 可见行规则
包通过 导出 机制控制 变量、结构体、函数等数据可见性
- 可见行规则：
全局可见：首字母大写，可导出
包内可见：首字母小写，不可导出
6.3 作用域范围
（1）全局变量
根据可见行规则，决定在包内可用还是在全局可用
（2）局部变量
① 不同的层级作用域
外层定义的变量在内层可以使用，内层定义的变量外层不可以使用。 常见的 if, for 等都是不同的代码块， 每个代码块组成了一个层级。
② 内层变量覆盖外层变量
一个程序可以包含多个相同名称的变量，只要这些变量处在不同的语句块内，而内层的会覆盖外出的同名变量
package main
import "fmt"
// 语句块
var phoneVersion string = "12 plus"
func printVersion (){
var phoneVersion string = "11 plus"
fmt.Println(phoneVersion)
}
func main() {
fmt.Println(phoneVersion)
printVersion()
}
-------------
12 plus
11 plus
7 函数
函数 是将一个或者一类问题包装为一个代码块，可以被多次调用，提高代码重用性。
7.1 语法规则
func 函数名(参数1 类型, 参数2 类型, ...) (返回值1类型, 返回值2类型, ...) {
逻辑...
return 返回值1, 返回值2, ...
}
/Users/duoduo/mianshi/django_1
// 普通函数，有参数 有返回值
func sayHello(name,sentence string) string {
fmt.Printf("%s说了：%s",name,sentence)
return sentence
}
// 调用
sayHello("duoduo","hello world!")
7.2 匿名函数
匿名函数赋值给一个变量
var a string = "duoduo"
func test(b int) {
var f func() int = func() int {
fmt.Printf(a)
return b
}
f()
}
7.3 闭包函数
func test1() func() {
t := 10
ff := func() {
fmt.Println(t)
}
return ff
}