02-Go语言基础变量和常量

标识符与关键字

标识符

在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名，常量名，函数名等等。Go语言中标识符由字母数字和_组成，并且只能以字母和_开头。举几个例子：abc,_,_123。

关键字

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

变量

变量的类型

常见的数据类型有：整型，浮点型，布尔型。

变量的声明

go语言中变量必须先声明才能使用。而且声明后，必须使用。

标准声明

var 变量名 变量类型

批量声明

var (
		v3 int
		v4 float32
		v5 string
		v6 bool
	)

变量初始化

GO语言在声明变量的时候，会自动对变量进行初始化。每个变量会被初始化成其类型的默认值。例如：整型和浮点型初始值为0.字符串变量的默认值为空字符串。布尔型变量默认为false.切片，函数，指针变量的默认值为nil

声明并赋值

  var v7 int = 68
	var v8 string = "wanglei"
	var (
		v9  bool    = true
		v10 float32 = 3.32
	)
	fmt.Printf("v7:%d\nv8:%v\nv9:%v\nv10:%f", v7, v8, v9, v10)

类型推导

有时候将变量类型省略，编译器会根据等号右边值类型来推断变量类型

//类型推导
	var v11, v12 = "wl", 26
	fmt.Println(v11, v12)

短变量赋值

在函数内部可以使用更简洁的:=来声明赋值变量，但是仅仅限于函数内部。

package main

import (
	"fmt"
)
// 全局变量m
var m = 100

func main() {
	n := 10
	m := 200 // 此处声明局部变量m
	fmt.Println(m, n)
}

匿名变量

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

//匿名变量
	v16, _ := 23, "string"
	fmt.Println(v16)

完整练习代码

package main

import "fmt"

var version string
var age11 = 18

// name12 := "小王子"  // 函数外语句必须以关键字开头

func main() {
	fmt.Println("Hello world!")

	/*
		多行注释
	*/
	// 变量的声明
	var name string // 声明变量

	// 批量声明
	var (
		age  int  // 0
		isOk bool // false
	)
	// var age int
	// var isOk bool

	age = 100 // 变量赋值
	fmt.Println(name, age, isOk)

	var age2 int = 18 // 声明变量并赋值
	fmt.Println(age2)

	// 没有指定类型？
	var name3, age3 = "jade", 28

	// var (
	// 	name3 string = "jade"
	// 	age3 int = 28
	// )

	fmt.Println(name3, age3)

	var age4 int8 = 28 // 如果不想用编译器推导的类型，就需要显式指定变量的类型
	fmt.Println(age4)

	// 双引号表示字符串，单引号表示字符

	var x byte = 'a'   // 字符
	var s string = "a" // 字符串
	fmt.Println(x, s)

	// 短变量声明
	s2 := "jade" // var s2 string s2="jade"
	fmt.Println(s2)
	s2 = "小王子"
	fmt.Println(s2)

	// var x2 string
	// x2 = 18 // 只能给变量赋正确类型的值
	// fmt.Println(x2)
}

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量在定义时必须赋值。

常量声明

package main

import "fmt"

func f2() {
	const c1 = 3.1415
	const c2 = 2.78
	//批量定义
	const (
		c3 = 100
		c4 //如果省略了，那么都和上面值一样
		c5
	)
	fmt.Println(c1, c2, c3, c4, c5)
}

Iota

iota是go语言的常量计数器，只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

使用_跳过某些值：

func f3() {
	//使用_跳过某些值
	const (
		c1 = iota //0
		c2        //1
		_
		c4 //3
	)
	fmt.Println(c4)
}

iota声明中间插队:

//iota插队
func f4() {
	const (
		c1 = iota //0
		c2 = 100  //100
		c3 = iota //2
		c4        //3
	)
	fmt.Println(c4)

}

定义数量级：

func f5() {
	const (
		_  = iota
		KB = 1 << (10 * iota) //<<向左偏移 eg:1<<10=2^10
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)
	fmt.Println(KB, MB, GB, TB, PB)
}

多个iota定义一行：

//多个iota定义在一起

func f6() {
	const (
		c1, c2 = iota + 1, iota + 2 //1,2
		c3, c4                      //2,3
		c5, c6                      //3,4
	)
	fmt.Println(c3, c4, c5, c6)
}

完整练习代码

// const.go

package main

const pi = 3.14

const (
	v = "v1.0"
	v2
	v3
	v4
)

const (
	week1 = 1
	week2 = 2
	week3 = 3
)

const (
	n1 = iota // 0
	n2        // 1
	n3
	n4
	n5
)

const (
	z1 = iota // 0
)

// 利用iota声明存储的单位常量
const (
	_  = iota             // 0
	KB = 1 << (10 * iota) // 1<<10 <=> 10000000000
	MB = 1 << (10 * iota) // 1<<20
	GB = 1 << (10 * iota) // 1<<30
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)

// 声明中插队
const (
	c1 = iota // 0
	c2        // 1
	c3 = 100  // 插队
	c4 = iota // 3
)

const (
	d1, d2 = iota + 1, iota + 2 // 1,2
	d3, d4 = iota + 1, iota + 2 // 2,3
)