9.3 Go语言入门(变量声明和函数调用)

news2024/11/24 4:02:13

Go语言入门（变量声明和函数调用）

目录
- 二、变量声明和函数调用
- - 1. 变量声明
  - - 1.1 使用 var 关键字声明
    - 1.2 简短声明
    - 1.3 零值
    - 1.4 常量
  - 2. 函数调用
  - - 2.1 函数定义
    - 2.2 多个返回值
    - 2.3 命名返回值
    - 2.4 可变参数
    - 2.5 匿名函数和闭包

package main

import "fmt"

func main() {
    // 声明一个字符串变量并初始化
    var name string = "Alice"
    fmt.Println(name)

    // 声明一个整型变量，未初始化时会使用零值
    var age int
    fmt.Println(age) // 默认值 0

    // 同时声明多个变量
    var width, height int = 100, 200
    fmt.Println(width, height)

    // 类型推断
    var country = "USA"
    fmt.Println(country)

    // 声明布尔变量
    var isActive bool = true
    fmt.Println(isActive)
}

1.2 简短声明

使用 := 进行简短声明，类型由右值推断。这种方法只能在函数内部使用。

package main

import "fmt"

func main() {
    // 简短声明变量
    name := "Bob"
    age := 30
    fmt.Println(name, age)

    // 同时声明多个变量
    x, y := 10, 20
    fmt.Println(x, y)

    // 声明布尔变量
    isActive := false
    fmt.Println(isActive)
}

1.3 零值

未初始化的变量会被赋予默认的零值：

数字类型（包括 int, float64）：0
布尔类型：false
字符串类型：“”（空字符串）
指针、切片、映射、通道、函数和接口：nil

package main

import "fmt"

func main() {
    var a int
    var b float64
    var c bool
    var d string
    var e []int

    fmt.Println(a) // 0
    fmt.Println(b) // 0
    fmt.Println(c) // false
    fmt.Println(d) // ""
    fmt.Println(e) // []
}

1.4 常量

使用 const 关键字声明常量，常量在编译时确定，并且不可修改。

package main

import "fmt"

const Pi = 3.14

func main() {
    const Greeting = "Hello, World!"
    fmt.Println(Pi)
    fmt.Println(Greeting)
}

2. 函数调用

2.1 函数定义

Go 中的函数定义包括函数名、参数列表、返回值列表和函数体。

package main

import "fmt"

// 定义一个函数，接受两个 int 参数，返回它们的和
func add(x int, y int) int {
    return x + y
}

func main() {
    sum := add(3, 4)
    fmt.Println("Sum:", sum)
}

2.2 多个返回值

Go 的函数可以返回多个值。

package main

import "fmt"

// 交换两个字符串
func swap(a, b string) (string, string) {
    return b, a
}

func main() {
    x, y := swap("hello", "world")
    fmt.Println(x, y) // 输出：world hello
}

2.3 命名返回值

返回值可以在函数定义中命名，命名返回值在函数体中被初始化为对应类型的零值。return 语句可以返回这些值。

package main

import "fmt"

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 省略返回变量名，返回 x, y
}

func main() {
    fmt.Println(split(17)) // 输出：7 10
}

2.4 可变参数

使用 … 表示可变参数。

package main

import "fmt"

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3))       // 输出：6
    fmt.Println(sum(4, 5, 6, 7, 8)) // 输出：30
}

2.5 匿名函数和闭包

匿名函数和闭包在 Go 中也很常见。

package main

import "fmt"

func main() {
    // 匿名函数
    add := func(x, y int) int {
        return x + y
    }
    fmt.Println(add(3, 4)) // 输出：7

    // 闭包
    counter := func() func() int {
        i := 0
        return func() int {
            i++
            return i
        }
    }()
    
    fmt.Println(counter()) // 输出：1
    fmt.Println(counter()) // 输出：2
    fmt.Println(counter()) // 输出：3
}