Comment utiliser le var tous les fichiers dans un paquet?

Je avoir la structure suivante:

modèles/db.aller

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
}

modèles/db_util.aller

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

Lorsque j'essaie d'accéder à db dans InsertProfile fonction, il est dit NULL ptr exception. Comment puis-je accéder à la db dans db_utils.go?

Je ne voudrais pas tirer profit db (car il permettrait de donner accès à tous les paquets).

Je reçois la REQUÊTE a retourné à partir de la db dans init() correctement.

InformationsquelleAutor lionelmessi | 2015-12-10
  1. 39

    Edit: Le problème, c'est que vous avez utilisé Courte déclaration de variable := et vous simplement stockés à la création de la *DB valeur dans une variable locale et non pas dans le global.

    Cette ligne:

    db, err := NewDB(dbinfo)

    Crée 2 variables locales: db et err, et ceci, db n'a rien à voir avec votre db variable. Votre variable globale restera nil. Vous devez affecter à la création de la *DB à la variable globale. Ne pas utiliser de courte déclaration de variable, mais simple affectation, e.g:

    var err error
db, err = NewDB(dbinfo)
if err != nil {
    log.Fatal(err)
}

    Original suit la réponse.

    C'est un pointeur de type, vous devez les initialiser avant de l'utiliser. La valeur zéro pour les types pointeur est nil.

    Vous n'avez pas à exporter (c'est ce qu'il commence par une lettre majuscule n'). Notez qu'il n'a pas d'importance que vous avez plusieurs fichiers, aussi longtemps qu'ils font partie d'un même ensemble, ils peuvent accéder à des identificateurs définis dans l'une de l'autre.

    Une bonne solution serait de le faire dans le package init() fonction qui est appelée automatiquement.

    Noter que sql.Open() peut juste valider ses arguments, sans création d'une connexion à la base de données. Pour vérifier que le nom de source de données est valide, appelez DB.Ping().

    Par exemple:

    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)
    }
}
    • exactement! C'est ce que je suis en train de faire .
    • pourtant, il est nul dans l'autre fichier.
    • J'imagine que vous avez utilisé courte déclaration de variable := et vous simplement stockés à la création de la *DB valeur dans une variable locale, et non à l'échelle mondiale. Impossible à dire sans voir votre source, de sorte s'il vous plaît être gentil et poster ça.
    InformationsquelleAutor icza
  2. 12

    icza a déjà correctement répondu à votre problème spécifique, mais il est intéressant d'ajouter des explications supplémentaires sur ce que vous faites mal donc vous comprenez comment ne pas faire l'erreur à l'avenir. Allez, la syntaxe := pour l'affectation crée de nouvelles variables avec des noms à la gauche de la :=, éventuellement, de l'occultation paquet, ou même la mère de la portée de la fonction/méthode des variables. À titre d'exemple:

    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 :=
}

    Remarque Go n'a aucun moyen de supprimer ou de désactiver une variable, donc une fois que vous avez l'ombre d'une étendue supérieure des variables (par exemple par la création d'une portée de fonction variable de même nom qu'un paquet de portée variable), il n'y a aucun moyen d'accès le plus élevé de la portée de la variable au sein de ce bloc de code.

    Aussi être conscient que := est un raccourci pour var foo =. Les deux agissent exactement de la même manière, cependant := est seulement valide la syntaxe à l'intérieur d'une fonction ou d'une méthode, alors que le var syntaxe est valable partout.

    InformationsquelleAutor Endophage