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

文章目录

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

一、前言

在这里插入图片描述

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中会报错:
【30天熟悉Go语言】4 Go的变量、常量、运算符_第1张图片

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

在这里插入图片描述

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

【30天熟悉Go语言】4 Go的变量、常量、运算符_第2张图片

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

常用运算符的优先级见下表(第一列优先级值越大,表示优先级越高):

【30天熟悉Go语言】4 Go的变量、常量、运算符_第3张图片

总体来看:

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

万能措施:为了提高优先级,可以加()

四、总结

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

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

此外,针对常量,Java和Go的认知不同:

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

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

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

你可能感兴趣的:(#,30天熟悉GO语言,golang)