Pointers 如何跨包中的文件使用全局变量？

我有以下文件结构：

型号/db.go

type DB struct {
    *sql.DB
}

var db *DB

func init() {
    dbinfo := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable",
        DB_USER, DB_PASSWORD, DB_NAME)

    db, err := NewDB(dbinfo)
    checkErr(err)

    rows, err := db.Query("SELECT * FROM profile")
    checkErr(err)

    fmt.Println(rows)
}

func NewDB(dataSourceName string) (*DB, error) {
    db, err := sql.Open("postgres", dataSourceName)
    if err != nil {
        return nil, err
    }
    if err = db.Ping(); err != nil {
        return nil, err
    }
    return &DB{db}, nil
}

func (p *Profile) InsertProfile() {
    if db != nil {
        _, err := db.Exec(...)
        checkErr(err)
    } else {
        fmt.Println("DB object is NULL")
    }
}

型号/db_util.go

type DB struct {
    *sql.DB
}

var db *DB

func init() {
    dbinfo := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable",
        DB_USER, DB_PASSWORD, DB_NAME)

    db, err := NewDB(dbinfo)
    checkErr(err)

    rows, err := db.Query("SELECT * FROM profile")
    checkErr(err)

    fmt.Println(rows)
}

func NewDB(dataSourceName string) (*DB, error) {
    db, err := sql.Open("postgres", dataSourceName)
    if err != nil {
        return nil, err
    }
    if err = db.Ping(); err != nil {
        return nil, err
    }
    return &DB{db}, nil
}

func (p *Profile) InsertProfile() {
    if db != nil {
        _, err := db.Exec(...)
        checkErr(err)
    } else {
        fmt.Println("DB object is NULL")
    }
}

当我尝试在

InsertProfile

函数中访问

db

时，它会显示

NULL ptr exception

。如何访问

db_utils.go

中的

db

我不想大写

db

（因为它可以访问所有包）

---

我正确地从

init（）

中的

db

返回查询。

编辑：问题是您使用了

：=

，而您只是将创建的

*db

值存储在局部变量中，而不是全局变量中

这一行：

db, err := NewDB(dbinfo)

创建两个局部变量：

db

和

err

，而此局部

db

与全局

db

变量无关。全局变量将保持为

nil

。必须将创建的

*DB

分配给全局变量。不要使用短变量声明，而要使用简单变量声明，例如：

原来的答案如下

---

它是指针类型，在使用它之前必须初始化它。指针类型的零值为

nil

您不必导出它（以大写字母开头就是这样）。请注意，有多个文件并不重要，只要它们是同一个包的一部分，它们就可以访问彼此定义的标识符

一个好的解决方案是在自动调用的包

init（）

函数中执行

请注意，可能只验证其参数，而不创建到数据库的连接。要验证数据源名称是否有效，请调用

例如：

var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("yourdrivername", "somesource")
    if err != nil {
        log.Fatal(err)
    }
    if err = db.Ping(); err != nil {
        log.Fatal(err)
    }
}

---

icza已经正确地回答了您的具体问题，但值得添加一些关于您做错了什么的额外解释，以便您了解如何在将来避免犯错误。在Go中，赋值的语法

：=

创建了新变量，其名称位于

：=

的左侧，可能是阴影包，甚至是父作用域函数/方法变量。例如：

package main

import "fmt"

var foo string = "global"

func main() {
    fmt.Println(foo) // prints "global"

    // using := creates a new function scope variable 
    // named foo that shadows the package scope foo
    foo := "function scope" 
    fmt.Println(foo) // prints "function scope"
    printGlobalFoo() // prints "global"

    if true {
        foo := "nested scope"
        fmt.Println(foo) // prints "nested scope"
        printGlobalFoo() // prints "global" 
    } 
    // the foo created inside the if goes out of scope when 
    // the code block is exited

    fmt.Println(foo) // prints "function scope"
    printGlobalFoo() // prints "global"

    if true {
        foo = "nested scope" // note just = not :=
    }

    fmt.Println(foo) // prints "nested scope"
    printGlobalFoo() // prints "global"

    setGlobalFoo()
    printGlobalFoo() // prints "new value"
}

func printGlobalFoo() {
    fmt.Println(foo)
}

func setGlobalFoo() {
    foo = "new value" // note just = not :=
}

注意Go无法删除或取消设置变量，因此一旦隐藏了更高范围的变量（例如通过创建与包范围变量同名的函数范围变量），就无法访问该代码块中的更高范围变量

---

还要注意，

：=

是

var foo=

的缩写。两者的作用方式完全相同，但是，

：=

是函数或方法中唯一有效的语法，而

var

语法在任何地方都有效。

对于来到这里想要快速回答的人来说

在

db.go

文件中：

package db

var db *DB

type DB struct {
    *gorm.DB // or what database you want like *mongo.Client
}

func GetDB() *DB {
    if db == nil{
        db = ConnectToYourDbFunc("connection_string")
    }
    return db
}

然后，在您的其他软件包中，您可以通过以下方式获得：

db := db.GetDB()

---

就这些。

没错！这就是我正在做的。但是在另一个文件中它是nil。@lionelmessi我猜您使用了短变量声明

：=

，您只是将创建的

*DB

值存储在局部变量中，而不是全局变量中。没有看到你的消息来源是不可能说出来的，所以请友好地发布。