快捷導(dǎo)航

Golang?int函數(shù)使用實例全面教程

更新時間：2023年10月19日 11:04:29 作者：帽兒山的槍手

這篇文章主要為大家介紹了Golang?int函數(shù)使用實例全面教程詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪

init 函數(shù)

例如某些場景下，我們需要提前初始化一些變量或邏輯代碼。在這種情況下，我們可以用一個特殊的init初始化函數(shù)來簡化初始化工作，每個文件都可以包含一個或多個init初始化函數(shù)。

func init() {} // init()函數(shù)語法

init初始化函數(shù)除了不能被調(diào)用或引用外，其他行為和普通函數(shù)類似。在每個文件中的init初始化函數(shù)，在程序開始執(zhí)行時按照它們聲明的順序被自動調(diào)用。

init函數(shù)先于main函數(shù)執(zhí)行

注意：每個包在解決依賴的前提下，以導(dǎo)入聲明的順序初始化，每個包只會被初始化一次。因此，如果一個p包導(dǎo)入了q包，那么在p包初始化的時候可以認(rèn)為q包必然已經(jīng)初始化過了。

init函數(shù)的特征

init函數(shù)是用于程序執(zhí)行前做包的初始化的函數(shù)，比如初始化包里的變量等
init函數(shù)沒有輸入?yún)?shù)、返回值
每個包可以擁有多個init函數(shù)
包的每個源文件也可以擁有多個init函數(shù)
同一個包中多個init函數(shù)的執(zhí)行順序go語言沒有明確的定義(說明)
不同包的init函數(shù)按照包導(dǎo)入的依賴關(guān)系決定該初始化函數(shù)的執(zhí)行順序
init函數(shù)不能被其他函數(shù)調(diào)用，而是在main函數(shù)執(zhí)行之前，自動被調(diào)用

初始化的過程

初始化導(dǎo)入的包（順序并不是按導(dǎo)入順序（從上到下）執(zhí)行的，runtime需要解析包依賴關(guān)系，沒有依賴的包最先初始化);
初始化包作用域的變量（并非按照“從上到下、從左到右”的順序，runtime解析變量依賴關(guān)系，沒有依賴的變量最先初始化);
執(zhí)行包的init函數(shù)；

runtime是go語言運行所需要的基礎(chǔ)設(shè)施，也是go的核心特性。該內(nèi)容將放到后續(xù)《go基礎(chǔ)之特性》章節(jié)為大家分享。

使用案例：init初始化順序

package main
import "fmt"
var Num int = Call() // 全局變量聲明
func init() { // 初始化函數(shù)
    fmt.Println("init()")
}
func Call() int {
    fmt.Println("Call()")
    return 1
}
func main() {
    fmt.Println("main()")
}

輸出

Call()
init()
main()

結(jié)論，初始化的過程：

Num變量初始化 -> init() -> main()

案例：同一個包不同源碼的init初始化順序

首先創(chuàng)建3個文件， main.go代碼中包含全局變量、init初始化函數(shù)定義，和main函數(shù)入口； a.go 和 b.go代碼文件中，只包含全局變量、init初始化函數(shù)的定義。

main.go文件

package main
import (
    "fmt"
)
var _ int = m()
func init() {
   fmt.Println("init in main.go")
}
func m() int {
   fmt.Println("call m() in main.go")
   return 1
}
func main() {
   fmt.Println("main()")
}

a.go 文件

package main
import "fmt"
var _ int = a()
func init() {
   fmt.Println("init in a.go")
}
func a() int {
   fmt.Println("call a() in a.go")
   return 1
}

b.go 文件

package main
import "fmt"
var _ int = b()
func init() {
   fmt.Println("init in b.go")
}
func b() int {
   fmt.Println("call b() in b.go")
   return 1
}

因為a.go 和 b.go 都歸屬于main包，但沒有兩文件中沒有main函數(shù)入口。在執(zhí)行的時候，需要使用 go run main.go a.go b.go 這樣形式執(zhí)行，runtime會將所有文件進行加載初始化。

輸出

call m() in main.go
call a() in a.go
call b() in b.go
init in main.go
init in a.go
init in b.go
main()

結(jié)論，同一個包不同源文件的init函數(shù)執(zhí)行順序，golang 沒做官方說明。這塊加載過程是按照 go run 文件排序。

使用案例：多個init函數(shù)初始化順序

package main
import "fmt"
func init() {
   fmt.Println("init 1")
}
func init() {
   fmt.Println("init 2")
}
func main() {
   fmt.Println("main")
}

輸出

init 1
init 2
main

結(jié)論：init函數(shù)比較特殊，可以在包里被多次定義。

方法

Golang中方法，實現(xiàn)是以綁定對象實例，并隱式將實例作為第一實參 (receiver)。

定義說明

只能為當(dāng)前包內(nèi)命名類型定義方法；
參數(shù) receiver 可任意命名，如方法中未曾使用，可省略參數(shù)名；
參數(shù) receiver 類型可以是 T 或 *T，基類型 T 不能是接口或指針；
不支持方法重載， receiver 只是參數(shù)簽名的組成部分；
可用實例 value 或 pointer 調(diào)用全部方法，編譯器自動轉(zhuǎn)換

一個方法就是一個包含了接受者的函數(shù)，接受者可以是命名類型或者結(jié)構(gòu)體類型的一個值或者是一個指針。

方法定義

func (recevier type) methodName(參數(shù)列表) (返回值列表) {} // 參數(shù)和返回值可以省略

使用

定義一個結(jié)構(gòu)類型和該類型的一個方法

package main
import "fmt"
// 結(jié)構(gòu)體
type Info struct {
    Name  string
    Desc string
}
// 方法
func (u Info) Output() {
    fmt.Printf("%v: %v \n", u.Name, u.Desc)
}
func main() {
    // 值類型調(diào)用方法
    u1 := Info{"帽兒山的槍手", "分享技術(shù)文章"}
    u1.Output()
    // 指針類型調(diào)用方法
    u2 := Info{"帽兒山的槍手", "分享技術(shù)文章"}
    u3 := &u2
    u3.Output()
}

輸出

帽兒山的槍手: 分享技術(shù)文章
帽兒山的槍手: 分享技術(shù)文章

匿名方法

如類型S包含匿名字段 *T ，則 S 和 *S 方法集包含 T + *T 方法。

這條規(guī)則說的是當(dāng)我們嵌入一個類型的指針，嵌入類型的接受者為值類型或指針類型的方法將被提升，可以被外部類型的值或者指針調(diào)用。

package main
import "fmt"
type S struct {
    T
}
type T struct {
    int
}
func (t T) testT() {
    fmt.Println("如類型 S 包含匿名類型 *T, 則 S 和 *S 方法集包含 T 方法")
}
func (t *T) testP() {
    fmt.Println("如類型 S 包含匿名字段 *T, 則 S 和 *S 方法集合包含 *T 方法")
}
func main() {
    s1 := S{T{1}}
    s2 := &s1
    fmt.Printf("s1 is : %v\n", s1)
    s1.testT()
    s1.testP() // 提升指針類型調(diào)用
    fmt.Printf("s2 is : %v\n", s2)
    s2.testT() // 提升值類型調(diào)用
    s2.testP()
}

輸出

s1 is : {{1}}
如類型 S 包含匿名類型 *T, 則 S 和 *S 方法集包含 T 方法
如類型 S 包含匿名字段 *T, 則 S 和 *S 方法集合包含 *T 方法
s2 is : &{{1}}
如類型 S 包含匿名類型 *T, 則 S 和 *S 方法集包含 T 方法
如類型 S 包含匿名字段 *T, 則 S 和 *S 方法集合包含 *T 方法

表達式

根據(jù)調(diào)用者不同，方法分為兩種表現(xiàn)形式

instance.method(args...) ---> <type>.func(instance, args...)

前者稱為 method value，后者 method expression則須顯式傳參。

package main
import "fmt"
type User struct {
    id   int
    name string
}
func (self *User) Test() {
    fmt.Printf("%p, %v\n", self, self)
}
func main() {
    u := User{1, "帽兒山的槍手"}
    u.Test()
    mValue := u.Test
    mValue() // 隱式傳遞 receiver
    mExpression := (*User).Test
    mExpression(&u) // 顯式傳遞 receiver
}

輸出