Go變數作用域精講及代碼實戰

来源:https://www.cnblogs.com/xfuture/p/18242545
-Advertisement-
Play Games

關註作者，復旦AI博士，分享AI領域與雲服務領域全維度開發技術。擁有10+年互聯網服務架構、AI產品研發經驗、團隊管理經驗，同濟本復旦碩博，復旦機器人智能實驗室成員，國家級大學生賽事評審專家，發表多篇SCI核心期刊學術論文，阿裡雲認證的資深架構師，項目管理專業人士，上億營收AI產品研發負責人。 精講 ...


關註作者，復旦AI博士，分享AI領域與雲服務領域全維度開發技術。擁有10+年互聯網服務架構、AI產品研發經驗、團隊管理經驗，同濟本復旦碩博，復旦機器人智能實驗室成員，國家級大學生賽事評審專家，發表多篇SCI核心期刊學術論文，阿裡雲認證的資深架構師，項目管理專業人士，上億營收AI產品研發負責人。

精講Go語言中局部作用域、全局作用域、塊作用域、包作用域、函數作用域的定義、記憶體管理和併發使用，提供豐富示例，幫助讀者編寫高效、安全的代碼。

file

1. 變數的作用域概述

在編程中，變數的作用域（Scope）定義了變數在程式中的可見性和生命周期。理解變數的作用域對於編寫健壯且可維護的代碼至關重要。Go語言（簡稱Go）提供了幾種不同的作用域類型，使得開發者可以靈活地控制變數的可見範圍和生命周期。本章節將詳細概述Go語言中變數的各種作用域，幫助讀者更好地理解和應用這些概念。

1.1 作用域的類型

在Go語言中，主要有以下幾種作用域類型：

作用域類型 描述 示例
局部作用域 變數在函數或代碼塊內部聲明，僅在該函數或代碼塊內可見。 func main() { var x int = 10 }
全局作用域 變數在包級別聲明，在同一包內的所有文件中都可見。 var y int = 20
塊作用域 變數在代碼塊（例如迴圈或條件語句）內部聲明，僅在該代碼塊內可見。 for i := 0; i < 10; i++ { var z int = i }
函數作用域 函數內的變數，僅在函數體內可見。 func foo() { var a int = 30 }
包作用域 包級別的變數聲明，在整個包範圍內可見。 package main; var b int = 40

1.2 作用域的可見性和生命周期

不同作用域類型決定了變數的可見性和生命周期：

  1. 局部作用域：

    • 可見性：局部變數僅在聲明它們的函數或代碼塊內可見。
    • 生命周期：局部變數的生命周期從它們被聲明開始，到函數或代碼塊執行完畢為止。

  2. 全局作用域：

    • 可見性：全局變數在同一包內的所有文件中都可見。
    • 生命周期：全局變數在程式啟動時被分配記憶體，併在程式結束時釋放。

  3. 塊作用域：

    • 可見性：塊作用域的變數僅在相應的代碼塊內可見。
    • 生命周期：塊作用域的變數從代碼塊開始執行到結束時結束。

  4. 函數作用域：

    • 可見性：函數作用域的變數僅在函數體內可見。
    • 生命周期：函數作用域的變數從函數調用開始到函數返回時結束。

  5. 包作用域：

    • 可見性：包作用域的變數在整個包範圍內可見。
    • 生命周期：包作用域的變數在包被載入時初始化，併在程式結束時釋放。

1.3 作用域與記憶體管理

不同作用域的變數在記憶體管理上也有所不同：

  • 局部變數：通常分配在棧上，函數或代碼塊執行完畢後自動釋放。
  • 全局變數：通常分配在堆上，直到程式結束時才釋放。
  • 塊變數：與局部變數類似，通常分配在棧上，塊執行完畢後釋放。
  • 函數變數：類似於局部變數，在棧上分配併在函數結束後釋放。
  • 包變數：與全局變數類似，通常在堆上分配，直到程式結束。

1.4 作用域的實際應用

理解不同作用域的應用場景對於編寫高效代碼至關重要：

  • 局部變數適用於臨時存儲和局部計算，避免全局變數的命名衝突。
  • 全局變數適用於跨函數共用數據，但要小心避免數據競爭和不必要的記憶體占用。
  • 塊變數適用於迴圈和條件判斷中的臨時數據存儲。
  • 函數變數適用於封裝函數內部邏輯，保證變數的私有性和安全性。
  • 包變數適用於包內共用數據，實現模塊化設計。

通過合理使用不同作用域，開發者可以有效管理變數的生命周期和可見性，提高代碼的可維護性和性能。

1.5 作用域的常見問題與調試技巧

處理變數作用域時，可能遇到以下常見問題：

  • 變數遮蔽：內層作用域的變數名與外層作用域相同，導致外層變數被遮蔽。
  • 作用域污染：不合理使用全局變數，導致命名衝突和意外修改。
  • 生命周期管理：誤用局部變數和全局變數，導致記憶體泄漏或性能問題。

調試技巧包括：

  • 使用調試器逐步檢查變數的值和生命周期。
  • 利用編譯器警告和錯誤信息，及時發現作用域問題。
  • 編寫單元測試，驗證不同作用域下變數的行為。

2. 局部作用域

局部作用域是指變數在函數或代碼塊內部聲明，其作用範圍僅限於該函數或代碼塊。理解局部作用域對於編寫安全、高效且可維護的代碼至關重要。在本章節中，我們將詳細探討局部作用域的定義、記憶體管理及在併發環境中的使用。

2.1 局部作用域的定義

局部變數是在函數或代碼塊內部聲明的變數。它們只能在聲明它們的作用範圍內訪問，離開該範圍後，這些變數將不再可見。局部變數的作用域通常較小，生命周期也較短，這使得它們在使用時非常高效。

  1. 函數內部的局部變數：

    • 這些變數在函數體內聲明，僅在函數體內可見。它們的生命周期從函數調用開始，到函數返回時結束。
    • 示例：
    func main() {
    var x int = 10
    fmt.Println("x in main:", x) // 輸出: x in main: 10
}

  2. 代碼塊內部的局部變數：

    • 這些變數在代碼塊（如條件語句、迴圈語句）內部聲明，僅在該代碼塊內可見。它們的生命周期從代碼塊開始執行，到代碼塊結束時結束。
    • 示例：
    func main() {
    if true {
        var y int = 20
        fmt.Println("y in if block:", y) // 輸出: y in if block: 20
    }
    // fmt.Println("y outside if block:", y) // 編譯錯誤: y 未定義
}

  3. 嵌套作用域：

    • 局部作用域可以嵌套，一個函數或代碼塊內部可以包含多個嵌套的代碼塊，每個代碼塊都有自己的局部變數。
    • 示例：
    func main() {
    var x int = 10
    if x > 5 {
        var y int = 20
        if y > 15 {
            var z int = 30
            fmt.Println("z in nested if block:", z) // 輸出: z in nested if block: 30
        }
        // fmt.Println("z outside nested if block:", z) // 編譯錯誤: z 未定義
    }
    // fmt.Println("y outside if block:", y) // 編譯錯誤: y 未定義
}

局部變數的優點

  1. 避免命名衝突：由於局部變數的作用範圍有限，它們不會與全局變數或其他函數的局部變數發生命名衝突。
  2. 記憶體管理高效：局部變數通常分配在棧上，函數或代碼塊執行完畢後自動釋放，記憶體管理非常高效。
  3. 代碼可讀性強：局部變數使得變數的作用範圍明確，增強了代碼的可讀性和可維護性。

2.2 記憶體管理

局部變數通常分配在棧上。當函數或代碼塊執行完畢後，這些局部變數會被自動釋放。這種記憶體管理方式使得局部變數的分配和釋放非常高效。

func calculate() int {
    var result int = 0
    for i := 0; i < 10; i++ {
        result += i
    }
    return result
}

func main() {
    sum := calculate()
    fmt.Println("Sum:", sum) // 輸出: Sum: 45
}

在calculate函數中，變數result和i都是局部變數，它們的記憶體分配在棧上。當calculate函數執行完畢後，這些變數會被自動釋放。

2.3 併發環境中的局部變數

在Go語言中，併發編程是其一大特性。在併發環境中使用局部變數可以避免數據競爭，因為每個goroutine都有自己獨立的棧空間，局部變數不會在不同的goroutine之間共用。

package main

import (
    "fmt"
    "sync"
)

func printNumber(wg *sync.WaitGroup, num int) {
    defer wg.Done()
    fmt.Println("Number:", num)
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go printNumber(&wg, i)
    }

    wg.Wait()
}

在上述示例中，每個printNumber函數調用都會在新的goroutine中執行，num作為局部變數不會在不同的goroutine之間共用，確保了併發執行的安全性。

3. 全局作用域

全局作用域指的是在包級別聲明的變數，它們在同一包內的所有文件中都可見。全局變數的使用需要謹慎，因為它們的生命周期貫穿整個程式運行過程，如果管理不當，可能會導致命名衝突、數據競爭等問題。在本章節中，我們將詳細探討全局作用域的定義、記憶體管理及在併發環境中的使用。

3.1 全局作用域的定義

全局變數是在包級別聲明的變數，這些變數在包內的所有文件中都可見，並且它們的生命周期從程式啟動開始，到程式結束時結束。全局變數可以在包的任意位置聲明，一般在包級別的開頭聲明。

  1. 包級別聲明：

    • 全局變數通常在包的開頭聲明，使得包內所有文件都可以訪問這些變數。
    • 示例：
    package main

import "fmt"

var globalVar int = 100 // 全局變數

func main() {
    fmt.Println("globalVar in main:", globalVar) // 輸出: globalVar in main: 100
}

  2. 跨文件訪問：

    • 全局變數可以在同一包內的不同文件中訪問。這對於共用數據或狀態信息非常有用。
    • 示例：
    // file1.go
package main

var sharedVar int = 200 // 全局變數

// file2.go
package main

import "fmt"

func printSharedVar() {
    fmt.Println("sharedVar in printSharedVar:", sharedVar) // 輸出: sharedVar in printSharedVar: 200
}

func main() {
    printSharedVar()
}

全局變數的優點

  1. 跨文件共用數據：全局變數可以在包內的所有文件中共用數據或狀態信息，方便模塊化編程。
  2. 持久性：全局變數的生命周期貫穿程式運行始終，適用於需要持久存儲的數據。

3.2 記憶體管理

全局變數通常分配在堆上。由於全局變數的生命周期從程式啟動到程式結束，記憶體管理需要特別註意，確保沒有不必要的記憶體占用。

package main

import "fmt"

var counter int = 0 // 全局變數

func increment() {
    counter++
}

func main() {
    for i := 0; i < 10; i++ {
        increment()
    }
    fmt.Println("Final counter value:", counter) // 輸出: Final counter value: 10
}

在上述示例中，變數counter是全局變數，生命周期貫穿整個程式運行過程。當increment函數被調用時，counter的值會遞增。

3.3 併發環境中的全局變數

在Go語言中，併發編程是其一大特性。全局變數在併發環境中需要特別小心，因為多個goroutine可能會同時訪問和修改全局變數，從而導致數據競爭和不一致性。

package main

import (
    "fmt"
    "sync"
)

var counter int = 0 // 全局變數
var mu sync.Mutex   // 互斥鎖

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()   // 加鎖
    counter++
    mu.Unlock() // 解鎖
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Final counter value:", counter) // 輸出: Final counter value: 10
}

在上述示例中，counter是一個全局變數，為了在併發環境中安全地訪問和修改它，我們使用了互斥鎖（sync.Mutex）來避免數據競爭。

4. 塊作用域

塊作用域（Block Scope）是指在特定代碼塊（如條件語句、迴圈語句等）內部聲明的變數，其作用範圍僅限於該代碼塊。塊作用域變數在聲明它們的代碼塊外部不可見。理解塊作用域對於編寫高效且可維護的代碼非常重要。在本章節中，我們將詳細探討塊作用域的定義、記憶體管理及在不同代碼結構中的使用。

1. 塊作用域的定義

塊作用域指的是變數在代碼塊內部聲明，其作用範圍僅限於該代碼塊。代碼塊可以是由大括弧 {} 包圍的一段代碼，如函數、條件語句、迴圈語句等。塊作用域變數的生命周期從代碼塊開始到代碼塊結束。

  1. 條件語句中的塊作用域：

    • 在條件語句（如 if、else if、else）內部聲明的變數，其作用範圍僅限於該條件語句塊。
    • 示例：
    package main

import "fmt"

func main() {
    x := 10
    if x > 5 {
        y := 20
        fmt.Println("y in if block:", y) // 輸出: y in if block: 20
    }
    // fmt.Println("y outside if block:", y) // 編譯錯誤: y 未定義
}

  2. 迴圈語句中的塊作用域：

    • 在迴圈語句（如 for、range）內部聲明的變數，其作用範圍僅限於該迴圈語句塊。
    • 示例：
    package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        msg := "Iteration"
        fmt.Println(msg, i) // 輸出: Iteration 0, Iteration 1, Iteration 2
    }
    // fmt.Println(msg) // 編譯錯誤: msg 未定義
}

  3. 嵌套塊作用域：

    • 塊作用域可以嵌套，一個代碼塊內部可以包含多個嵌套的代碼塊，每個代碼塊都有自己的局部變數。
    • 示例：
    package main

import "fmt"

func main() {
    x := 10
    if x > 5 {
        y := 20
        if y > 15 {
            z := 30
            fmt.Println("z in nested if block:", z) // 輸出: z in nested if block: 30
        }
        // fmt.Println("z outside nested if block:", z) // 編譯錯誤: z 未定義
    }
    // fmt.Println("y outside if block:", y) // 編譯錯誤: y 未定義
}

塊作用域的優點

  1. 避免命名衝突：由於塊作用域變數的作用範圍有限，它們不會與其他塊或函數的變數發生命名衝突。
  2. 記憶體管理高效：塊作用域變數通常分配在棧上，代碼塊執行完畢後自動釋放，記憶體管理非常高效。
  3. 代碼可讀性強：塊作用域使得變數的作用範圍明確，增強了代碼的可讀性和可維護性。

2. 記憶體管理

塊作用域變數通常分配在棧上。當代碼塊執行完畢後，這些變數會被自動釋放。這種記憶體管理方式使得塊作用域變數的分配和釋放非常高效。

package main

import "fmt"

func calculateSum() int {
    sum := 0
    for i := 1; i <= 10; i++ {
        sum += i
    }
    return sum
}

func main() {
    result := calculateSum()
    fmt.Println("Sum:", result) // 輸出: Sum: 55
}

在上述示例中，變數 sum 和 i 都是在 for 迴圈語句塊內部聲明的塊作用域變數，它們的記憶體分配在棧上，for 迴圈執行完畢後，這些變數會被自動釋放。

3. 塊作用域在不同代碼結構中的使用

塊作用域在條件語句中非常有用，因為它們可以限制變數的作用範圍，使得變數只在條件成立時存在。

package main

import "fmt"

func main() {
    x := 5
    if x < 10 {
        message := "x is less than 10"
        fmt.Println(message) // 輸出: x is less than 10
    } else {
        message := "x is 10 or more"
        fmt.Println(message)
    }
    // fmt.Println(message) // 編譯錯誤: message 未定義
}

在上述示例中，變數 message 在 if 和 else 塊中分別聲明，具有各自獨立的作用域。

**迴圈語句中的塊作用域

在迴圈語句中使用塊作用域變數，可以確保每次迭代都有獨立的變數實例，避免變數狀態被意外修改。

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        count := i * 2
        fmt.Println("Count:", count) // 輸出: Count: 0, 2, 4, 6, 8
    }
    // fmt.Println("Count outside loop:", count) // 編譯錯誤: count 未定義
}

在上述示例中，變數 count 在 for 迴圈的每次迭代中聲明，並且每次迭代都是一個新的實例。

**嵌套代碼塊中的塊作用域

使用嵌套代碼塊可以有效地管理變數的作用範圍，避免變數的命名衝突。

package main

import "fmt"

func main() {
    total := 0
    for i := 1; i <= 3; i++ {
        partial := i * 10
        {
            temp := partial + 5
            fmt.Println("Temp:", temp) // 輸出: Temp: 15, 25, 35
        }
        // fmt.Println("Temp outside nested block:", temp) // 編譯錯誤: temp 未定義
    }
}

在上述示例中，變數 temp 僅在嵌套的代碼塊內可見，離開該塊後即不可見。

5. 包作用域

包作用域（Package Scope）是指變數在包級別聲明，其作用範圍覆蓋整個包，即同一個包中的所有文件都可以訪問這些變數。包作用域在Go語言中非常重要，因為它有助於實現模塊化編程和代碼的可維護性。在本章節中，我們將詳細探討包作用域的定義、記憶體管理及其在不同代碼結構中的使用。

5.1 包作用域的定義

包作用域變數是在包級別聲明的，這些變數在同一個包中的所有文件中都可見。包作用域變數的生命周期從包被載入開始，到程式結束時結束。通常，包作用域變數在包的頂層聲明。

  1. 包級別聲明：

    • 包作用域變數通常在包的開頭或文件的最頂層聲明，使得包內所有文件都可以訪問這些變數。
    • 示例：
    package main

import "fmt"

var packageVar int = 100 // 包作用域變數

func main() {
    fmt.Println("packageVar in main:", packageVar) // 輸出: packageVar in main: 100
}

  2. 跨文件訪問：

    • 包作用域變數可以在同一個包內的不同文件中訪問，這對於共用數據或狀態信息非常有用。
    • 示例：
    // file1.go
package main

var sharedVar int = 200 // 包作用域變數

// file2.go
package main

import "fmt"

func printSharedVar() {
    fmt.Println("sharedVar in printSharedVar:", sharedVar) // 輸出: sharedVar in printSharedVar: 200
}

func main() {
    printSharedVar()
}

包作用域的優點

  1. 跨文件共用數據：包作用域變數可以在包內的所有文件中共用數據或狀態信息，方便模塊化編程。
  2. 持久性：包作用域變數的生命周期從包載入到程式結束，適用於需要持久存儲的數據。

5.2 記憶體管理

包作用域變數通常分配在堆上。由於包作用域變數的生命周期從程式啟動到程式結束，記憶體管理需要特別註意，確保沒有不必要的記憶體占用。

package main

import "fmt"

var counter int = 0 // 包作用域變數

func increment() {
    counter++
}

func main() {
    for i := 0; i < 10; i++ {
        increment()
    }
    fmt.Println("Final counter value:", counter) // 輸出: Final counter value: 10
}

在上述示例中，變數counter是包作用域變數，其生命周期貫穿整個程式運行過程。當increment函數被調用時，counter的值會遞增。

5.3 包作用域在不同代碼結構中的使用

模塊化編程中的包作用域

包作用域在模塊化編程中非常重要，它可以將相關的功能和數據封裝在一個包中，實現高內聚、低耦合的設計。

// config.go
package config

var AppName string = "MyApp" // 包作用域變數
var Version string = "1.0"

// main.go
package main

import (
    "fmt"
    "config"
)

func main() {
    fmt.Println("App Name:", config.AppName) // 輸出: App Name: MyApp
    fmt.Println("Version:", config.Version)  // 輸出: Version: 1.0
}

在上述示例中，config包中的變數AppName和Version具有包作用域，可以在main包中訪問，從而實現配置的集中管理。

包作用域與初始化函數

包作用域變數可以與初始化函數（init函數）結合使用，在程式開始時進行必要的初始化操作。

package main

import "fmt"

var configVar string

func init() {
    configVar = "Initialized" // 初始化包作用域變數
}

func main() {
    fmt.Println("configVar:", configVar) // 輸出: configVar: Initialized
}

在上述示例中，init函數在程式啟動時自動執行，對包作用域變數configVar進行初始化。

包作用域與併發編程

在併發編程中，包作用域變數需要特別小心，因為多個goroutine可能會同時訪問和修改包作用域變數，從而導致數據競爭和不一致性。

package main

import (
    "fmt"
    "sync"
)

var counter int = 0 // 包作用域變數
var mu sync.Mutex   // 互斥鎖

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()   // 加鎖
    counter++
    mu.Unlock() // 解鎖
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Final counter value:", counter) // 輸出: Final counter value: 10
}

在上述示例中，counter是一個包作用域變數，為了在併發環境中安全地訪問和修改它，我們使用了互斥鎖（sync.Mutex）來避免數據競爭。

6. 函數作用域

函數作用域（Function Scope）指的是在函數內部聲明的變數，其作用範圍僅限於該函數。這些變數在函數外部不可見，離開函數後即被銷毀。函數作用域在Go語言中非常重要，因為它可以有效地管理變數的生命周期，避免命名衝突和記憶體泄漏。在本章節中，我們將詳細探討函數作用域的定義、記憶體管理及其在不同代碼結構中的使用。

6.1 函數作用域的定義

函數作用域是指在函數內部聲明的變數，這些變數只能在該函數內部訪問，函數執行結束後，這些變數就會被銷毀。函數作用域的變數包括函數參數、局部變數以及在函數內部聲明的任何其他變數。

  1. 函數內部聲明的變數：

    • 這些變數只能在聲明它們的函數內部訪問，生命周期從函數調用開始，到函數返回結束。
    • 示例：
    package main

import "fmt"

func calculate(a int, b int) int {
    sum := a + b // sum 是函數作用域變數
    return sum
}

func main() {
    result := calculate(3, 4)
    fmt.Println("Result:", result) // 輸出: Result: 7
}

  2. 函數參數：

    • 函數參數也是函數作用域的一部分，它們在函數調用時被傳遞，在函數內部使用。
    • 示例：
    package main

import "fmt"

func greet(name string) {
    message := "Hello, " + name // name 是函數參數，具有函數作用域
    fmt.Println(message)
}

func main() {
    greet("Alice") // 輸出: Hello, Alice
}

函數作用域的優點

  1. 避免命名衝突：由於函數作用域變數的作用範圍僅限於函數內部，它們不會與其他函數的變數發生命名衝突。
  2. 記憶體管理高效：函數作用域變數通常分配在棧上，函數執行完畢後自動釋放，記憶體管理非常高效。
  3. 代碼可讀性強：函數作用域使得變數的作用範圍明確，增強了代碼的可讀性和可維護性。

6.2 記憶體管理

函數作用域變數通常分配在棧上。當函數執行完畢後，這些變數會被自動釋放。這種記憶體管理方式使得函數作用域變數的分配和釋放非常高效。

記憶體分配示例

package main

import "fmt"

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

func main() {
    result := factorial(5)
    fmt.Println("Factorial:", result) // 輸出: Factorial: 120
}

在上述示例中，n 是函數 factorial 的參數，其記憶體分配在棧上，函數執行完畢後自動釋放。

6.3 函數作用域在不同代碼結構中的使用

嵌套函數中的函數作用域

Go語言支持在一個函數內部聲明另一個函數，這使得函數作用域可以嵌套使用。

package main

import "fmt"

func outerFunction() {
    outerVar := "I am outside!"
    
    func innerFunction() {
        innerVar := "I am inside!"
        fmt.Println(outerVar) // 輸出: I am outside!
        fmt.Println(innerVar) // 輸出: I am inside!
    }

    innerFunction()
    // fmt.Println(innerVar) // 編譯錯誤: innerVar 未定義
}

func main() {
    outerFunction()
}

在上述示例中，innerFunction 是在 outerFunction 內部聲明的嵌套函數。outerVar 是 outerFunction 的局部變數，但在 innerFunction 中可見，而 innerVar 僅在 innerFunction 內部可見。

閉包中的函數作用域

閉包是指在其詞法作用域內引用了自由變數的函數。Go語言中的閉包可以捕獲並記住其外層函數中的變數。

package main

import "fmt"

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(pos(i))  // 累加正數
        fmt.Println(neg(-2*i)) // 累加負數
    }
}

在上述示例中，adder 函數返回一個閉包，該閉包捕獲了外層函數的變數 sum，併在多次調用中累加 sum 的值。

6.4 函數作用域與併發編程

在併發編程中，函數作用域變數對於保證數據安全和避免數據競爭非常重要。每個 goroutine 都有自己的函數作用域，因此函數內部的局部變數在不同的 goroutine 之間不會共用。

package main

import (
    "fmt"
    "sync"
)

func printNumbers(wg *sync.WaitGroup, start int) {
    defer wg.Done()
    for i := start; i < start+5; i++ {
        fmt.Println(i)
    }
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 3; i++ {
        wg.Add(1)
        go printNumbers(&wg, i*10)
    }

    wg.Wait()
}

在上述示例中，每個 printNumbers 函數調用在不同的 goroutine 中執行，且 i 和 start 變數均具有函數作用域，保證了併發執行的安全性。

如有幫助，請多關註
TeahLead KrisChang，10+年的互聯網和人工智慧從業經驗，10年+技術和業務團隊管理經驗，同濟軟體工程本科，復旦工程管理碩士，阿裡雲認證雲服務資深架構師，上億營收AI產品業務負責人。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • json-server 快速搭建REST API 伺服器
    json-server 快速搭建REST API 伺服器 ★ 認識json-server 官方文檔參考 json-server 是一個非常流行的開源工具，用於快速搭建一個完整的 REST API 伺服器。它使用 JSON 文件作為數據源，通過簡單的配置即可模擬複雜的伺服器功能，非常適合前端開發者在沒 ...
  • Vue 3與ESLint、Prettier：構建規範化的前端開發環境
    這篇文章介紹瞭如何在Vue 3項目中配置ESLint和Prettier以統一代碼風格，實現代碼規範性與可讀性的提升。通過設置規則、解決衝突、以及將配置融入持續集成流程和代碼審查過程，確保團隊協作時代碼風格的一致性，提升開發效率與項目維護性。 ...
  • Vue3——創建Vue3工程
    基於Vue-Cli創建 現在官方推薦使用 create-vue 來創建基於 Vite 的新項目(⚠️ Vue CLI 現已處於維護模式!) # 查看@vue/cli版本號，確保@vue/cli版本在4.5.0以上 vue --version # 沒有安裝@vue/cil或者版本不在4.5.0以上執行 ...
  • 【PB案例學習筆記】-05 圖片瀏覽器
    寫在前面 這是PB案例學習筆記系列文章的第5篇，該系列文章適合具有一定PB基礎的讀者。 通過一個個由淺入深的編程實戰案例學習，提高編程技巧，以保證小伙伴們能應付公司的各種開發需求。 文章中設計到的源碼，小凡都上傳到了gitee代碼倉庫https://gitee.com/xiezhr/pb-proje ...
  • Cursor是什麼？基於ChatGPT代碼編輯器的cursor如何使用？VS Code如何遷移到Cursor的步驟
    Cursor 是一個基於 Visual Studio Code（VS Code）技術構建的高級代碼編輯器，專為提高編程效率並更深度地整合 AI 功能而設計。它不僅繼承了 VS Code 的強大功能和用戶界面，還增加了專門針對 AI 支持的特色功能。Cursor 是 VS Code 的一個分支，這意味... ...
  • Maven詳解
    1 maven介紹 1)為什麼使用maven Maven是一個強大的項目管理和構建工具，它能夠簡化Java項目的構建、依賴管理和發佈過程。以下是Maven的一些主要特點和功能： 項目結構管理：Maven採用約定優於配置的原則，提供了標準的項目結構模板，使得開發人員可以快速創建和維護項目。 依賴管理： ...
  • NumPy 簡單算術：加減乘除及其他運算
    NumPy 中的簡單算術運算可以通過 `add`, `subtract`, `multiply`, `divide`, `power`, `mod`, `remainder` 等函數實現，這些函數支持條件運算，並接受 `where` 參數。例如，`add()` 實現加法，`subtract()` 表... ...
  • cJSON學習及簡單應用小結
    JSON 簡介 JSON（JavaScript Object Notation，JavaScript對象表示法）是一種輕量級的數據交換格式。它基於ECMAScript（歐洲電腦製造商協會制定的js規範）的一個子集，採用完全獨立於編程語言的文本格式來存儲和表示數據。簡潔和清晰的層次結構使得JSON成 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類