GoLong的学习之路（一）语法之变量与常量

GoLang

go的诞生为了解决在21世纪多核和网络化环境越来越复杂的变成问题而发明的Go语言。
go语言是从Ken Thomepson发明的B语言和Dennis M.Ritchie发明的c语言逐步演化过来的，是c语言家族的成员（在我看来，其实现在大部分还在用的语言与c语言分不开）
Go语言有着和C语言类似的语法外表，和C语言一样是专业程序员的必备工具，可以用最小的代价获得最大的战果。

• 同时避免引入过度的复杂性。
• Go语言中和并发编程相关的特性是全新的也是有效的，同时对数据抽象和面向对象编程的支持也很灵活。
• Go语言同时还集成了自动垃圾收集技术用于更好地管理内存。（类似于java的JVM的回收机制）

Go语言还是一个开源的项目，可以免费获编译器、库、配套工具的源代码。

变量

关键字是指编程语言中预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。

Go语言中有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
1
2
3
4
5

Go语言中37个保留字:

Constants:    true  false  iota  nil

Types:   
int  int8  int16  int32  int64  
uint  uint8  uint16  uint32  uint64  uintptr
float32  float64  complex128  complex64
bool  byte  rune  string  error

Functions:   make  len  cap  new  append  copy  close  delete 
             complex  real  imag  panic  recover
1
2
3
4
5
6
7
8
9
10

程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量,所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。（方便计算机获取数据）

Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

var 变量名 变量类型

var name string
var age int
var isOk bool
1
2
3

批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

var (
    a string
    b int
    c bool
    d float32
)
1
2
3
4
5
6

变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值。

• 整型和浮点型变量的默认值为0
• 字符串变量的默认值为空字符串
• 布尔型变量默认为false
• 切片、函数、指针变量的默认为nil

变量初始化的标准格式：

var 变量名 类型 = 表达式

var age int = 18
var name, age = "Q1mi", 20
1
2

类型推导

有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var age = 18
1

短变量声明

在函数内部，可以使用更简略的 [ := ] 方式声明并初始化变量。

package main
//可放多个包
import ("fmt")
// 全局变量m
var m = 100

func main() {
	// 此处声明局部变量m
	n := 10
	m := 200 
	fmt.Println(m, n)
}
1
2
3
4
5
6
7
8
9
10
11
12

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线 _ 表示：

func foo() (int, string) {
	return 10, "你好"
}
func main() {
	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}
1
2
3
4
5
6
7
8
9

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意：

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. :=不能使用在函数外。
3. _多用于占位，表示忽略值。

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把 var 换成了const，常量在定义的时候必须赋值。

const A = 3.1415
const B = 2.715
1
2

声明了 A 和 B 这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

批量声明常量的时候，const同时声明多个常量，如果省略了值则表示和上面一行的值相同。（初始化后就一毛一样了）

func main() {
	const (
		n1 = 100
		n2
		n3
	)
	fmt.Println(n1, n2, n3)
}
1
2
3
4
5
6
7
8

iota（特殊）（需要重点记忆）

iota是go语言的常量计数器，只能在常量的表达式中使用。iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

应用在枚举情况是很有用的。

1. 枚举的特点就是不可变
2. 枚举变量中的值不能重复

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)
1
2
3
4
5
6

使用 _ 跳过某些值

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)
1
2
3
4
5
6

iota声明中间插队

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0
1
2
3
4
5
6
7

定义数量级：

const (
		_  = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)
1
2
3
4
5
6
7
8

多个iota定义在一行

func main() {
	const (
		a, b = iota + 1, iota + 2 //1,2
		c, d  // 2,3
		e, f  // 3,4
	)
}
1
2
3
4
5
6
7

学习自：李文周：博客