（二）go之变量 常量

变量 常量

无论什么代码，里面要么是数据，那么就是逻辑，数据在内存中的地址难以记忆，而变量名方便记忆。

变量名本身也有内存地址，但是我们不关心，也用不到，我们只关心数据是什么。

用变量名找到数据的过程由编译器帮我们维护着二者的地址映射，我们只需关心变量名即可。

数据用变量名牵着，业务逻辑用函数名或类名牵着，以便反复使用。

go中变量声明之后必须使用，不使用就会报错，不用会浪费内存。

声明之后不赋值会给与默认值

go中变量的变量类型不是必须声明有自动推导机制，但是转化为二进制后是一定要有变量类型的。

因为编译之后，编译器知道了你的程序是如何搭建的，就会在内存中开辟连续的内存来存放数据。

例如int类型的数据一段连续内存，string一段连续内存。

而python不需要声明变量类型，程序运行时就要从整个内存中去找此数据，而go有了变量类型之后只需要在一段小的连续内存中找到数据，速度比python快。

方式一：var  变量名  变量类型

var b int 

b=100 变量声明和赋值分开

var b int =100合并

方式二：var (

a string

b int

c bool

)批量声明，可以少写许多var

静态语言声明类型，这样内存上一段区域专门放此类型的变量，动态语言就是全内存扫描找变量，静态语言扫描的范围更小。

方式三：var name = "zhangsan"会自动推导，不用声明变量类型。

但是不是所有的都能推导出来，例如函数返回值是自定义类型时，要手动声明

方式四：短变量声明，不能放到全局 ，：=只能放局部。

func main(){

a :=100//自动推断a的类型

}

匿名变量

多重赋值的时候，某个变量不需要，想忽略掉，则用_接收即可

func test()(int,string){

    return 100,"123"  
}

　可以返回多值

a,b = test()//但是后面，a用不到，就会报错

接收的时候例如100不想要

就 _,num = test()

常量

不变的量，且定义的时候必须赋值，关键字用const即可。

iota

用此关键字实现枚举，只能在枚举里面使用。

const （

n1 = iota //0

n2//1

n3//2 自动递增

_//跳过

n4//4

）

关键点：

1：出现const关键字，iota置0.

2：const中每增加一行，iota增加1.

3：_可以跳过某些值。

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

　

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)

　　

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0

　　

const (
        a, b = iota + 1, iota + 2 //1,2
        c, d                      //2,3
        e, f                      //3,4
    )

const (
        _  = iota //0
        KB = 1 << (10 * iota)
        MB = 1 << (10 * iota)
        GB = 1 << (10 * iota)
        TB = 1 << (10 * iota)
        PB = 1 << (10 * iota)
    )

 

注意

go中语句没有python那么随意，不允许将语句放在函数之外。

赋值语句，++  -- 都是语句，不能独立于方法之外。

var  a  int 
a=100//这是语句，尽管赋值不允许放在函数外，会报错
//但是可以var a int =100声明和赋值放一起是可以的

func test(){
   fmt.Println(a)
}