Table des matières

1. accéder aux notes de travail (espace de travail multi-modules)

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.workde fichiers à git car il est principalement utilisé pour le développement de code local ;
$GOPATHIl est recommandé d'exécuter sous le chemin : pour générer go.workles fichiers
go work initInitialiser le fichier d'espace de travail, utilisé pour générer go.workle fichier d'espace de travail

Initialisez et écrivez-en un nouveau go.workdans le chemin actuel. Vous pouvez spécifier les modules de code qui doivent être ajoutés.
Exemple : go work init ./helloAjouter 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.modle 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 editpour éditer go.workdes fichiers

Vous pouvez utiliser editla commande pour modifier le fichier et modifier manuellement go.workle 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 syncSynchroniser 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.workle chemin n'est pas trouvé, vous pouvez utiliser GOWORKspé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.

aller aux notes de travail (espace de travail multi-modules)