Go语言基础语法（一）：变量的声明与赋值

四种声明

变量声明

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

声明变量的一般形式是使用 var 关键字：

var name type

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。

需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b; 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：

var a, b *int

Go语言的基本类型有：

bool
string
int、int8、int16、int32、int64
uint、uint8、uint16、uint32、uint64、uintptr
byte // uint8 的别名
rune // int32 的别名代表一个 Unicode 码
float32、float64
complex64、complex128

当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的。

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写，例如：numShips 和 startDate 。

变量声明的几种形式

//声明变量1: var 变量名(驼峰命名法) 数据类型 = 数据值
var name string = "pw"


//声明变量2: var(一组变量)
var (
        age   int
        phone string
    )


//声明变量3：(短声明变量) 变量名 := 初始值

//关于短声明变量：
1.短声明变量会根据初始值自动推导数据类型
2.短声明变量常用于函数内部的局部变量
3.全局变量只能通过var声明，不能使用短声明
sex := "男"

//和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：
a,s:=1, "abc"

变量初始化的标准格式

var 变量名类型 = 表达式

例如，游戏中，玩家的血量初始值为100。可以这样写：

var hp int = 100

这句代码中，hp 为变量名，类型为 int，hp 的初始值为 100。

上面代码中，100 和 int 同为 int 类型，int 可以认为是冗余信息，因此可以进一步简化初始化的写法。

编译器推导类型的格式

在标准格式的基础上，将 int 省略后，编译器会尝试根据等号右边的表达式推导 hp 变量的类型。

var hp = 100

等号右边的部分在编译原理里被称做右值（rvalue）。

下面是编译器根据右值推导变量类型完成初始化的例子。

package main

import "fmt"

func main() {
	var attack = 40
	var defence = 20
	var damageRate float32 = 0.17
	var damage = float32(attack-defence) * damageRate
	fmt.Println(damage)
}

代码说明如下：

第 1 和 2 行，右值为整型，attack 和 defence 变量的类型为 int。
第 3 行，表达式的右值中使用了 0.17。由于Go语言和C语言一样，编译器会尽量提高精确度，以避免计算中的精度损失。所以这里如果不指定 damageRate 变量的类型，Go语言编译器会将 damageRate 类型推导为 float64，我们这里不需要 float64 的精度，所以需要强制指定类型为 float32。
第 4 行，将 attack 和 defence 相减后的数值结果依然为整型，使用 float32() 将结果转换为 float32 类型，再与 float32 类型的 damageRate 相乘后，damage 类型也是 float32 类型。
提示：damage 变量的右值是一个复杂的表达式，整个过程既有 attack 和 defence 的运算还有强制类型转换。强制类型转换会在后面的章节中介绍。
第 5 行，输出 damage 的值。

以上代码输出结果为：

短变量声明并初始化

var 的变量声明还有一种更为精简的写法，例如：

hp := 100

这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。

注意：由于使用了:=，而不是赋值的=，因此推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

如果 hp 已经被声明过，但依然使用:=时编译器会报错，如下：

意思是，在“:=”的左边没有新变量出现，意思就是“:=”的左边变量已经被声明了。

短变量声明的形式在开发中的例子较多，比如：

conn, err := net.Dial("tcp","127.0.0.1:8080")

net.Dial 提供按指定协议和地址发起网络连接，这个函数有两个返回值，一个是连接对象（conn），一个是错误对象（err）。如果是标准格式将会变成：


var conn net.Conn
var err error
conn, err = net.Dial("tcp", "127.0.0.1:8080")

因此，短变量声明并初始化的格式在开发中使用比较普遍。

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错，代码如下：

conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn2, err := net.Dial("tcp", "127.0.0.1:8080")

上面的代码片段，编译器不会报 err 重复定义。

多个变量同时赋值

编程最简单的算法之一，莫过于变量交换。交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下：

var a int = 100
var b int = 200
var t int

t = a
a = b
b = t

fmt.Println(a, b)

在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量：

var a int = 100
var b int = 200
a = a ^ b
b = b ^ a
a = a ^ b
fmt.Println(a, b)

到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。使用 Go 的“多重赋值”特性，可以轻松完成变量交换的任务：

var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)

常量的声明

1.const的使用

与其他语言一样 const代表常量不能修改

注意：Go语言中浮点型有float32和float64 不存在double和float

const pi float32 = 3.1415926
    const (
        p1 = 1
        p2 = 2
        p3 = 3
    )

2.关于const的无类型常量

正常情况下常量可以是任何基本数据类型(如int或float64)，

也包括具名的基本类型(如time.Duration)

但是许多常量并不属于某一个具体的类型，此时这些常量属于：从属类型待定的常量

从属类型待定的常量有6种：

无类型布尔、无类型整数、无类型文字符合、无类型浮点数、无类型复数、无类型字符串

且：这些常量比基础类型的数字精度更高，且算术精度高于原生的机器密度。可以认为它们的精度至少达到256位

关于无类型常量的作用：

1.暂时维持更高的精度

2.用于更多的表达式而不需要转换类型

例如：

    const zib = 1180591620717411303424
    const yib = 1208925819614629174706176
    fmt.Println(zib)

很明显变量zib和yib的精度超过了基本数据类型，所以在输出时会报错

但是zib和yib的数据依旧会完整的存储并能进行运算

const zib = 1180591620717411303424
const yib = 1208925819614629174706176
fmt.Println(yib / zib)

类型的声明

type主要用于声明新的数据类型

例如当姓名name和密码password都使用string时在大型开发中可能会混乱

此时可以使用type将二者区分成不同名字的类型但他们的底层都是string的底层

type Name string
type Password string
var name Name = "pw"
var password Password = "123456"

函数的声明

func 函数名 (参数列表parameter-list) 返回值列表result-list{

}

注意点：

1.在接收返回值时，如果返回值列表中有一个或者多个不需要时，可以使用_接收

func text_func(a, b int) (x, y int) {
    return a, b
}


func main() {
 
    a, _ := text_func(1, 2)
    fmt.Println(a)
}

2.函数主体的大括号{函数主体} 其中左半边括号必须和函数名同行，这是因为go语言编译器会主动把特定符号后的换行符转换为分号

//正确函数样式
func text_func(a, b int) (x, y int) {
    return a, b
}
 
//错误函数样式 这种情况会报错
func text_funcx(a, b int) (x, y int) 
{
    return a, b
}

匿名变量（没有名字的变量）

在Go语言中，匿名变量（通常表示为 `_`，下划线）是一种特殊的变量，它用于忽略函数返回值中的某个部分，当你不关心某个返回值时，可以使用匿名变量来避免编译器警告关于未使用的变量。但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。下面是使用匿名变量的例子：

//示例1：忽略不需要的返回值
假设有一个函数返回两个值，但我们只关心其中一个。
//函数声明，其中(quotient int, remainder int)表示返回值类型
func divideAndRemainder(x, y int) (quotient int, remainder int) {
    return x / y, x % y
}

func main() {
    _, remainder := divideAndRemainder(10, 3)
    fmt.Println("Remainder:", remainder)
}
在这个例子中，我们调用 `divideAndRemainder` 函数，
但只关心余数，所以将商的返回值用匿名变量 `_` 忽略。

参考文章：Go语言的四种声明_go double-CSDN博客