Qu'est-ce qu'un package en langage Go

Un package est une collection de plusieurs codes sources Go et constitue une solution avancée de réutilisation de code. Les packages de langage Go utilisent la forme organisationnelle d'une arborescence de répertoires. Généralement, le nom d'un package est le nom du répertoire où se trouve son fichier source. Les packages peuvent être définis dans des répertoires très profonds. le chemin du répertoire, mais le package est référencé. Utilisez généralement une référence de chemin complet.

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

Le langage Go utilise des packages pour organiser le code source. Un package est une collection de plusieurs codes sources Go et constitue une solution avancée de réutilisation du code. Le langage Go nous fournit de nombreux packages intégrés, tels que fmt, os, io, etc.

Les packages et dossiers dans Golang ont une correspondance individuelle et doivent être créés dans le répertoire GOPATH avant de pouvoir être utilisés. Si un package dans Golang doit référencer le contenu d'un autre package, il doit être importé à l'aide du mot-clé import avant de pouvoir être utilisé.

Tout fichier de code source doit appartenir à un certain package, et la première ligne de code valide dans le fichier de code source doit être l'instruction package pacakgeName, par laquelle vous déclarez le package dans lequel vous vous trouvez. package pacakgeName 语句，通过该语句声明自己所在的包。

包的基本概念

Go语言的包借助了目录树的组织形式，一般包的名称就是其源文件所在目录的名称，虽然Go语言没有强制要求包名必须和其所在的目录名同名，但还是建议包名和所在目录同名，这样结构更清晰。

包可以定义在很深的目录中，包名的定义是不包括目录路径的，但是包在引用时一般使用全路径引用。比如在GOPATH/src/a/b/ 下定义一个包 c。在包 c 的源码中只需声明为package c，而不是声明为package a/b/c，但是在导入 c 包时，需要带上路径，例如import "a/b/c"。

包的习惯用法：

• 包名一般是小写的，使用一个简短且有意义的名称。

• 包名一般要和所在的目录同名，也可以不同，包名中不能包含- 等特殊符号。

• 包一般使用域名作为目录名称，这样能保证包名的唯一性，比如 GitHub 项目的包一般会放到GOPATH/src/github.com/userName/projectName 目录下。

• 包名为 main 的包为应用程序的入口包，编译不包含 main 包的源码文件时不会得到可执行文件。

• 一个文件夹下的所有源码文件只能属于同一个包，同样属于同一个包的源码文件不能放在多个文件夹下。

包的导入

要在代码中引用其他包的内容，需要使用 import 关键字导入使用的包。具体语法如下：

import "包的路径"

注意事项：

• import 导入语句通常放在源码文件开头包声明语句的下面；

• 导入的包名需要使用双引号包裹起来；

• 包名是从GOPATH/src/

Le concept de base des packages

Les packages de langage Go utilisent la forme d'organisation d'une arborescence de répertoires. Généralement, le nom d'un package est le nom du répertoire où se trouve son fichier source, bien que le langage Go le fasse. n'exige pas que le nom du package soit le même que le répertoire dans lequel il se trouve. Le nom du répertoire porte le même nom, mais il est néanmoins recommandé que le nom du package et le répertoire dans lequel il se trouve portent le même nom, afin que le nom du package soit identique à celui du répertoire dans lequel il se trouve. la structure est plus claire.

Les packages peuvent être définis dans des répertoires très profonds. La définition du nom du package n'inclut pas le chemin du répertoire, mais le chemin complet est généralement utilisé lors du référencement du package. Par exemple, définissez un package c sous GOPATH/src/a/b/. Dans le code source du package c, il vous suffit de le déclarer comme package c au lieu de package a/b/c. Cependant, lors de l'importation du package c, vous avez besoin. pour apporter le chemin. Par exemple import "a/b/c".

Utilisation idiomatique des packages :

Les noms de packages sont généralement en minuscules, utilisez un nom court et significatif.

Le nom du package a généralement le même nom que le répertoire dans lequel il se trouve, ou il peut être différent. Le nom du package ne peut pas contenir de symboles spéciaux tels que -.

• Les packages utilisent généralement le nom de domaine comme nom de répertoire, ce qui garantit l'unicité du nom du package. Par exemple, les packages des projets GitHub sont généralement placés dans le GOPATH/src/github.com/userName/. répertoire projectName .

• Le package nommé main est le package d'entrée de l'application Lors de la compilation du fichier de code source qui ne contient pas le package principal, vous n'obtiendrez pas de fichier exécutable.

• Tous les fichiers de code source d'un dossier ne peuvent appartenir qu'au même package. Les fichiers de code source qui appartiennent également au même package ne peuvent pas être placés dans plusieurs dossiers.

Importation de packages

Pour référencer le contenu d'autres packages dans votre code, vous devez utiliser le mot-clé import pour importer le package utilisé. La syntaxe spécifique est la suivante :

import "lab/test"
import "database/sql/driver"
import "database/sql"

Notes :

Les instructions import import sont généralement placées sous l'instruction de déclaration du package au début du fichier de code source

Le nom du package importé doit être enveloppé en double ; quotes;

Nom du package Il est calculé à partir d'après GOPATH/src/, en utilisant / pour séparer les chemins.

🎜🎜🎜🎜Le chemin d'importation du package 🎜🎜🎜🎜Il existe deux façons d'écrire le chemin de référence du package, à savoir l'importation du chemin complet et l'importation du chemin relatif. 🎜🎜🎜Importation du chemin complet🎜🎜🎜Le chemin absolu du package est le chemin de stockage du package après GOROOT/src/ ou GOPATH/src/, comme indiqué ci-dessous : 🎜

// 相对路径导入
import "../a"

🎜La signification du code ci-dessus est la suivante : Le package 🎜🎜🎜🎜test est self Le code source du package défini se trouve dans le répertoire GOPATH/src/lab/test ; le code source du package 🎜🎜🎜🎜driver se trouve dans le répertoire GOROOT/src/database/sql ; /driver répertoire ; le code source du package 🎜🎜🎜🎜sql se trouve dans le répertoire GOROOT/src /database/sql. 🎜🎜🎜🎜🎜Importation de chemin relatif🎜🎜🎜Les chemins relatifs ne peuvent être utilisés que pour importer des packages sous GOPATH, et les packages standard ne peuvent être importés qu'en utilisant le chemin complet. 🎜🎜Par exemple, le chemin du package a est GOPATH/src/lab/a et le chemin du package b est GOPATH/src/lab/b Si vous importez le package a dans le package b, vous pouvez utiliser l'importation de chemin relatif. méthode. Un exemple est le suivant : 🎜

// 全路径导入
import "lab/a"

🎜 Bien sûr, vous pouvez également utiliser l'importation du chemin complet ci-dessus, comme indiqué ci-dessous : 🎜rrreee🎜🎜🎜Chargement du package🎜🎜🎜🎜Grâce à la série d'études précédente, je crois que tout le monde a un compréhension générale du démarrage et du démarrage des programmes Go. Pendant le processus de chargement, avant d'exécuter la fonction principale du package principal, le programme de démarrage Go initialisera l'ensemble du package du programme. L'ensemble du processus d'exécution est illustré dans la figure ci-dessous. 🎜🎜🎜🎜Image : Initialisation du package Go 🎜🎜L'initialisation du package linguistique Go présente les caractéristiques suivantes : 🎜

• Le programme d'initialisation du package démarre à partir du package référencé par la fonction principale, recherche les références de package étape par étape, jusqu'à ce qu'il trouve un package qui ne fait pas référence à d'autres packages, et génère enfin un graphe acyclique dirigé des références de package.

• Le compilateur Go convertira le graphe acyclique dirigé en arbre, puis initialisera le package couche par couche en commençant par les nœuds feuilles de l'arbre.

• Le processus d'initialisation d'un seul package est comme indiqué dans la figure ci-dessus. Les constantes sont d'abord initialisées, puis les variables globales et enfin la fonction init du package est exécutée.

Résumé de l'utilisation des packages Golang

L'organisation du code source du langage Go se présente sous forme de packages. La fonction principale du langage Go ne peut être exécutée que par le système du package principal.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

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!