快捷導(dǎo)航

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

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

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

init 函數(shù)

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

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

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

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

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

init函數(shù)的特征

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

初始化的過程

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

runtime是go語言運(yùn)行所需要的基礎(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()

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

首先創(chuàng)建3個(gè)文件， 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
}

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

輸出

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é)論，同一個(gè)包不同源文件的init函數(shù)執(zhí)行順序，golang 沒做官方說明。這塊加載過程是按照 go run 文件排序。

使用案例：多個(gè)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中方法，實(shí)現(xiàn)是以綁定對(duì)象實(shí)例，并隱式將實(shí)例作為第一實(shí)參 (receiver)。

定義說明

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

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

方法定義

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

使用

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

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)我們嵌入一個(gè)類型的指針，嵌入類型的接受者為值類型或指針類型的方法將被提升，可以被外部類型的值或者指針調(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 方法

表達(dá)式

根據(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
}

輸出