Comment importer des packages en langage Go

En langage Go, vous pouvez importer des packages via l'instruction d'importation. Le nom du package importé est entouré de guillemets doubles. Le nom du package est le chemin calculé à partir de GOPATH et utilise "/" pour séparer les chemins. Il existe deux formats de base pour l'importation de packages : 1. Syntaxe d'importation sur une seule ligne "import "bao1" import "bao2"" 2. Syntaxe d'importation multiligne "import("bao1" "bao2" ...)".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Paquet d'importation d'importation de langue Go - utilisez un autre code dans le code

Vous pouvez inclure de zéro à plusieurs déclarations de déclaration de package d'importation après une déclaration de déclaration de package de fichier source de langue Go et avant d'autres déclarations de déclaration de non-importation. Chaque déclaration d'importation peut spécifier un chemin d'importation individuellement, ou plusieurs chemins d'importation peuvent être importés simultanément via des parenthèses. Pour référencer les identifiants d'autres packages, vous pouvez utiliser le mot-clé import. Le nom du package importé est entouré de guillemets doubles. Le nom du package est le chemin calculé à partir de GOPATH et est séparé par /.

Méthode d'écriture d'importation par défaut

Il existe deux formats de base pour l'importation, à savoir l'importation sur une seule ligne et l'importation sur plusieurs lignes. L'effet de code d'importation des deux méthodes d'importation est le même.

1) Importation sur une seule ligne

Le format d'importation sur une seule ligne est le suivant :

import "包1"
import "包2"

2) Importation sur plusieurs lignes

Lors de l'importation de plusieurs lignes, l'ordre des noms de packages dans l'importation n'affecte pas l'effet d'importation. Le format est le suivant :

import(
    "包1"
    "包2"
    …
)

Importer Personnalisez le nom du package référencé après le package

Si nous voulons importer deux packages du même nom en même temps, comme le package math/rand et le crypto /rand package, l'instruction d'importation doit spécifier au moins un nouveau package pour un package portant le même nom pour éviter les conflits. C'est ce qu'on appelle renommer le package importé.

import (
    "crypto/rand"
    mrand "math/rand" // 将名称替换为mrand避免冲突
)

Le renommage des packages importés n'affecte que le fichier source actuel. Si d'autres fichiers sources importent le même package, ils peuvent utiliser le nom par défaut d'origine du package importé ou le renommer sous un autre nom complètement différent.

Le renommage des packages d'importation est une fonctionnalité utile, pas seulement pour résoudre les conflits de noms. Si le nom du package importé est compliqué, en particulier dans certains codes générés automatiquement, il peut être plus pratique d'utiliser un nom court. Lorsque vous choisissez de renommer des packages importés avec des noms courts, il est préférable d'être cohérent pour éviter toute confusion dans les noms de packages. Le choix d'un autre nom de package peut également permettre d'éviter les conflits avec les noms de variables communes locales. Par exemple, s'il existe déjà une variable nommée path dans le fichier, nous pouvons alors renommer le package standard "path" en pathpkg.

Chaque déclaration d'importation spécifie clairement la dépendance entre le package actuel et le package importé. Si vous rencontrez une boucle d'importation de package, l'outil de création de langage Go signalera une erreur.

Package d'importation anonyme - importez uniquement le package mais n'utilisez pas les types et les valeurs dans le package

Si vous souhaitez uniquement importer le package sans utiliser de structures ni de types dans le package, ni en appelant n'importe quelle fonction du package, vous pouvez utiliser des packages d'importation anonymes, le format est le suivant :

import (
    _ "path/to/package"
)

Parmi eux, path/to/package représente le nom du package à importer, et le soulignement _ représente le package d'importation anonyme .

Les packages importés de manière anonyme seront compilés dans le fichier exécutable tout comme les autres packages importés. En même temps, le package importé déclenchera également l'appel de la fonction init().

Le point d'entrée d'initialisation du package avant le démarrage du programme : init

Dans la conception de certaines exigences, les fonctions d'initialisation de tous les packages référencés par le programme doivent être appelées uniformément au démarrage du programme. doivent être appelés manuellement par la fonction d'initialisation du développeur, des erreurs ou des omissions peuvent survenir dans ce processus. Nous espérons que dans le package référencé, le rédacteur du package sera informé du démarrage du code et effectuera un travail d'initialisation du code dans son propre package au démarrage du programme.

Par exemple, afin d'améliorer l'efficacité d'exécution de la bibliothèque mathématique pour le calcul des fonctions trigonométriques, les valeurs des fonctions trigonométriques peuvent être intégrées dans une table d'index en mémoire à l'avance au démarrage du programme, et le programme externe peut obtenir rapidement les valeurs des fonctions trigonométriques en consultant le tableau. Cependant, l'appel à la fonction d'initialisation de la table d'index des fonctions trigonométriques ne devrait pas être appelé par tous les développeurs qui utilisent des fonctions trigonométriques en externe. S'il existe un mécanisme dans le package de fonctions trigonométriques qui peut indiquer quand le programme du package de fonctions trigonométriques démarre, alors le problème d'initialisation peut être résolu.

Le langage Go fournit une fonctionnalité très pratique pour les problèmes ci-dessus : la fonction init(). Les caractéristiques de la fonction

init() sont les suivantes :

• Chaque code source peut utiliser 1 fonction init(). La fonction

• init() sera automatiquement appelée avant l'exécution du programme (avant l'exécution de la fonction main()).

• L'ordre d'appel concerne les packages référencés dans main(), qui sont initialisés dans l'ordre en profondeur.

Par exemple, en supposant qu'il existe une telle relation de référence de package : main→A→B→C, alors la fonction init() appelant l'ordre de ces packages est :

C.init→B.init→A.init→main

Explication :

• Multiple dans le même package L'ordre dans lequel les fonctions init() sont appelées est imprévisible. La fonction

• init() ne peut pas être appelée par d'autres fonctions.

理解包导入后的init()函数初始化顺序

Go 语言包会从 main 包开始检查其引用的所有包，每个包也可能包含其他的包。Go 编译器由此构建出一个树状的包引用关系，再根据引用顺序决定编译顺序，依次编译这些包的代码。

在运行时，被最后导入的包会最先初始化并调用 init() 函数。

通过下面的代码理解包的初始化顺序。

代码8-3　包导入初始化顺序入口（…/chapter08/pkginit/main.go）

package main
import "chapter08/code8-2/pkg1"
func main() {
    pkg1.ExecPkg1()
}

代码说明如下：

• 第 3 行，导入 pkg1 包。

• 第 7 行，调用 pkg1 包的 ExecPkg1() 函数。

代码8-4　包导入初始化顺序pkg1（…/chapter08/pkginit/pkg1/pkg1.go）

package pkg1
import (
    "chapter08/code8-2/pkg2"
    "fmt"
)
func ExecPkg1() {
    fmt.Println("ExecPkg1")
    pkg2.ExecPkg2()
}
func init() {
    fmt.Println("pkg1 init")
}

代码说明如下：

• 第 4 行，导入 pkg2 包。

• 第 8 行，声明 ExecPkg1() 函数。

• 第 12 行，调用 pkg2 包的 ExecPkg2() 函数。

• 第 15 行，在 pkg1 包初始化时，打印 pkg1 init。

代码8-5　包导入初始化顺序pkg2（…/chapter08/pkginit/pkg2/pkg2.go）

package pkg2
import "fmt"
func ExecPkg2() {
    fmt.Println("ExecPkg2")
}
func init() {
    fmt.Println("pkg2 init")
}

代码说明如下：

• 第 5 行，声明 ExecPkg2() 函数。

• 第 10 行，在 pkg2 包初始化时，打印 pkg2 init。

执行代码，输出如下：

pkg2 init
pkg1 init
ExecPkg1
ExecPkg2

【相关推荐：Go视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!