Tutoriel pour l'installation du Code source local du projet GO: Résolvez la gestion de la dépendance après GO GET Échec

Ce tutoriel fournit des instructions détaillées sur la façon de télécharger manuellement le code source et d'installer correctement les projets GO tiers localement lorsque la commande Go Get échoue en raison de problèmes de réseau ou de certificat. Les étapes de base incluent la configuration des variables d'environnement GOPATH, l'organisation de la structure du répertoire de code source local en suivant strictement les règles d'importation du package GO et en utilisant la commande go install pour compiler et installer le projet et ses dépendances. Avec l'exemple de démonstration, assurez-vous que les dépendances du projet GO peuvent être gérées avec succès même dans des environnements complexes.

1. Comprendre GO Workspace et Gopath

Avant les modules GO, Gopath était au cœur de la gestion de la dépendance du projet GO. Il définit le répertoire racine de l'espace de travail GO, et tous le code source GO, les packages compilés et les fichiers exécutables seront stockés dans cet espace de travail. Aujourd'hui encore, lorsque GO est répandu, la compréhension de Gopath est toujours cruciale pour traiter certains anciens projets ou scénarios spécifiques.

1.1 La structure de Gopath

Un répertoire de Gopath standard contient généralement trois sous-répertoires:

• SRC: stocke le code source de tous les projets GO.
• PKG: stocke le fichier de package (fichier .a) généré après compilation.
• Bin: stocke le fichier exécutable compilé.

1.2 Réglage de la variable d'environnement de Gopath

Tout d'abord, vous devez définir la variable d'environnement Gopath pour pointer de votre répertoire de racine d'espace de travail Go. Par exemple, si vous souhaitez définir l'espace de travail sur e: \ workspace_go, vous devez le définir comme suit:

• Windows:

   définir gopath = e: \ workspace_go

  Ou le définir graphiquement sur les propriétés du système -> Advanced -> Variables d'environnement.

• Linux / macOS:

   exporter gopath = / path / to / your / workspace_go

  Il est recommandé d'ajouter cette commande au fichier ~ / .bashrc, ~ / .zshrc ou ~ / .profile pour le rendre permanent.

IMPORTANT: Le répertoire pointé par Gopath doit contenir un sous-répertoire SRC. Si votre gopath est e: \ workspace_go, le chemin du code source attendu par le compilateur Go commencera à rechercher à partir de e: \ workspace_go \ src.

2. Organisez correctement la structure du répertoire du code source local

Il s'agit de l'étape la plus critique dans l'installation manuelle d'un projet Go. Le compilateur Go recherche le fichier source correspondant via le chemin d'importation du package. Lorsque vous importez un package, tel que LaunchPad.net/MGO, GO s'attendra à trouver le code source du package sous le chemin GOPATH / SRC / LaunchPad.net / MgO. Par conséquent, le code source téléchargé manuellement doit être placé strictement conformément à la structure de son chemin d'importation de package.

2.1 Faites correspondre le chemin d'importation du package

Supposons que vous ayez téléchargé le code source du projet MGO et que le chemin du package défini dans le code est Launchpad.net/mgo. Ensuite, vous devez placer le code source MGO téléchargé dans le répertoire% GOPATH% / SRC / LaunchPad.net / MGO.

Exemple: prenez le projet MGO comme exemple

1. Définissez GOPATH: Supposons que votre GOPATH est défini sur e: \ workspace_go.

2. Créez la structure du répertoire nécessaire: Tout d'abord, assurez-vous qu'il existe un répertoire SRC sous Gopath: E: \ Workspace_Go \ SRC. Ensuite, créez un sous-répertoire basé sur le chemin d'importation de package lancé lance-pad.net/mgo:

    E: \ workspace_go \ src \ launchpad.net \ mgo

   Vous pouvez créer ces dossiers manuellement ou utiliser la ligne de commande:

    mkdir -p e: \ workspace_go \ src \ launchpad.net \ mgo

   (Le paramètre -p peut créer des répertoires à plusieurs niveaux sous Linux / MacOS, et vous devez les créer étape par étape ou utiliser MKDIR plusieurs fois dans Windows)

3. Copiez le code source: Copiez tous les fichiers de code source (y compris les sous-répertoires BSON, etc.) du projet MGO que vous avez téléchargé manuellement dans le répertoire final e: \ workspace_go \ src \ launchpad.net \ mgo.

   La structure du répertoire terminé doit être similaire:

    E: \ workspace_go
   └fiques
       └fiquesnpad.net
           └fiques
               ├fique.
               ├fiques
               ├fiques
               └fiques ... (autres fichiers de projet MGO)

3. Effectuer une installation locale

Lorsque la structure du répertoire de code source est correcte, vous pouvez utiliser la commande go install pour l'installer. La commande go install compilera le code source du package spécifié et placera le fichier de package compilé (.a) dans le répertoire GOPATH / PKG. Si le package est un fichier exécutable (package principal), son fichier exécutable sera placé dans le répertoire GOPATH / BIN.

3.1 Compilation des sous-packages

Si le projet contient des sous-packages (tels que BSON dans le projet MGO), il est généralement recommandé d'installer d'abord le sous-package, puis le package principal pour s'assurer que les dépendances sont correctement résolues.

1. Installez le sous-package BSON: accédez au répertoire du sous-package BSON et exécutez l'installation Go.

    cd e: \ workspace_go \ src \ launchpad.net \ mgo \ bson
   aller installer

   Si tout se passe bien, cette commande ne sortira rien et ne générera pas le résultat de compilation du package BSON sous Gopath / PKG.

2. Installez le package principal MGO: retournez au répertoire du package principal MGO, puis exécutez l'installation de Go.

    cd e: \ workspace_go \ src \ launchpad.net \ mgo
   aller installer

   De même, il n'y aura pas de sortie après une installation réussie.

Désormais, le projet MGO et ses sous-packages BSON de dépendances ont été compilés et installés avec succès dans votre espace de travail Go. D'autres projets GO peuvent le référencer en important "lancementpad.net/mgo".

4. Précautions et FAQ

• Unicité de Gopath: assurez-vous qu'un seul Gopath est en vigueur dans votre environnement, ou explicitement spécifié lorsqu'il est utilisé. Plusieurs chemins de gopath sont séparés par des colons (Linux / MacOS) ou des demi-finales (Windows), mais il est généralement recommandé de configurer un gopath principal pour un projet ou un workflow.
• Différences en mode modules GO: ce didacticiel se concentre principalement sur le mode Gopath. Si votre version GO (1.11) a des modules GO activés par défaut et que le projet a des modules activés, la méthode de gestion des dépendances sera différente. En mode Modules Go, le projet est généralement en dehors de Gopath, et les dépendances sont téléchargées dans le répertoire du fournisseur de GOPATH / PKG / MOD ou le répertoire racine du projet. Cependant, pour les codes source spécifiques qui ne peuvent pas être obtenus via GO GET, la méthode susmentionnée d'organisation manuelle GOPATH / SRC est toujours une solution efficace "de contournement", en particulier lorsque le code source doit être introduit comme un package local.
• Interprétation du message d'erreur:
  • Impossible de trouver le package "...": Le problème le plus courant est que la structure du répertoire ne correspond pas, et le compilateur Go ne peut pas trouver le fichier de code source correspondant en fonction du chemin d'importation. Veuillez vérifier attentivement si le chemin Gopath et le chemin de placement du code source correspond strictement.
  • Pas d'emplacement d'installation pour _ / e_ / mgo / bson: Cela signifie généralement que vous essayez d'exécuter GO Installer sous un chemin de package non standard, ou Gopath n'est pas réglé correctement. Assurez-vous que vous exécutez, allez installer dans le chemin de package correct sous GOPATH / SRC.

Résumer

Grâce à ce didacticiel, vous avez maîtrisé la méthode de téléchargement manuellement du code source de projet GO GO et l'installation locale lorsque la commande Go Get échoue. Le noyau est de définir correctement les variables d'environnement de Gopath et d'organiser strictement la structure du répertoire de code source local en fonction des règles d'importation du package GO. Suivez ces étapes pour gérer efficacement vos projets GO même face à des environnements de réseau complexes ou à des dépendances de projet spécifiques. Dans le développement de GO moderne, bien que les modules GO soient devenus courant, la compréhension du principe de travail de Gopath est toujours d'une grande valeur pour résoudre des problèmes dans des scénarios spécifiques.

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!