1、什么是变量
变量指定了某存储单元的名称，该存储单元会存储特定类型的值。在go中，有多种语法用于声明变量
2、变量的声明
2.1 声明单个变量
语法：var name type
package main
import "fmt"
func main(){
var age int // 变量声明
fmt.Println("my age is",age)
}
// my age is 0
1、此时只是声明了变量，变量名age，数据类型int，并没有给它赋值
2、如果变量没有被赋值，Go会自动将其初始化，赋值该变量类型的零值。此时age的值为0
3、变量可以赋值为本类型的任何值。注意是本类型。赋值语句：变量名 = 值
Go是强类型语言，因此不允许某一类型的变量赋值为其他类型，否则会报错
2.2 声明变量并初始化
声明变量的同时可以给定初始值
语法：var age int = 18
注意：不是var age int age = 18
2.3 类型推断
如果变量有初始化，那么Go能够自动推断具有初始值的变量的类型。因此初始化时，可以省略语法中的数据类型
如：var age = 18
2.4 声明多个变量并初始化
1、声明相同类型变量：
通过一条语句声明多个变量
语法：var name1,name2 type = value1,value2
同样可以省略类型
语法：var name1,name2 = value1,value2
同样，不初始化，那么必须声明类型，并且赋值该类型的零值
2、声明不同类型变量
语法：
var {
name1 = "tank"
age = 18
height int
}
2.5 简短声明
声明变量的简洁方式，使用:=操作符
语法：name :=value
如：
package main
import "fmt"
func main(){
name,age := "tank",19
fmt.Print("my name is ",name," and my age is ",age)
}
// my name is tank and my age is 19
注意：
1、:=操作符的左边至少有一个变量是尚未声明的
2、变量也可以是在运行时进行赋值的，即变量的值，可以是一个表达式的执行结果
3、数据类型
3.1 bool
布尔值，true或false
3.2 数字类型
3.2.1 有符号整形
| 类型 | 大小 | 取值范围 |
|---|---|---|
| int8 | 8 | -128~127 |
| int16 | 16 | -32768~32767 |
| int32 | 32 | -2147483648~2147483647 |
| int64 | 64 | -9223372036854775808~9223372036854775807 |
| int | 根据不同平台底层，32或64位 |
3.2.2 无符号整形
| 类型 | 大小 | 取值范围 |
|---|---|---|
| uint8 | 8 | 0~255 |
| uint16 | 16 | 0~65535 |
| uint32 | 32 | 0~4294967295 |
| uint64 | 64 | 0~18446744073709551615 |
| uint | 32或者64 |
3.2.3 浮点型
float32：32位浮点数
float64：64位浮点数（默认类型）
3.2.4 复数类型
complex64：实部和虚部都是float32类型的复数
complex128：实部和虚部都是64位的复数类型
内建complex用于创建一个包含实部和虚部的复数
complex的定义：
func complex(r,i)
1、两个参数分别是实部和虚部，返回值是一个复数类型
2、实部和虚部，应该是相同类型
3、使用简短语法声明：c := 6 + 7i
3.2.5 byte和rune
byte是uint8的别名
rune是int32的别名
3.3 string
字符串类型
在go中，字符串是字节的集合
可以简单理解为：很多字符组成的字符串
1、使用""定义字符串值
2、使用+拼接字符串
3.4 类型转换
Go中不允许不同类型之间的操作
如：float64不能与int相加减
转换类型的语法：type(value)
package main
import "fmt"
func main() {
a := 18
b := 180.5
c := a + int(b)
d := float64(a) +b
fmt.Print("c:",c)
fmt.Print(" d:",d)
}
//c:198 d:198.5
3.5 格式说明符
%T // 打印类型
%d // 打印字节大小 需要导入unsafe包，其中的Sizeof函数接收变量并返回它的字节大小
package main
import (
"fmt"
"unsafe"
)
func main() {
a := 18
b := "sb"
fmt.Println("value of a is ",a," and b is ", b)
fmt.Printf("type of a is %T,size of a is %d",a,unsafe.Sizeof(a))
fmt.Printf("
type of b is %T,size of b is %d",b,unsafe.Sizeof(b))
}
/*
value of a is 18 and b is sb
type of a is int,size of a is 8
type of b is string,size of b is 16
*/
4、常量
4.1 常量的值
1、在Go中，常量用于表示固定的值，比如：5,-89,I love Go等等
// 变量被赋值为常量
var a int = 18
var name string = 'tank'
2、关键字：const表示常量
package main
func main(){
const a int = 18
a = 81 // 此时将会报错，因为a被定义为了常量，值是固定的，不能修改
}
3、Go是编译型语言，常量的值会在编译的时候确定，所以不能将函数的返回值赋值给常量
package main
import (
"fmt"
"math"
)
func main(){
fmt.Println("Hello,boys")
var a = math.Sqrt(4)
const b = math.Sqrt(4) // 将会报错
}
4.2 常量的类型
1、定义常量的两种方式：
const a = 9 //不声明数据类型，那么它可以关联的默认数据类型是所有的数字类型，在赋值时，才会确定
const b float32 = 10 //声明数据类型，那么这个常量就只能是该类型的常量
package main
import (
"fmt"
)
func main(){
const a = 9
const b float32 = 10
var c complex64 = a
//var d complex128 = b //报错，常量b类型是float32,不能赋值给类型为complex128的变量d
var e complex128 = c //报错，变量c的类型是complex64,不能赋值给类型为complex128的变量
fmt.Printf("a 的类型：%T",a)
fmt.Printf("
b 的类型：%T",b)
fmt.Printf("
c 的类型：%T",c)
//fmt.Printf("
d 的类型：%T",d)
fmt.Printf("
e 的类型：%T",e)
}
2、按数据类型分析常量
数字常量
1、不声明常量类型时，可以关联到所有的数字数据而类型
2、无类型常量的默认关联类型在语法中才能确定，但是不超过大类型，如数字不能关联到字符串
3、数字常量可以在表达式中进行自由混合和搭配，只有当他们被分配给变量或者需要类型的代码中才会需要类型
package main
import (
"fmt"
)
func main(){
const a = 18
var b int16 = a
var c float32 = a
var d complex64 = complex(a,6.5) // 数字常量6.5 在此语法中关联默认类型float32
var e complex128 = complex(float64(c),6) // 数字常量6 在此语法中关联默认类型float64
fmt.Println(a,b,c,d,e)
fmt.Printf("%T,%T,%T,%T,%T,%T",a,b,c,d,e,6.0) // 浮点数常量默认关联类型float64
}
/*
18 18 18 (18+6.5i) (18+6i)
int,int16,float32,complex64,complex128,float64
*/
字符串常量
1、双引号中的任何值都是Go中的字符串常量
2、字符串类型string起了别名后是一个新的字符串类型，如MySring，尽管意义是一样的，但是在规则上，是不同的类型
因此，他们之间也不能进行分配，比如类型string的常量或变量不能赋值给MyString类型的常量或变量
布尔常量
1、两个无类型的常量true和false
2、特点与字符串一样