【30天熟悉Go语言】4 Go的变量、常量、运算符

一、前言

Go系列文章：

1. GO开篇：手握Java走进Golang的世界
2. 2 Go开发环境搭建、Hello World程序运行
3. 3 Go编程规约和API包

Go专栏传送链接：https://blog.csdn.net/saintmm/category_12326997.html

二、变量

变量相当于内存中一个数据存储空间的标识。

1、变量的基础使用

变量的使用分三步：声明、赋值、使用。

• 变量的声明 采用 var 变量名 数据类型的形式。

package main

import "fmt"

func main() {
	// 1. 变量的声明
	var age int
	// 2. 变量的赋值
	age = 18
	// 3. 变量的使用
	fmt.Println("age = ", age)
}

变量的声明和赋值可以合成一句：

var age int = 19

如果变量重复定义，GoLand中会报错：

变量赋值时，数据与类型不匹配，报错如下：

2、变量的多种使用方式

1）全局变量

全局变量是定义在函数外的变量，可以被多个函数使用。

package main

import "fmt"

var globalV1 = 100
var globalV2 = 1.11

func main() {
	variable1()
	//variable2()
}

func variable1() {
	fmt.Println(globalV1)
	fmt.Println(globalV2)
}

func variable2() {
	fmt.Println(globalV1)
	fmt.Println(globalV2)
}

如果存在多个全局变量，每次都要用var来声明，太麻烦了；所以Go支持一次性声明多个不用类型的变量；

var (
	globalV1= 3.33
	globalV2= "Hello"
)

2）局部变量

局部变量是声明在函数{}中的变量；

1> 指定变量的类型 并 赋值：

var v1 int = 18
fmt.Println(v1)

2> 指定变量的类型，但是不赋值，使用默认值：

var v2 int
fmt.Println(v2)

3> 不写变量的类型，程序会自动根据 = 号后面的值判断变量的类型（自动类型推断）：

var v3 = "saint"
fmt.Println(v3)

4> 可以使用:= 代替 var，进行变量的声明赋值：

v4 := "bob"
fmt.Println(v4)

5> 声明多个相同类型的变量：

var n1, n2, n3 int
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)

6> 声明多个不同类型的变量：

var n4, name, n5 = 9, "jack", 7.8
fmt.Println(n4)
fmt.Println(name)
fmt.Println(n5)

// 省略var的方式
n6, sex := 6.9, "man"
fmt.Println(n6)
fmt.Println(sex)

3）丢弃赋值

使用标识符_接收值，可以丢弃赋值；

丢弃赋值必须在一次取两个及以上的值的场景下，又不想要其中一个值的时候使用。

var _,_,num = 1,2,3
fmt.Println("num = ",num)

代码片段中将只会接受到3这个值，并将其赋值给num变量。

3、Go和Java的变量对比

1. 变量声明赋值方式不同；Java是变量类型 变量名 = 变量值、Go是var 变量名 变量类型 = 变量值

   // Java 变量类型  变量名 = 变量值
   String name = "li_ming";
   

   // Go var  变量名  变量类型 = 变量值
   var name string = "li_ming"
   

2. Java的变量声明需要指定变量的数据类型；Go的变量声明可以不指定变量的数据类型（类型自动推断）

   // go类型自动推断
   var v3 = "saint"
   

3. Java方法内外变量赋值只能使用=；Go的变量声明赋值在函数内部可以缩写（变量名 := 变量值），函数外只能用var 变量名 = 变量值

   // 函数内部可以直接使用 【 变量名 := 变量值 】 赋值，函数外不可以
   name := "saint"
   

4. Go支持多变量同时赋值，丢失赋值（使用标识符_接收值，可以丢弃赋值，但必须在一次取两个及以上的值的场景下，又不想要其中一个值的时候使用）

   // 多变量同时赋值
   var name,age = "saint",18
   

   // 丢弃赋值，示例中：把 1和2丢弃 只取3
   var _,_,num = 1,2,3
   fmt.Println("num = ",num)
   

三、常量

Go的常量和变量声明的唯一区别在于：常量声明使用const、变量声明使用var。如果大家写过一段时间的前端，会发现Go的常量和变量声明和前端比较像。

//const  常量名  常量类型 = 常量值   显示推断类型
const name string = "const_sanint"
//隐式推断类型
const name2 ="const_sanint2"

1、Go和Java的常量对比

Go中的常量和Java中的常量含义有一个本质的区别：

• Go中的常量是指在编译期间就能确定的量；而Java中的常量是指被赋值一次（JVM跑起来后赋值的）后就不能修改的量。

1. 常量声明方式不同；Java是final修饰符 常量类型 常量名 = 常量值，Go是const 常量名 常量类型 = 常量值

   // Java final修饰符   常量类型   常量名 =  常量值；
   public static final String TAG = "A";
   

   // go const  常量名  常量类型 = 常量值   显示推断类型
   const name string = "const_li_ming"
   // go 隐式推断类型
   const name2 ="const_xiao_hong"
   

三、运算符

运算符是—种特殊的符号，用以表示数据的运算、赋值和比较等 。Go中常用的运算符如下：

这里几乎和Java语言的使用方式，这里针对算术运算符中的++、--和其他运算符做一些解释说明。

1、算术运算符 ++、–

++ 自增 加1操作，–自减，减1操作。

var a int = 10
a++
fmt.Println(a)
a--
fmt.Println(a)

和Java不同的点：

• Go中，++，-- 操作非常简单，只能单独使用，不能参与到运算中去，比如：age = ++age + 10，这种复杂运算是不允许的。
• Go中，++，-- 只能在变量的后面，不能写在变量的前面（--a ++a都是错误的写法）

2、运算符 &、*

在Go中 & 和 * 有特殊的用意：

• & ：返回变量的存储地址
• *：取指针变量对应的数值

package main

import "fmt"

func main() {
	var age int = 18
	fmt.Println("age对应的存储空间内存地址为：",&age)

	// 指针变量 ptr，指向age在存储空间的内存地址
	var ptr *int = &age
	fmt.Println(ptr)
	fmt.Println("ptr这个指针指向的具体数值为：",*ptr)
}

指针的内容见后面的文章。

3、运算符优先级

优先级指：当多个运算符出现在同一个表达式中时，先执行哪个运算符。

• 比如：a + b * c，先计算乘法后计算加法，乘法运算符的优先级比加法运算符的优先级高。

常用运算符的优先级见下表（第一列优先级值越大，表示优先级越高）：

总体来看：

• 单目运算符 > 算术运算符 > 位移运算符 > 关系运算符 > 位运算符 > 逻辑运算符 > 赋值运算符

万能措施：为了提高优先级，可以加（）

四、总结

针对变量/常量的声明赋值，和Java相比，Go有一些特有的性质：

1. 支持同时声明多个不同类型的变量/常量；
2. 支持类型自动推断
3. 支持丢弃赋值。

此外，针对常量，Java和Go的认知不同：

• Java认为JVM跑起来之后，常量值被赋值了一次，后面不允许再更改。
• 而Go的常量则是在编译期就能确定的量，同样不允许修改。

Go的算术运算符++、-- 不能像Java一样用于复杂运算中，只能做最简单的使用。

并且Go的& 和 * 有特殊用意。