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，变量
变量是几乎所有编程语言中最基本的组成元素，变量是程序运行期间可以改变的量。
变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。
1）变量声明
Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明， Go语言引入了关键字var，而类型信息放在变量名之后，示例如下：
var v1 int var v2 int //一次定义多个变量 var v3, v4 int var ( v5 int v6 int )
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
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 //多重赋值
4）匿名变量
_, i, _, j := 1, 2, 3, 4 func test() (int, string) { return 250, "hi" } _, str := test()
3，常量
在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。
1）字面常量(常量值)
所谓字面常量（literal），是指程序中硬编码的常量，如：
123 3.1415 // 浮点类型的常量 3.2+12i // 复数类型的常量 true // 布尔类型的常量 "foo" // 字符串常量
2）常量定义
const Pi float64 = 3.14 const zero = 0.0 // 浮点常量, 自动推导类型 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, 常量不能修改
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 )
4，数据类型
类型 名称 长度 零值 说明 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字符串
1）布尔类型
var v1 bool v1 = true v2 := (1 == 2) // v2也会被推导为bool类型 //布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换 var b bool b = 1 // err, 编译错误 b = bool(1) // err, 编译错误
2）整型
var v1 int32 v1 = 123 v2 := 64 // v1将会被自动推导为int类型
3）浮点型
var f1 float32 f1 = 12 f2 := 12.0 // 如果不加小数点， fvalue2会被推导为整型而不是浮点型
4）字符类型
在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表utf-8字符串的单个字节的值；另一个是rune，代表单个unicode字符。
var ch1, ch2, ch3 byte ch1 = 'a' //字符赋值 ch2 = 97 //字符的ascii码赋值 ch3 = ' ' //转义字符 fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)
5）字符串
在Go语言中，字符串也是一种基本类型
package main import "fmt" func main() { var str string // 声明一个字符串变量 str = "abc" // 字符串赋值 ch := str[0] // 取字符串的第一个字符 fmt.Printf("str = %s, len = %d ", str, len(str)) //内置的函数len()来取字符串的长度 fmt.Printf("str[0] = %c, ch = %c ", str[0], ch) //`(反引号)括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。 str2 := `hello world 测试 ` fmt.Println("str2 = ", str2) }
5，fmt包的格式化输出输入
1）格式说明
格式 含义 %% 一个%字面量 %b 一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 %c 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 %d 一个十进制数值(基数为10) %e 以科学记数法e表示的浮点数或者复数值 %E 以科学记数法E表示的浮点数或者复数值 %f 以标准记数法表示的浮点数或者复数值 %g 以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 %G 以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 %o 一个以八进制表示的数字(基数为8) %p 以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 %q 使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 %s 字符串。输出字符串中的字符直至字符串中的空字符（字符串以' ‘结尾，这个'0'即空字符） %t 以true或者false输出的布尔值 %T 使用Go语法输出的值的类型 %U 一个用Unicode表示法表示的整型码点，默认值为4个数字字符 %v 使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话 %x 以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 %X 以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示
2）输出
//整型 a := 15 fmt.Printf("a = %b ", a) //a = 1111 fmt.Printf("%% ") //只输出一个% //字符 ch := 'a' fmt.Printf("ch = %c, %c ", ch, 97) //a, a //浮点型 f := 3.14 fmt.Printf("f = %f, %g ", f, f) //f = 3.140000, 3.14 fmt.Printf("f type = %T ", f) //f type = float64 //复数类型 v := complex(3.2, 12) fmt.Printf("v = %f, %g ", v, v) //v = (3.200000+12.000000i), (3.2+12i) fmt.Printf("v type = %T ", v) //v type = complex128 //布尔类型 fmt.Printf("%t, %t ", true, false) //true, false //字符串 str := "hello go" fmt.Printf("str = %s ", str) //str = hello go
3）输入
var v int fmt.Println("请输入一个整型：") fmt.Scanf("%d", &v) //fmt.Scan(&v) fmt.Println("v = ", v)
6，类型转换
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。
var ch byte = 97 //var a int = ch //err var a int = int(ch)
7，类型别名
type bigint int64 //int64类型改名为bigint var x bigint = 100 type ( myint int //int改名为myint mystr string //string改名为mystr )
黑马程序员