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

news2024/11/19 6:21:16

文章目录

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

一、前言

在这里插入图片描述

Go系列文章：

GO开篇：手握Java走进Golang的世界
2 Go开发环境搭建、Hello World程序运行
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的变量对比

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

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

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

Java的变量声明需要指定变量的数据类型；Go的变量声明可以不指定变量的数据类型（类型自动推断）
```
// go类型自动推断
var v3 = "saint"
```
Java方法内外变量赋值只能使用=；Go的变量声明赋值在函数内部可以缩写（变量名 := 变量值），函数外只能用var 变量名 = 变量值
```
// 函数内部可以直接使用 【 变量名 := 变量值 】 赋值，函数外不可以
name := "saint"
```
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跑起来后赋值的）后就不能修改的量。

常量声明方式不同；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)
}