Go语言--＞变量

Go语言–>变量

在 Go 语言中，定义变量有几种常见的方式。下面是一些常见的语法和用法：

1. 使用 var 关键字定义变量

最常见的方式是使用 var 关键字，后面跟上变量名和类型。你也可以为变量赋初值。

基本格式：

var variableName type

示例：

在go语言中定义了一个变量，指定变量类型，如果没有初始化，则变量默认为零值。零值就是变量没有做初始化时系统默认设置的值。

var age int // 定义一个整数类型的变量 age
var name string // 定义一个字符串类型的变量 name

也可以在定义时给变量赋初值：

var age int = 30 // 定义变量并赋初值
var name string = "Alice" // 定义变量并赋初值

使用类型推断：

如果你给变量赋了初值，Go 可以自动推断出变量的类型（类型推断）。这种情况下，你可以省略类型。

var age = 30 // Go 自动推断 age 为 int 类型
var name = "Alice" // Go 自动推断 name 为 string 类型

2. 短变量声明 :=

Go 还提供了一个简洁的方式来声明和初始化变量，叫做短变量声明。它通常在函数内部使用，省略了 var 关键字，自动根据初始值推断变量的类型。

基本格式：

variableName := value

当我们定义一个变量后又使用该符号初始化变量，就会产生编译错误，因为该符号其实是一个声明语句
也就是说intVal := 1相等于：

var intVal int 
intVal =1 

示例：

age := 30 // 自动推断 age 为 int 类型
name := "Alice" // 自动推断 name 为 string 类型

注意：短变量声明只能在函数内部使用，不能在函数外部使用。

3. 声明常量 const

常量的值在编译时就已经确定，不会改变。常量通过 const 关键字声明。

基本格式：

const constantName type = value

示例：

const pi float64 = 3.14159 // 定义一个浮动常量 pi
const message = "Hello, World!" // 定义一个字符串常量 message，Go 会自动推断类型为 string

4. 多个变量声明

Go 允许你在一行中声明多个变量，可以使用 var 关键字或者短变量声明。

使用 var 声明多个变量：

var a, b, c int // 声明多个 int 类型的变量

使用短变量声明：

a, b, c := 1, 2, 3 // 声明多个变量并初始化

5. 全局变量和局部变量

• 全局变量：在函数外部声明的变量是全局变量，在整个包内都能访问。

函数外定义的变量为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，甚至可以使用import引入外部包来使用。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

• 局部变量：在函数内部声明的变量是局部变量，只能在该函数内使用。

示例：

package main

import "fmt"

var globalVar = 100 // 全局变量

func main() {
    var localVar = 50 // 局部变量
    fmt.Println(globalVar)
    fmt.Println(localVar)
}

6 匿名变量

匿名变量使用 下划线 _ 来表示，它不能用作变量的名称，不能直接访问或修改其值。Go 语言在使用匿名变量时，会自动丢弃对应的值。

示例：

package main

import "fmt"

func main() {
    a, _ := 10, 20  // 忽略第二个返回值
    fmt.Println(a)   // 只打印 10
}

匿名变量在以下几种常见场景中很有用：

1) 忽略函数的返回值

当调用一个函数时，返回值中可能有些我们并不关心，只需要其中一部分的值。在这种情况下，使用匿名变量来忽略不需要的值。

示例：

package main

import "fmt"

func getCoordinates() (int, int, int) {
    return 1, 2, 3
}

func main() {
    x, _, z := getCoordinates()  // 忽略第二个返回值
    fmt.Println(x, z) // 输出：1 3
}

在这个例子中，函数 getCoordinates 返回了三个值，但我们只关心第一个和第三个值，于是使用 _ 来忽略第二个返回值。

2) 在循环中忽略索引

在某些情况下，当我们不需要使用迭代器的索引值时，可以使用匿名变量来忽略它。

示例：

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30}
    for _, value := range numbers {  // 忽略索引
        fmt.Println(value)  // 输出 10 20 30
    }
}

这里，for _, value := range numbers 中的 _ 用来忽略数组的索引，只关注值。

3) 只关注某些字段

有时结构体或接口中包含多个字段，但你只需要其中的一些字段。通过使用匿名变量，你可以只选择需要的字段。

示例：

package main

import "fmt"

type Person struct {
    Name    string
    Age     int
    Address string
}

func main() {
    p := Person{"Alice", 30, "New York"}
    name, _ := p.Name, p.Age  // 只关注 Name，忽略 Age
    fmt.Println(name)  // 输出：Alice
}

在这个例子中，结构体 Person 有多个字段，但我们只关心 Name，所以通过匿名变量忽略了 Age 字段。

4) 避免编译器警告

在某些情况下，你可能需要声明一个变量，但你并不打算使用它。为了避免编译器的警告，可以使用匿名变量。

示例：

package main

func main() {
    var _ int  // 这样声明的变量不会被使用
}

这样可以确保变量不会被使用，避免编译器发出警告。

匿名变量的限制

• 无法访问：匿名变量一旦被赋值，就无法访问其值。例如，你不能像普通变量那样用 fmt.Println() 打印匿名变量的值。
• 只能丢弃值：匿名变量的作用就是丢弃不需要的值，因此，它只能在接受函数返回值时被使用。

示例：

package main

func main() {
    // 无法访问匿名变量的值
    _, _ := 1, 2
    // fmt.Println(_)  // 编译错误：cannot use _ as value
}

匿名变量的优势与适用场景

• 代码简洁：当你不关心某些返回值时，匿名变量使代码更加简洁，避免了为不使用的变量命名。
• 避免浪费资源：如果一个函数返回多个值，但你只关心其中的某些值，使用匿名变量可以避免不必要的内存占用和浪费。
• 保持语义清晰：匿名变量让你显式地表明某些返回值是有意忽略的，这在代码阅读时能提供清晰的语义。

总结

匿名变量（_）在 Go 语言中是一个非常实用的特性，主要用于忽略函数返回值、循环索引值或者结构体字段等。当我们不关心某些数据时，通过使用匿名变量来丢弃它们，能够提高代码的简洁性和可读性。

• 局限性：匿名变量不能被访问，不能修改其值。

• 常见用途：

  • 忽略不需要的函数返回值
  • 忽略循环中的索引
  • 避免编译器警告
  • 仅关心部分字段

在实际开发中，合理使用匿名变量能够使代码更简洁并提升可读性。如果有不需要的值，使用匿名变量是一个非常优雅的解决方案。

7. 指针变量的定义

Go 语言可以通过 & 来获取变量的地址，从而得到指针。指针变量可以存储其他变量的地址。

基本格式：

var ptr *Type // 定义一个指针变量

示例：

var ptr *int // 定义一个指向 int 类型的指针变量

总结：

• 使用 var 关键字可以声明变量，并指定类型或初始化值。
• 使用 := 可以简洁地声明并初始化变量（仅限函数内部）。
• 使用 const 定义常量，值不可修改。
• Go 自动推断变量的类型，简化代码书写。