Go中函數的使用細節(jié)與注意事項詳解

更新時間：2022年11月26日 16:09:07 作者：甜點cc

在Go語言中函數可是一等的(first-class)公民,函數類型也是一等的數據類型,下面這篇文章主要給大家介紹了關于Go中函數的使用細節(jié)與注意事項的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下

細節(jié)匯總

函數的形參列表可以是多個，返回值列表也可以是多個
形參列表和返回值列表的數據類型，可以是值類型、也可以是引用類型
函數的命名遵循標識符命名規(guī)范，首字母不能是數字，首字母大寫表示該函數可以被本包文件和其它文件使用，類似public；首字母小寫只能被本包文件使用，類似private。
函數中的變量是局部的，外部不能訪問。作用域
基本數據類型和數組都是值傳遞的，即進行值拷貝。在函數內修改，不會影響到原來的值，
如果希望函數內的變量能夠修改函數外的變量，可以傳入變量的地址（&），函數內以指針的方式操作變量，從效果上看類似引用
Go函數不支持函數重載。
在Go中，函數也是一種數據類型，可以賦值給一個變量，則該變量是一個函數類型的變量，通過該變量可以對函數調用。
函數既然是一種數據類型，因此在Go中，函數也可以作為形參，并且調用。（回調函數）
為了簡化數據類型定義，Go支持自定義數據類型

語法： type 自定數據類型名數據類型 (相當于一個別名)
案例： type myInt int 這時，myInt就等價于int來使用了
type mySum func(int, int) int 這時，mySum就等價于func(int, int) int

支持對函數返回值命名（可以不受返回值順序限制）
使用 _ 下劃線標識符，忽略返回值。（占位符）
Go支持可變參數

值傳遞和指針傳遞

func test(n1 int) {
	n1 = n1 + 10
	fmt.Println("test n1=", n1)
}

// 指針類型接收處理
func test02(n2 *int) {
	*n2 = *n2 + 10
	fmt.Println("test02 n2=", *n2)
}

func main() {
	n1 := 20
	n2 := 2
	test(n1) // 值類型
	test02(&n2) // 指針類型
	fmt.Println("main n1=", n1)
	fmt.Println("main n2=", n2)
}

什么是重載

重載：函數名相同，但是形參不同或者數據類型不同的情況。

Golang語言中是不支持傳統(tǒng)的函數重載的，fn redeclared in this block

Golang語言是支持可變參數的，空接口的形式

函數類型的變量

類型： func(int, int) int

func getSum(n1 int, n2 int) int {
	return n1 + n2
}
func getSums(n1 int, n2 int, n3 int) int {
	return n1 + n2 + n3
}

// main 函數
sumFn := getSum
res := sumFn(10, 20)
fmt.Printf("%T %v\n", res, res) // int 30
fmt.Printf("%T \n", sumFn) // func(int, int) int

sumsFn := getSums
result := sumsFn(10, 20, 30)
fmt.Printf("result : %T %v\n", result, result) // result : int 60
fmt.Printf("sumsFn類型：%T \n", sumFn) // sumsFn類型：func(int, int) int

函數作為形參傳入

func getSum(n1 int, n2 int) int {
	return n1 + n2
}
func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
	return fnVar(num1, num2) // 調用傳入的函數，并返回值
}

// 函數類型形參
sumFn := getSum
total := testFn(sumFn, 1, 2)
fmt.Println("total=", total) // 3

自定義數據類型

自定義函數數據類型，相當于起了一個別名

type mySum func(int, int) int

func testFn(fnVar mySum, num1 int, num2 int) int {
	return fnVar(num1, num2)
}

// func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
// 	return fnVar(num1, num2)
// }

自定義數據類型

// main函數下
type myInt int
var num1 myInt = 2
// var num2 int = num1 // 這樣是報錯的， myInt和int并不等價
var num2 int = int(num1) // 顯式類型轉換
fmt.Printf("num1的類型：%T 值：%v \n", num1, num1) // num1的類型：main.myInt 值：2
fmt.Printf("num2的類型：%T 值：%v \n", num2, num2) // num2的類型：int 值：2

定義的類型: 包名.類型名，如：utils.myInt

// 以下是utils包
package utils

import "fmt"

func TestFn() string {
	fmt.Println("TestFn 函數被調用")
	type myInt int
	var n myInt = 10
	fmt.Printf("n的類型：%T 值：%v", n, n) // n的類型：utils.myInt 值：10
	return "hahaha"
}

返回值命名

func sumSub(n1 int, n2 int) (sum int, sub int) {
    // 這里不需要聲明sum, sub變量了，也不用在return時寫
	sum = n1 + n2
	sub = n1 - n2
	return
}

// main函數
sum, sub := sumSub(9, 8)
fmt.Println("sum=", sum, "sub=", sub) // sum= 17 sub= 1

可變參數

基本語法

支持零到多個參數

func sum(args... int) {}

支持1到多個參數

func sum(n1 int, args... int) {}

args：就是一個承接的變量名，可以自定義，如：func sum(n1 int, **vars**... int) {}

說明：

args是slice切片，通過args[index]可以訪問到各個值
args必須放到形參列表的最后面

參數個數可變

func sumV2(n1 int, args ...int) int {
	sum := n1
	fmt.Printf("args類型是：%T\n", args) // args類型是：[]int
	// 遍歷args切片
	for i := 0; i < len(args); i++ {
		sum += args[i]
	}
	return sum
}

// main函數
// 參數可變
total02 := sumV2(1, 2, 3, 4)
fmt.Println("total02=", total02) // total02= 10

總結練習

交換變量a, b的值

package main

import "fmt"

func swap(n1 *int, n2 *int) {
	*n1 = *n1 + *n2
	*n2 = *n1 - *n2 // *n1
	*n1 = *n1 - *n2 // *n2
}

func main() {
	a := 12
	b := 20
	swap(&a, &b)
	fmt.Println("a = ", a, "b = ", b)
}

到此這篇關于Go中函數的使用細節(jié)與注意事項的文章就介紹到這了,更多相關Go函數使用和注意內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: