Comment configurer le répertoire Golang

Golang est un langage de programmation populaire, facile à apprendre et à utiliser et doté de puissantes fonctionnalités de performances et de concurrence. Lors de l'écriture d'applications à l'aide de Golang, il est très important d'organiser et de gérer le code efficacement.

La structure des répertoires est l'un des moyens de base d'organiser les fichiers de code et les répertoires. Il peut vous aider à mieux comprendre votre code, à parcourir rapidement les fichiers et répertoires, à améliorer la lisibilité du code, et bien plus encore.

Dans cet article, nous apprendrons comment mettre en place une structure de répertoires dans Golang pour optimiser l'organisation et la gestion du code.

Structure de base du projet Golang

Avant de commencer, nous devons comprendre certains composants de base de la structure du projet Golang. Les projets Golang ont généralement la structure de base suivante :

project/
├── main.go
├── go.mod
└── go.sum

Ici main.go est le fichier principal, qui stocke l'entrée du programme et le code logique important. go.mod et go.sum sont des fichiers qui gèrent les dépendances du projet. main.go 是主文件，存放了程序的入口和重要的逻辑代码。 go.mod 和 go.sum 是管理项目依赖的文件。

但是，随着项目的复杂性不断增加，我们可能需要更复杂的目录结构来组织我们的代码文件和目录。

让我们来看看一个更常见的Golang项目目录结构。

Golang项目目录结构示例

以下是一个示例Golang项目的通用目录结构：

project/
├── cmd/
│   └── myapp/
│       └── main.go
├── internal/
│   ├── app/
│   │   ├── model/
│   │   ├── controller/
│   │   ├── view/
│   │   └── application.go
│   ├── pkg/
│   ├── config/
│   └── util/
├── db/
│   └── db.go
├── web/
│   ├── middleware/
│   ├── static/
│   ├── templates/
│   └── server.go
├── go.mod
└── go.sum

让我们逐一了解每个目录：

• cmd: 存放了一些应用程序的入口。

  • myapp: 应用程序 "myapp" 的入口。

    • main.go: 应用程序 "myapp" 的主要入口点。

• internal: 包含项目内部使用的代码。

  • app: 存放应用程序的逻辑代码。

    • model: 存放模型代码。
    • controller: 存放控制器代码。
    • view: 存放视图代码。
    • application.go: 应用程序的启动逻辑。
  • pkg: 公共的库代码。
  • config: 存放应用程序配置相关的代码。
  • util: 通用的工具函数存放在这。
• db: 存放数据库相关的代码。

• web: 存放Web相关代码。

  • middleware: 存放中间件代码。
  • static: 存放静态文件。
  • templates: 存放模板文件。
  • server.go: Web服务器的入口。
• go.mod: 项目的依赖管理文件。
• go.sum: 项目依赖的版本文件。

如上所示，这个目录结构比基本结构要复杂得多。它具有更多的目录，包含更多的文件，但是更加有组织且易于管理。

为什么需要这样的结构？

这种目录结构在面对复杂项目时更具优势。它可以帮助我们更好地组织和管理代码，使其易于维护、重构和扩展。

以下是使用这种目录结构的优点：

• 更好的代码组织：分离应用程序代码、通用代码、配置代码和库代码，使其更加清晰。
• 更容易管理：更好的目录结构意味着更容易管理。
• 更好的可读性：逻辑代码和业务功能被分组在一起，使代码更易于阅读并维护。
• 更好的可扩展性：更好的组织结构为未来的重构和扩展提供了更好的基础。

如果您正在开发一个大型的、复杂的Golang应用程序，则使用这种目录结构是很有必要的。

如何创建这样的结构？

创建这样的目录结构并不难，你可以按照以下步骤进行：

1. 在项目根目录中创建以下目录： cmd,internal,db,web。

mkdir cmd internal db web

2. 在 cmd 目录下创建一个子目录来存放您的应用程序入口。

mkdir cmd/myapp

3. 在 internal 目录下创建子目录来存放通用的应用程序代码。

mkdir -p internal/app/{model,controller,view}

4. 在 internal 目录下创建其他子目录来存放库、配置和通用工具代码。

mkdir internal/{pkg,config,util}

5. 在 db 目录下创建文件来处理数据库逻辑。

touch db/db.go

6. 在 web 目录下创建子目录来存放Web相关代码。

mkdir -p web/{static,templates,middleware}

7. 在 web
Cependant, à mesure que la complexité du projet continue d'augmenter, nous pourrions avoir besoin d'une structure de répertoires plus complexe pour organiser nos fichiers de code et nos répertoires.

Jetons un coup d'œil à une structure de répertoires de projet Golang plus courante.

#🎜🎜#Exemple de structure de répertoires de projet Golang#🎜🎜##🎜🎜#Ce qui suit est la structure générale de répertoires d'un exemple de projet Golang : #🎜🎜#

touch web/server.go

#🎜🎜#Comprenons chaque répertoire un par one : # 🎜🎜#

• #🎜🎜#cmd : Stocke les points d'entrée de certaines applications. #🎜🎜#
  • #🎜🎜#myapp : L'entrée de l'application "myapp". #🎜🎜#
    • main.go : Le point d'entrée principal de l'application "myapp". #🎜🎜#
    #🎜🎜#
  #🎜🎜#
• #🎜🎜#interne : Contient le code utilisé en interne par le projet. #🎜🎜#
  • #🎜🎜#app : Stocke le code logique de l'application. #🎜🎜#
    • model : stocke le code du modèle. #🎜🎜#
    • contrôleur : stocke le code du contrôleur. #🎜🎜#
    • view : stocke le code de vue. #🎜🎜#
    • application.go : La logique de démarrage de l'application. #🎜🎜#
    #🎜🎜#
  • pkg : Code de la bibliothèque publique. #🎜🎜#
  • config : stocke le code lié à la configuration de l'application. #🎜🎜#
  • util : les fonctions utilitaires courantes sont stockées ici. #🎜🎜#
  #🎜🎜#
• db : stocke les codes liés à la base de données. #🎜🎜#
• #🎜🎜#web : stocke les codes liés au Web. #🎜🎜#
  • middleware : stocke le code du middleware. #🎜🎜#
  • static : Stockez les fichiers statiques. #🎜🎜#
  • templates : stockez les fichiers de modèles. #🎜🎜#
  • server.go : L'entrée du serveur Web. #🎜🎜#
  #🎜🎜#
• go.mod : Le fichier de gestion des dépendances du projet. #🎜🎜#
• go.sum : Le fichier de version dont dépend le projet. #🎜🎜#

#🎜🎜#Comme indiqué ci-dessus, cette structure de répertoires est beaucoup plus complexe que la structure de base. Il comporte plus de répertoires, contient plus de fichiers, mais est plus organisé et plus facile à gérer. #🎜🎜##🎜🎜#Pourquoi une telle structure est-elle nécessaire ? #🎜🎜##🎜🎜#Cette structure de répertoires présente plus d'avantages face à des projets complexes. Cela peut nous aider à mieux organiser et gérer le code, en le rendant facile à maintenir, à refactoriser et à étendre. #🎜🎜##🎜🎜#Voici les avantages de l'utilisation de cette structure de répertoires : #🎜🎜#

• Meilleure organisation du code : code d'application séparé, code général, code de configuration et code de bibliothèque pour les rendre plus clairs . #🎜🎜#
• Plus facile à gérer : une meilleure structure de répertoires signifie une gestion plus facile. #🎜🎜#
• Meilleure lisibilité : le code logique et les fonctions métiers sont regroupés, ce qui rend le code plus facile à lire et à maintenir. #🎜🎜#
• Meilleure évolutivité : une meilleure structure organisationnelle fournit une meilleure base pour une refactorisation et une expansion futures. #🎜🎜#

#🎜🎜#Si vous développez une application Golang volumineuse et complexe, il est nécessaire d'utiliser cette structure de répertoires. #🎜🎜##🎜🎜#Comment créer une telle structure ? #🎜🎜##🎜🎜#Créer une telle structure de répertoires n'est pas difficile, vous pouvez suivre les étapes ci-dessous : #🎜🎜#

1. Créez le répertoire suivant dans le répertoire racine du projet : cmd code >,<code>interne,db,web. #🎜🎜##🎜🎜#rrreee
   2. Créez un sous-répertoire sous le répertoire cmd pour stocker votre entrée d'application. #🎜🎜##🎜🎜#rrreee
      3. Créez des sous-répertoires sous le répertoire interne pour stocker le code d'application commun. #🎜🎜##🎜🎜#rrreee
         4. Créez d'autres sous-répertoires sous le répertoire interne pour stocker la bibliothèque, la configuration et le code général de l'outil. #🎜🎜##🎜🎜#rrreee
            5. Créez des fichiers dans le répertoire db pour gérer la logique de la base de données. #🎜🎜##🎜🎜#rrreee
               6. Créez un sous-répertoire sous le répertoire web pour stocker le code lié au Web. #🎜🎜##🎜🎜#rrreee
                  7. Créez un fichier dans le répertoire web pour stocker le code de démarrage du serveur web. #🎜🎜##🎜🎜#rrreee#🎜🎜#Après avoir modifié la structure des répertoires, vous pouvez organiser les commandes couramment utilisées dans des Makefiles ou des outils de ligne de commande. Utilisez ces outils pour mieux gérer et tester vos applications. #🎜🎜#

                     Résumé

                     Dans les projets Golang, la structure des répertoires est très importante, elle peut vous aider à mieux organiser et gérer votre code. Lorsque vous travaillez avec des applications Golang volumineuses et complexes, il est nécessaire d'utiliser une structure de répertoires plus organisée. En utilisant ces répertoires, vous pouvez améliorer la lisibilité, la maintenabilité et l'évolutivité de votre code. Bien sûr, il n'est pas difficile de créer un tel répertoire dans Golang. Il vous suffit de comprendre la structure de base du projet Golang et d'organiser le code selon certaines conventions et bonnes pratiques.

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!