Quel package la langue go doit-elle avoir ?

Le langage go doit avoir un package principal. Le langage Go est un langage statique compilé, donc avant d'exécuter un programme en langage Go, il doit être compilé dans un fichier exécutable binaire pour générer un programme exécutable en langage Go, il doit y avoir un package nommé main, et dans ce package il doit y avoir et une seule fonction principale.

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

1. Le concept de packages et de fichiers sources

Les programmes Go sont composés en reliant des packages entre eux. Un package est composé de fichiers sources qui définissent les constantes, les types, les variables et les fonctions appartenant au package (ils sont accessibles par tous les fichiers du même package et peuvent également être utilisés par d'autres packages via l'exportation). Le code de chaque package peut être utilisé comme une petite unité de réutilisation et référencé par d'autres projets.

Chaque fichier source contient une instruction package qui définit à quel package il appartient, suivie d'une collection d'importation éventuellement vide qui déclare quels packages doivent être utilisés, puis suivie d'une collection éventuellement vide de fonctions, types, variables et constantes. .

Nous pouvons voir que les packages appartenant aux fichiers nommés code et errno sont tous deux errno. Cela montre que Go n'utilise pas de classe comme unité de réutilisation comme Java, mais utilise le package comme une petite unité de réutilisation.

Résumé : La plus petite unité de Go est le package, et il peut y avoir plusieurs fichiers source sous le package. Le fichier source est équivalent à la classe de classe. Chaque fichier source déclare à quel package le fichier appartient via l'instruction package.

2. package principal

En langage Go, le package nommé main a une signification particulière. Le compilateur du langage Go tentera de compiler un package portant ce nom dans un fichier exécutable binaire. Tous les programmes exécutables compilés avec le langage Go doivent avoir un package nommé main.

En termes simples : pour générer un programme exécutable en langage Go, il doit y avoir un package nommé main, et il doit y avoir une seule fonction principale sous ce package

Lorsque le compilateur découvre que le nom d'un certain package est main Autrement dit, il trouvera certainement que la fonction nommée main() l'est, sinon le fichier exécutable ne sera pas créé. La fonction main() est le point d’entrée du programme, donc sans cette fonction, le programme n’a aucun moyen de commencer à s’exécuter. Lorsque le programme est compilé, le nom du répertoire où se trouve le code qui déclare le package principal sera utilisé comme nom de fichier du fichier exécutable binaire.

3. Conventions de dénomination pour les répertoires de packages

On dit qu'aucune règle ne peut faire de règle Avant de développer le langage Go, nous devons comprendre certaines des caractéristiques et spécifications du langage Go afin de mieux développer des fonctionnalités avancées. un code universel de qualité. Sinon, si vous développez un programme que vous seul pouvez comprendre, ce ne sera que votre propre divertissement. Cette section donne un exemple de convention de dénomination basée sur certains codes classiques et habitudes de développement de l'entreprise. L'exemple est le suivant :

Ce qui suit expliquera les spécifications de développement que je comprends sur la base de cet exemple de diagramme :

• conf : Ce répertoire. enregistre principalement les fichiers de configuration

• handler : stocke principalement les fichiers d'entrée de certains programmes, équivalent à la couche Collter en Java

• model : stocke principalement les fichiers liés aux opérations de base de données

• pkg : stocke principalement certains outils communs classes et autres codes

• router : enregistre principalement le code du service de routage

• service : enregistre principalement le code métier

• vendor : enregistre principalement les packages de dépendances du projet lui-même

• conf. yaml : le fichier de configuration du projet, qui peut être placé dans le répertoire, ou peut être placé sous le dossier conf

• main.go : Le point d'entrée du programme est généralement placé dans le répertoire racine

4 . Importer

Principe d'introduction du package

programme L'initialisation et l'exécution démarrent à partir du package principal. Si le package principal importe également d’autres packages, ils seront importés dans l’ordre lors de la compilation. Un package importé de plusieurs endroits ne sera importé qu’une seule fois. Lorsqu'un package est importé, si le package importe également d'autres packages, les autres packages seront importés en premier, puis les constantes et variables au niveau du package dans ces packages seront initialisées, puis la fonction init (le cas échéant) sera exécutée . ), et ainsi de suite. Une fois tous les packages importés chargés, les constantes et variables au niveau du package dans le package principal seront initialisées, puis la fonction init dans le package principal sera exécutée (si elle existe), et enfin la fonction principale sera exécutée.
Lorsqu'un package est importé, les dépendances sont recherchées en fonction de la priorité de haut en bas, à peu près :

• Le répertoire des fournisseurs sous le package actuel.
• Recherchez dans le répertoire supérieur jusqu'à ce que vous trouviez le répertoire des fournisseurs sous src.
• Recherchez les packages dépendants sous GOPATH.
• Recherchez dans le répertoire GOROOT la syntaxe de

package import

Lors de l'écriture du code Go, la commande import est souvent utilisée pour importer des fichiers de package. La façon de la voir est la suivante :

• Regular. import

import(
    "fmt"
)

Ensuite, vous pouvez l'appeler dans le code comme suit

fmt.Println("hello world")

上面这个fmt是Go语言的标准库，他其实是去GOROOT下去加载该模块。

• 点操作

import (
   . "fmt"
)

这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名，也就是前面你调用的fmt.Println(“hello world”)  可以省略的写成Println(“hello world”)。注意：该包内的函数不能与其重名。

• 别名操作

import( f “fmt” )

别名操作顾名思义可以把包命名成另一个用起来容易记忆的名字，别名操作调用包函数时前缀变成了重命名的前缀，即f.Println(“hello world”)，通常为了解决导入多个重名包的问题。

• _操作

import (
    _ "github.com/go-sql-driver/mysql"
)

_操作其实只是引入该包但不使用，通常只为了执行该包中所有的init()函数,最常见的就是上面的mysql包。

【相关推荐：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!