【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"funcmain(){// 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 =100var globalV2 =1.11funcmain(){variable1()//variable2()}funcvariable1(){
    fmt.Println(globalV1)
    fmt.Println(globalV2)}funcvariable2(){
    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丢弃 只取3var_,_,num =1,2,3fmt.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修饰符 常量类型 常量名 = 常量值；publicstaticfinalString 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"funcmain(){var age int=18
    fmt.Println("age对应的存储空间内存地址为：",&age)// 指针变量 ptr，指向age在存储空间的内存地址var ptr *int=&age
    fmt.Println(ptr)
    fmt.Println("ptr这个指针指向的具体数值为：",*ptr)}

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

四、总结

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

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

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

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

Go的算术运算符

++

、

--

不能像Java一样用于复杂运算中，只能做最简单的使用。

并且Go的

&

和

*

有特殊用意。