类型

变量

定义

var name type = expression

　　

类型和表达式部分可以省略一个

关键字var定义变量，类型放在变量名后

var x int //自动初始化为0
var y=false //自动推断为bool类型

　　

可一次定义多个变量，包括用不同初始值定义不同类型

var x,y int //相同类型的多个变量
var a,s = 100,"abc" //不同类型初始化值

　　

依照惯例，建议组方式整理多行变量定义

var (
	x,y int
	a,s = 100,"abc"
)

　　

简短模式

	x := 100
	a, s := 100, "abc"

　　限制

• 不能提供数据类型
• 只能用在函数内部

package main

import (
	"fmt"
)

var x = 100

func main() {
	fmt.Println(&x, x) //全局变量
	x := "abc" //重新定义 赋值局部变量    
	fmt.Println(&x, x)
}

　　

简短模式并不总是重新定义变量，也可能是部分退化的赋值操作

package main

import (
	"fmt"
)

func main() {
	x := 100
	fmt.Println(&x, x)
	x, y := 200, "abc"
	fmt.Println(&x, x, y)
}

　　

输出

0xc04204e080 100
0xc04204e080 200 abc

　　

退化赋值的前提条件是至少一个变量被定义，必须同一作用域；不同作用域，全是新变量定义

package main

import (
	"fmt"
)

func main() {
	x := 100
	fmt.Println(&x, x)
	{
		x, y := 200, "abc"
		fmt.Println(&x, x, y)
	}

}

　　

输出结果两内存地址不一样

退化赋值的应用场景：在处理函数返回值时，重复定义err

package main

import (
	"os"
	"fmt"
)

func main() {
	f,err := os.Open("/root/test")
	b := make([]bytes,1024)
	n,err := f.Read(b)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(n)
}

　　

命名

变量首字母大小写决定了其作用域，首字母大写为导出成员，可被外包调用，小写仅能在包内使用

空标识符

‘_’ 特殊成员，通常作为忽略占位符使用，表达式左值，无法读取内容

常量

常量表示运行时恒定不可改变的值，通常是一些字面量；常量值必须是编译期可确定的字符、字符串、数字或布尔值，可指定常量类型

const (
	a, b int    = 10, 20
	s    string = "hello"
)

　　

枚举

go没有明确意义的enum定义，不过可以通过iota标识符实现一组自增常量值来实现枚举类型

const (
	a = iota  // 0
	b           // 1     
	c           // 2
)    

　　

基本类型

 别名

在官方的语言规范中，专门提到两个别名

byte  alias for uint8

rune  alias for int32

package main

import (
	"fmt"
)

func test(x byte) {
	fmt.Println(x)
}

func main() {
	var a byte = 0x11
	var b uint8 = a
	var c uint8 = a + b
	test(c)
} 

　　

引用类型

特指slice、map、slice这三种预定义类型，使用make函数创建（new也能为引用类型分配内存，但是不完整创建，字典为例，仅分配字典类型本身所需内存，没有分配键值存储内存）