2.1 命名
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的：heapSort和Heapsort是两个不同的名字。
Go语言中类似if和switch的关键字有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 |
此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。
|
内建常量: true false iota nil 内建类型: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error 内建函数: make len cap new append copy close delete complex real imag panic recover |
2.2 变量
变量是几乎所有编程语言中最基本的组成元素，变量是程序运行期间可以改变的量。
从根本上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。
2.2.1 变量声明
Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明， Go语言引入了关键字var，而类型信息放在变量名之后，示例如下：
|
var v1 int var v2 int
//一次定义多个变量 var v3, v4 int
var ( v5 int v6 int ) |
2.2.2 变量初始化
对于声明变量时需要进行初始化的场景， var关键字可以保留，但不再是必要的元素，如下所示：
|
var v1 int = 10 // 方式1 var v2 = 10 // 方式2，编译器自动推导出v2的类型 v3 := 10 // 方式3，编译器自动推导出v3的类型 fmt.Println("v3 type is ", reflect.TypeOf(v3)) //v3 type is int
//出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化 var v4 int v4 := 2 //err |
2.2.3 变量赋值
|
var v1 int v1 = 123
var v2, v3, v4 int v2, v3, v4 = 1, 2, 3 //多重赋值
i := 10 j := 20 i, j = j, i //多重赋值 |
2.2.4 匿名变量
_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃：
|
_, i, _, j := 1, 2, 3, 4
func test() (int, string) { return 250, "sb" }
_, str := test() |
2.3 常量
在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。
2.3.1 字面常量(常量值)
所谓字面常量（literal），是指程序中硬编码的常量，如：
|
123 3.1415 // 浮点类型的常量 3.2+12i // 复数类型的常量 true // 布尔类型的常量 "foo" // 字符串常量 |
2.3.2 常量定义
|
const Pi float64 = 3.14 // 常量一般大写表示 常量定义完不能更改访问 const zero = 0.0 // 浮点常量, 自动推导类型 //ctrl+alt+l 格式化代码 const ( // 常量组 size int64 = 1024 eof = -1 // 整型常量, 自动推导类型 )
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值 const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo" //err, 常量不能修改
const PI float64 = 3.14 //常量定以后值不能发生改变 //PI=3.14159//err var b float64 //代码写完后可以进行格式化 ctrl+alt+l b = PI fmt.Printf("%p\n", &b) //常量的地址不允许访问 常量是在数据区下的常量区进行存储 //fmt.Printf("%p\n",&PI)//err
|
2.3.3 iota枚举
常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。
在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。
|
const ( x = iota // x == 0 y = iota // y == 1 z = iota // z == 2 w // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota" ) const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0 const ( h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同 )
const ( a = iota //a=0 b = "B" c = iota //c=2 d, e, f = iota, iota, iota //d=3,e=3,f=3 g = iota //g = 4 )
const ( x1 = iota * 10 // x1 == 0 y1 = iota * 10 // y1 == 10 z1 = iota * 10 // z1 == 20 ) |
2.4 基础数据类型
Go语言内置以下这些基础类型：
|
类型 |
名称 |
长度 |
零值 |
说明 |
|
bool |
布尔类型 |
1 |
false |
其值不为真即为家，不可以用数字代表true或false |
|
byte |
字节型 |
1 |
0 |
uint8别名 |
|
rune |
字符类型 |
4 |
0 |
专用于存储unicode编码，等价于uint32 |
|
int, uint |
整型 |
4或8 |
0 |
32位或64位 |
|
int8, uint8 |
整型 |
1 |
0 |
-128 ~ 127, 0 ~ 255 |
|
int16, uint16 |
整型 |
2 |
0 |
-32768 ~ 32767, 0 ~ 65535 |
|
int32, uint32 |
整型 |
4 |
0 |
-21亿 ~ 21 亿, 0 ~ 42 亿 |
|
int64, uint64 |
整型 |
8 |
0 |
|
|
float32 |
浮点型 |
4 |
0.0 |
小数位精确到7位 |
|
float64 |
浮点型 |
8 |
0.0 |
小数位精确到15位 |
|
complex64 |
复数类型 |
8 |
||
|
complex128 |
复数类型 |
16 |
||
|
uintptr |
整型 |
4或8 |
⾜以存储指针的uint32或uint64整数 |
|
|
string |
字符串 |
"" |
utf-8字符串 |
内存存储
2.4.2 布尔类型
|
var v1 bool v1 = true v2 := (1 == 2) // v2也会被推导为bool类型
//布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换 var b bool b = 1 // err, 编译错误 b = bool(1) // err, 编译错误 |
2.4.3 整型
|
var v1 int32 v1 = 123 v2 := 64 // v1将会被自动推导为int类型 |
2.4.4 浮点型
|
var f1 float32 f1 = 12 f2 := 12.0 // 如果不加小数点， fvalue2会被推导为整型而不是浮点型，float64 |
2.4.5 字符类型
在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表utf-8字符串的单个字节的值；另一个是rune，代表单个unicode字符。
|
package main import ( "fmt" )
func main() { var ch1, ch2, ch3 byte ch1 = 'a' //字符赋值 ch2 = 97 //字符的ascii码赋值 ch3 = '\n' //转义字符 fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3) } |
2.4.6 字符串
|
var str string // 声明一个字符串变量 str = "abc" // 字符串赋值 ch := str[0] // 取字符串的第一个字符 fmt.Printf("str = %s, len = %d\n", str, len(str)) //内置的函数len()来取字符串的长度 fmt.Printf("str[0] = %c, ch = %c\n", str[0], ch)
//`(反引号)括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。 str2 := `hello mike \n \r测试 ` fmt.Println("str2 = ", str2) /* str2 = hello mike \n \r测试
*/
|
2.4.7 复数类型
复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。
|
var v1 complex64 // 由2个float32构成的复数类型 v1 = 3.2 + 12i v2 := 3.2 + 12i // v2是complex128类型 v3 := complex(3.2, 12) // v3结果同v2
fmt.Println(v1, v2, v3) //内置函数real(v1)获得该复数的实部 //通过imag(v1)获得该复数的虚部 fmt.Println(real(v1), imag(v1)) |