Golang变量和常量

avatar 2020年4月10日18:08:16 评论 1,459 次浏览

为什么要有变量，因为要存储的值需要写到内存中，等需要的时候直接调用这个值，方便快捷。不需要每次都创建，如果需要的这个值经常用到，就需要放在经常用到的位置，让更多的函数用到，这就叫常量。变量原本没有任何的数据类型，只有根据变量的值，来判断变量是属于什么数据类型。这个值可能是字符串，可能是整数，也可能是浮点数等。这个值是存储在内存中的，如果想获取这个值，需要使用变量名指引到内存中的值，数据类型和变量名没有关系，有关系的是变量指引的值，这就是我们常说的变量赋值。

变量

变量的值是有变量指引到内存地址，获取到内存地址中的值，我们就可以打印变量时获取到内存中存储的值了，多个变量名可以对应一个变量值，不过值是唯一的。变量和值的关系我们可以理解为变量赋值。变量的赋值方法有，直接赋值，先声明数据类型在进行赋值，同一数据类型多个变量进行赋值等等。我们先看看变量值的数据类型有哪些?

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

变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。申明变量的一般形式是使用var关键字：

var identifier type

一次可以申明多个变量：

var identifier1, identifier2 type

例如：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    var a string = "Go"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

结果：

Go
1 2

变量分类

变量分为局部变量和全局变量，简单的说就是在函数外边的就是全局变量，在函数里的就是局部变量，局部变量只能供函数内部使用。针对局部变量和全局变量写一个程序，在函数调用变量的时候，先调用局部变量，后调用全局变量。下面看看例子：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
var a string = "Golang"
func main() {
    var a string = "Go"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
}

这里定义了两个变量，一个局部变量(Go)，一个全局变量(Golang)，如果直接执行程序一定打印的是Go，因为是局部变量，如果把局部变量注释掉会打印什么，可以试试看。

变量声明

1、指定的变量没有初始化，变量默认为零值。

语法：

var v_name v_type
v_name = value

零值就是变量没有初始化时系统默认设置的值。

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    var a = "Golang" //申明的变量进行了初始化
    fmt.Println(a)
    var b int     //申明的变量没有初始化
    fmt.Println(b)
    var c bool //申明布尔值的变量没有初始化默认为false
    fmt.Println(c)
}

结果：

Golang
0
false

根据不同的数据类型初始化值不一样，一下总结了一些：

* 数值类型（包括complex64/128）为 0
* 布尔类型为 false
* 字符串为 ""（空字符串）

以下几种类型为 nil：

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

2、根据变量自行判定变量类型。

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    var d = true     //值是什么类型就定义的什么类型
    fmt.Println(d)
}

结果：

true

3、省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

v_name := value

举例：

var a int 
// 吴老二 个人博客地址 http://www.wulaoer.org
a :=1 // 这时候会产生编译错误，因为前面初始化了a，a :=1就等于var a = 1
正确的方式是：
a := 1 //不需要前面的var a int

多个变量可以这样写：

a,b,c := 1,2,3 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句,相当于a,b,c = 1,2,3,而不是a=1,b=2,c=3

举例：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    a,b := 1,"hello"
    fmt.Println(a)
}

就会报错

a declared and not used

如果输出两个变量

fmt.Println(a,b)

结果为：

1 2

4、多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
// 吴老二 个人博客地址 http://www.wulaoer.org
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

举例：

package main
// 吴老二 个人博客地址 http://www.wulaoer.org
var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为：

0 0 0 false 1 2 123 hello 123 hello

值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：

当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：

你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。值类型的变量的值存储在栈中。

内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。

更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。

一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。

这个内存地址为称之为指针，这个指针实际上也被存在另外的某一个字中。

同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。

当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。

如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。

简短形式，使用 := 赋值操作符

我们知道可以在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此我们可以将它们简写为 a := 50 或 b := false。

a 和 b 的类型（int 和 bool）将由编译器自动推断。

这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。

注意事项

如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。

如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

尝试编译这段代码将得到错误 a declared and not used。此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用

fmt.Println("hello, world", a)

会移除错误。但是全局变量是允许声明但不使用。 同一类型的多个变量可以声明在同一行，如：

var a, b, c int

多变量可以在同一行进行赋值，如：

var a, b int
var c string
a, b, c = 5, 7, "abc"

上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用：

a, b, c := 5, 7, "abc"
右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 "abc"。
这被称为 并行 或 同时 赋值。
如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。
空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。

常量

前面已经说了变量分为全局变量和局部变量，那么常量是属于全局变量还是数据局部变量呢？先不说，看看变量的定义：变量来源于数学，是计算机语言中能存储计算结果或能表示值抽象概念。如果不理解，没关系，可以看看下面，我们使用例子来证明

常量类型只可以是布尔类型、数字类型(整数型、浮点型和复数)和字符串。

常量的格式：

const identifier [type] = value

这里可以省略类型[type]，因为编译器会根据变量的值来推断变量类型。

* 显示类型：  const b string = "abc"
* 隐藏类型：  const b = "abc"

如果有多个相同类型的声明可以简写成：

const c_name1, c_name2, c_name3 = value1, value2, value3

下面举例说明一下：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
    const LENGTE int = 30     //声明变量LENGTE,相当于const LENGTE = 30
    const WIDTH int = 5       //声明变量WIDTH，相当于const WIDTH = 5 
    var area int              //声明area的数据类型，如果这里不声明变量，后面就是不能使用
    const a,b,c = 1,false,"str" //多重赋值
    area = LENGTE * WIDTH       //变量运算得到一个全新的变量
    fmt.Printf("面积: %d",area)  //打印运算后得到的变量
    println()                   //打印空行，进行分割
    println(a,b,c)              //打印定义的多重变量
}

打印结果：

面积: 150
1 false str

也可以使用常量做枚举：

package main
import "unsafe"
// 吴老二 个人博客地址 http://www.wulaoer.org
const (
	a = "wolf27w" 
	b = len(a)  //计算长度
	c = unsafe.Sizeof(a) //unsafe.Sizeof()计算表达式的值
	)
func main() {
	println(a,b,c)     //这里没有导入fmt函数，所以可以直接使用println打印
}

打印结果：

wolf27w 7 16

iota

iota是一个特殊的常量，可以认为是被编译器修改的常量。iota在const关键字出现时，将被重置为0(在const内部的第一行之前,也就是第一行），const中每新增一行常量什么就使iota计数一次(iota可理解为const语句中块的行索引)

iota也可以用作枚举：

const (
	a = iota
	b = iota
	c = iota
	)

第一行a=iota，a的值就是0,新增一行b的值就自动加1等于2，c就等于3，形式如下：

package main
import “fmt”
// 吴老二 个人博客地址 http://www.wulaoer.org
func main() {
	const (
			a = iota    //第一行值为0
			b           //自动加1
			c           //自动加1 
			d = "ha"    //申明的独立值
			e           // "ha" ioya += 1
			f = 100     //iota += 1
			g           //100 iota += 1
			h = iota    //7 恢复计数
			i           //8 
		)
	fmt.Println(a,b,c,d,e,f,g,h,i)
}

打印结果：

0 1 2 ha ha 100 100 7 8

下面看一下例子：

package main
import "fmt"
// 吴老二 个人博客地址 http://www.wulaoer.org
const (
	i=2<<iota   //表示二进制左移1位，010
	j=3<<iota   //表示二进制左移2位，110
	k           //表示二进制左移3位，1100
	l           //表示二进制左移4位，11000
)
func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

打印结果：

i= 1
j= 6
k= 12
l= 24

注释：iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

* i=1：左移 0 位,不变仍为 1;
* j=3：左移 1 位,变为二进制 110, 即 6;
* k=3：左移 2 位,变为二进制 1100, 即 12;
* l=3：左移 3 位,变为二进制 11000,即 24。

以上就是对Golang的诠释，有部分参考了菜鸟教程，很多东西需要沉淀一下，不是画完了就完事了，下个章节就是Golang的判断和循环了，算是真正进去Golang的学习。

avatar

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: