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

雨点打透心脏的1/2处 2023-10-10 21:16 56阅读 0赞

#### 文章目录 ####

*  一、前言
 *  二、变量
 *   *  1、变量的基础使用
     *  2、变量的多种使用方式
     *   *  1）全局变量
         *  2）局部变量
         *  3）丢弃赋值
     *  3、Go和Java的变量对比
 *  三、常量
 *   *  1、Go和Java的常量对比
 *  三、运算符
 *   *  1、算术运算符 ++、--
     *  2、运算符 &、\*
     *  3、运算符优先级
 *  四、总结

## 一、前言 ##

![在这里插入图片描述][26456da6bcf74d8ab70094e321fbd199.png]

Go系列文章：

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

**Go专栏传送链接：[https://blog.csdn.net/saintmm/category\_12326997.html][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中会报错：**  
![在这里插入图片描述][10f7b6598b194d0781de651a7f7a6479.png]

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

![在这里插入图片描述][378dc11ced8748389bd548b52557ac15.png]

### 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中常用的运算符如下：

![在这里插入图片描述][593751310f264d77889abfa3066a4398.png]

这里几乎和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，先计算乘法后计算加法，乘法运算符的优先级比加法运算符的优先级高。

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

![在这里插入图片描述][e22638da7f6d4b128bbacd6310b59eb5.png]

**总体来看：**

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

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

## 四、总结 ##

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

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

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

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

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

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

[26456da6bcf74d8ab70094e321fbd199.png]: https://img-blog.csdnimg.cn/26456da6bcf74d8ab70094e321fbd199.png
[GO_Java_Golang]: https://blog.csdn.net/Saintmm/article/details/130793052
[2 Go_Hello World]: https://blog.csdn.net/Saintmm/article/details/130799639
[3 Go_API]: https://blog.csdn.net/Saintmm/article/details/130819239
[https_blog.csdn.net_saintmm_category_12326997.html]: https://blog.csdn.net/saintmm/category_12326997.html
[10f7b6598b194d0781de651a7f7a6479.png]: https://img-blog.csdnimg.cn/10f7b6598b194d0781de651a7f7a6479.png
[378dc11ced8748389bd548b52557ac15.png]: https://img-blog.csdnimg.cn/378dc11ced8748389bd548b52557ac15.png
[593751310f264d77889abfa3066a4398.png]: https://img-blog.csdnimg.cn/593751310f264d77889abfa3066a4398.png
[e22638da7f6d4b128bbacd6310b59eb5.png]: https://img-blog.csdnimg.cn/e22638da7f6d4b128bbacd6310b59eb5.png