目录

一、Go中的函数

函数声明

 多个返回值

可变参数

匿名函数

值传递和地址传递

函数执行顺序（init函数）

二、Go中的包

基本语法

主要包（main package）

导入其他包

包的作用域

包的使用

包名别名

小结

---

一、Go中的函数

        Go中的函数与其他函数中功能大差不差，只是格式不同，当然也更加简便，从中可以看到其他语言的影子，但是开发效率会高上不少。

函数声明

• 函数签名：函数的声明包括函数名、参数列表和返回类型。
• 参数：可以在函数定义中指定参数的名字和类型。
• 返回值：可以指定函数返回的类型。如果函数不需要返回任何值，可以使用 () 表示无返回值。

一个简单的Go函数定义如下：

package main

import "fmt"

// 定义一个名为 add 的函数，接受两个 int 参数，返回一个 int 结果
func add(a int, b int) int {
    return a + b
}

func main() {
    // 调用 add 函数
    result := add(2, 3)
    fmt.Println("结果是:", result)
}

 多个返回值

我们的返回值列表也可以设置多返回值，这个C++中可能就要设置自定义数据类型或者模板来实现，而Go提供了很便捷的方法，直接定义返回值列表返回即可

func divide(a int, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果是:", result)
    }
}

可变参数

如果你想要传递可变数量的参数给一个函数，可以使用 ... 操作符

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

func main() {
    result := sum(1, 2, 3, 4, 5)
    fmt.Println("总和是:", result)
}

匿名函数

你也可以定义匿名函数，并将其赋值给一个变量或立即调用：

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

    result := sum(1, 2, 3, 4, 5)
    fmt.Println("总和是:", result)
}

我们来看这一种情况，将函数赋值给一个变量，这个变量就是一个函数，和我们之前学习的函数指针非常像，回调函数的场景应用非常多

func test(args ...int) {
	//函数内部处理可变参数，将可变参数当作切片来处理
	for i := 0; i < len(args); i++ {
		fmt.Println(args[i])
	}
}
func test2(num1 int, num2 int, funct func(args ...int)) {
	funct(num1, num2)
}
func main() {
	//var a = 10
	//var b = 20
	//exchange(&a, &b)
	//fmt.Println(a)
	//fmt.Println(b)
	test(1, 2, 3, 4, 5, 6, 7, 8, 6, 55)
	c := test
	fmt.Printf("c:%T,test:%T\n", c, test)
	c(1, 2, 3, 5, 6, 7, 8)
	test2(1, 2, test) //test和C是完全一样的
	test2(1, 2, c)
}

 可以看到c和test的类型没有任何区别

值传递和地址传递

在C语言中我们直到形参的改变不会引起实参的改变，所以我们需要传递实参的地址 

package main

import "fmt"

func exchange(num1 *int, num2 *int) {
	var tmp int = *num1
	*num1 = *num2
	*num2 = tmp
}

func test(args ...int) {
	//函数内部处理可变参数，将可变参数当作切片来处理
	for i := 0; i < len(args); i++ {
		fmt.Println(args[i])
	}
}
func test2(num1 int, num2 int, funct func(args ...int)) {
	funct(num1, num2)
}
func main() {
	var a = 10
	var b = 20
	exchange(&a, &b)
	fmt.Println(a)
	fmt.Println(b)
	test(1, 2, 3, 4, 5, 6, 7, 8, 6, 55)
	//c := test
	fmt.Printf("c:%T,test:%T", c, test)
	c(1, 2, 3, 5, 6, 7, 8)
	//test2(1, 2, test)
	//test2(1, 2, c)
}

函数执行顺序（init函数）

全局变量初始化：全局变量的初始化按其声明顺序进行。

包级别的 init 函数：每个包中的 init 函数按包的依赖顺序执行。

main 函数：一旦所有初始化完成，程序进入 main 包的 main 函数。

 下面是一个综合示例，展示了全局变量初始化、包级别的 init 函数和 main 函数的执行顺序

// pkg1/init.go
package pkg1

var x = initX()

func initX() int {
    println("初始化 pkg1.x")
    return 10
}

func init() {
    println("pkg1 的 init 函数")
}

// pkg2/init.go
package pkg2

var y = initY()

func initY() int {
    println("初始化 pkg2.y")
    return 20
}

func init() {
    println("pkg2 的 init 函数")
}

// main/main.go
package main

import (
    "pkg1"
    "pkg2"
)

func main() {
    println("main 函数开始")
    println("pkg1.x 的值:", pkg1.x)
    println("pkg2.y 的值:", pkg2.y)
}

输出是

初始化 pkg1.x

pkg1 的 init 函数

初始化 pkg2.y

pkg2 的 init 函数

main 函数开始

pkg1.x 的值: 10

pkg2.y 的值: 20 

二、Go中的包

        在 Go 语言中，包（package）是一个重要的概念，用于组织和复用代码。通过使用包，你可以将相关的函数、类型、变量等组织在一起，从而提高代码的可维护性和可读性。

基本语法

每个 Go 文件必须属于一个包。包的声明位于文件的顶部：

package mypackage

其中 mypackage 是包的名称。通常，包名会反映其功能或用途（一般建议包名和文件夹名称相同）

主要包（main package）

一个特殊的包是 main 包，它是程序的入口点。当编译和运行一个 Go 程序时，默认情况下会编译 main 包。main 包中的 main 函数是程序执行的起点：

package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}

导入其他包

你可以通过 import 语句来导入其他包。导入语句通常位于包声明之后，但在任何其他代码之前

如果导入多个包，可以使用这种写法更为便捷

import (
    "fmt"      // 标准库包
    "mypackage" // 自定义包
)

包的作用域

在 Go 中，包内的标识符（如变量、函数、类型等）默认具有包级作用域，这意味着它们只能在同一包内访问。为了使一个标识符在其他包中也能访问，需要将其首字母大写

package common

// 大写的标识符在其他包中可访问
func Add(a int, b int) int {
    return a + b
}

// 小写的标识符只在当前包中可访问
func add(a int, b int) int {
    return a + b
}

包的使用

我们来看一下下图，如果将所有函数都写在一个文件里那么会很难阅读，同时模块划分也会很混乱，所以我们可以把一些工具函数写在其他包中，在需要使用的地方导入包即可。

 我们可以使用这样一个简单的结构来测试

在main中调用common中的Add和db中的Getconn

package db

func Getconn() {
	println("数据库连接")
	println("dbutil函数执行")
}

package aaa

func Add(a int, b int) int {
	println("common_________")
	return a + b
}

main.go

package main

import (
	"fmt"
	"gocode/test_10_2/common"
	"gocode/test_10_2/db"
)

func main() {
	fmt.Println("main函数执行")
	db.Getconn()
	var c int = aaa.Add(1, 5)
	println(c)
	
}

运行输出如下

那同名函数会冲突吗

 

我们在db中也定义一个Add调用，其实也不会冲突，因为需要使用导入的包名作为前缀来调用函数。//在 main 函数中，我们使用 aaa.Add 来调用 Add 函数。这里 aaa 是包名，Add 是函数名。

包名别名

如果导入的包名较长，或者为了避免与其他包名冲突，可以给包起一个别名，比如下面的例子我们就使用了test来当作包名，但是使用了test后就不能再使用原来的包名了

package main

import (
	"fmt"
	test "gocode/test_10_2/common"
	"gocode/test_10_2/db"
)

func main() {
	fmt.Println("main函数执行")
	db.Getconn()
	var c int = test.Add(1, 5)
	println(c)
	var d int = db.Add(3, 4)
	println(d)
}

小结

        以上就是Go中一些函数和包的简单使用，在实际应用场景中可能更多的用法，就需要我们在这些基础上进行操作。函数是 Go 语言中非常灵活的构造，可以用来实现各种复杂的逻辑。合理地组织和使用包，可以使 Go 程序更加模块化和易于维护。确保遵循 Go 的最佳实践，如使用简洁的包名、导出必要的标识符等，可以使代码更加健壮和易用。