Table des matières
- 1. accéder aux notes de travail (espace de travail multi-modules)
-
- 1.1. Qu'est-ce qu'aller travailler ?
- 1.2. go work prend en charge les commandes
- 1.3.Structure du fichier go.work
- 1.4.use spécifie le répertoire du module à utiliser
- 1.5. remplace remplace l'adresse de l'entrepôt dépendant
- 1.6. La priorité du fichier go.work est supérieure à celle définie dans go.mod
- 1.7. Comment utiliser
- 1.8. Comment désactiver un espace de travail
- 1.9. Démonstration du processus de développement
- 1.10. Résumé
1. accéder aux notes de travail (espace de travail multi-modules)
1.1. Qu'est-ce qu'aller travailler ?
go 1.18 introduit les génériques fonctionnels (Generics), ainsi que les espaces de travail multi-modules (Workspaces) et le fuzzing (Fuzzing).
L'espace de travail multi-modules Go permet aux développeurs de travailler plus facilement sur plusieurs modules en même temps, tels que :
- Pratique pour le débogage du code dépendant (points d'arrêt, modifications de code) et le dépannage des bogues de code dépendants
- Facilite le développement et le débogage parallèles de plusieurs entrepôts/modules en même temps
1.2. go work prend en charge les commandes
- Normalement, il est recommandé de ne pas soumettre
go.work
de fichiers à git car il est principalement utilisé pour le développement de code local ; $GOPATH
Il est recommandé d'exécuter sous le chemin : pour générergo.work
les fichiersgo work init
Initialiser le fichier d'espace de travail, utilisé pour générergo.work
le fichier d'espace de travail
Initialisez et écrivez-en un nouveau go.work
dans le chemin actuel. Vous pouvez spécifier les modules de code qui doivent être ajoutés.
Exemple : go work init ./hello
Ajouter l'entrepôt local hello à l'espace de travail.
L'entrepôt hello doit être un entrepôt de gestion des dépendances go mod ( ./hello/go.mod
le fichier doit exister )
- go work use ajoute de nouveaux modules à l'espace de travail
Exemple de commande :
go work use ./example 添加一个模块到工作区
go work use ./example ./example1 添加多个模块到工作区
go work use -r ./example 递归 ./example 目录到当前工作区
删除命令使用 go work edit -dropuse=./example 功能
go work edit
pour éditergo.work
des fichiers
Vous pouvez utiliser edit
la commande pour modifier le fichier et modifier manuellement go.work
le fichier. L'effet est le même, exemple :
go work edit -fmt go.work 重新格式化 go.work 文件
go work edit -replace=github.com/link1st/example=./example go.work 替换代码模块
go work edit -dropreplace=github.com/link1st/example 删除替换代码模块
go work edit -use=./example go.work 添加新的模块到工作区
go work edit -dropuse=./example go.work 从工作区中删除模块
-
go work sync
Synchroniser la liste de build d'un espace de travail avec les modules de l'espace de travail -
go env GOWORK
Vérifiez les variables d'environnement et vérifiez le chemin du fichier d'espace de travail actuel pour vérifier si le fichier d'espace de travail est défini correctement. Si go.work
le chemin n'est pas trouvé, vous pouvez utiliser GOWORK
spécifier
> go env GOWORK
$GOPATH/src/link1st/link1st/workspaces/go.work
1.3.Structure du fichier go.work
- La structure du fichier est similaire à la structure du fichier go.mod. Elle prend en charge le numéro de version Go, l'espace de travail spécifié et l'entrepôt qui doivent être remplacés. Exemple de structure de fichier :
go 1.18
use (
./hello
./example
)
replace (
github.com/link1st/example => ./example1
)
1.4.use spécifie le répertoire du module à utiliser
- Vous pouvez utiliser go work use hello pour ajouter des modules, ou vous pouvez modifier manuellement l'espace de travail go.work pour ajouter de nouveaux modules. Le chemin du module est ajouté à l'espace de travail. Lors de la compilation, le code local utilisé sera automatiquement utilisé pour la compilation du code. , et la fonction de remplacement est similaire.
# 单模块结构
use ./hello
# 多模块结构
use (
./hello
./example
)
1.5. remplace remplace l'adresse de l'entrepôt dépendant
- La commande replace est la même que la commande go.mod et est utilisée pour remplacer l'adresse de l'entrepôt dont dépend le projet. Il convient de noter que replaces et use ne peuvent pas spécifier le même chemin local en même temps.
Voici la version :
go : le module d'espace de travail http://github.com/link1st/example est remplacé dans toutes les versions du fichier go.work. Pour résoudre le problème, supprimez le remplacement du fichier go.work ou spécifiez la version à laquelle remplacer le module.
- Exemple d'erreur
Spécifiez le même chemin local utilisé et remplacez-le en même temps
aller 1.18
use (
./hello
./example
)
replace (
github.com/link1st/example => ./example
)
1.6. La priorité du fichier go.work est supérieure à celle définie dans go.mod
- Lorsque vous utilisez go.work et go.mod replace fonctions en même temps, spécifiez respectivement différents chemins d'entrepôt de code. La priorité de go.work est supérieure à celle définie dans go.mod.
Remplacez la définition dans go.mod par l'exemple de l'entrepôt local
replace (
github.com/link1st/example => ./example1
)
Remplacez la définition dans go.work par l'exemple d'entrepôt local1
replace (
github.com/link1st/example => ./example1
)
- Lors de la construction du code, le code de l'entrepôt exemple1 spécifié par go.work est utilisé et go.work a une priorité plus élevée.
1.7. Comment utiliser
- Dans Go 1.18, go run et go build utiliseront la fonction d'espace de travail par défaut. GOWORK peut également spécifier l'emplacement du fichier go.work.
export GOWORK="~/go/src/test/go.18/workspace/go.work"
1.8. Comment désactiver un espace de travail
- La variable globale Go GOWORK est désactivée pour désactiver la fonction d'espace de travail.
exporter GOWORK=off
1.9. Démonstration du processus de développement
-
Montre comment utiliser la fonctionnalité d’espace de travail multimodule. À l'ère actuelle où les microservices sont répandus, une seule personne gère plusieurs entrepôts de codes. Dans de nombreux cas, plusieurs entrepôts sont développés simultanément.
-
Supposons que nous développons actuellement l'entrepôt hello. La fonction implémentée consiste à inverser la chaîne d'entrée et à la sortir. La fonction d'inversion de chaîne repose sur l'implémentation de l'entrepôt public de http://github.com/link1st/example (ci-après collectivement appelés à titre d'exemple)
-
Créer un nouveau projet bonjour
mkdir hello
cd hello
# 代码仓库启动 go mod 依赖管理, 生成 go.mod 文件
go mod init github.com/link1st/link1st/workspaces/hello
# 下载依赖包
go get github.com/link1st/example
# 编写 main 文件
vim main.go
- code main.go
// Package main main 文件, go 多模块工作区演示代码
// 实现将输入的字符串反转输出并输出
package main
import (
"flag"
"fmt"
"github.com/link1st/example/stringutil"
)
var (
str = ""
)
func init() {
flag.StringVar(&str, "str", str, "输入字符")
flag.Parse()
}
func main() {
if str == "" {
fmt.Println("示例: go run main.go -str hello")
fmt.Println("str 参数必填")
flag.Usage()
return
}
// 调用公共仓库, 进行字符串反转
str = stringutil.Reversal(str)
// 输出反转后的字符串
fmt.Println(str)
return
}
- Exécutez le code go run main.go -str "hello world" ou allez run github.com/link1st/link1st/workspaces/hello -str "hello world". Vous pouvez voir que la chaîne inversée de hello world est affichée.
> go run main.go -str "hello world"
dlrow olleh
- À ce stade, la fonction initiale est terminée, mais les changements ultérieurs dans les exigences nécessitent non seulement de sortir la chaîne inversée, mais également de mettre la chaîne en majuscule.Nous devons ensuite ajouter et développer la fonction de mise en majuscule de la chaîne dans l'exemple d'entrepôt.
# 回到工作根目录, 将 common 代码下载到本地进行添加新的功能
# 下载依赖的 example 包
git clone [email protected]:link1st/example.git
# 在 example 包中添加 字符串大学的功能
- vim example/stringutil/to_upper.go le code est le suivant
// Package stringutil stringutil
package stringutil
import (
"unicode"
)
// ToUpper 将字符串进行大写
func ToUpper(s string) string {
r := []rune(s)
for i := range r {
r[i] = unicode.ToUpper(r[i])
}
return string(r)
}
-
Étant donné que le code est toujours en cours de débogage localement et n'a pas été soumis au référentiel git, vous devez utiliser la fonction d'espace de travail multi-module Go pour le moment.
-
Entrez dans le répertoire racine du projet et initialisez le module que nous développons actuellement
# 初始化 go.work 文件
go work init ./hello ./example
# 查看 go.work 文件内容
cat go.work
- La structure du fichier est la suivante
go 1.18
use (
./example
./hello
)
- De retour au projet hello, vim main.go ajoute la fonction de capitalisation des chaînes.
func main() {
...
// 调用公共仓库, 进行字符串反转
str = stringutil.Reversal(str)
// 增加字符大写的功能
str = stringutil.ToUpper(str)
// 输出反转后的字符串
fmt.Println(str)
...
}
- exécuter le code
Vous pouvez voir que la chaîne inversée et majuscule est sortie. La fonction majuscule est uniquement locale et n'est pas soumise à git. De cette façon, nous pouvons développer deux modules en parallèle en même temps.
go run main.go -str "hello world"
DLROW OLLEH
- À ce stade, le code de démonstration est terminé
1.10. Résumé
- L'utilisation de la fonction de l'espace de travail multi-modules de Go nous permet de basculer facilement le travail entre plusieurs modules et est plus adaptable au développement d'une architecture de microservices moderne.