Construire les contraintes dans GO sont des commentaires spéciaux qui contr?lent l'inclusion des fichiers pendant la compilation en fonction de conditions telles que la plate-forme, l'architecture ou les balises personnalisées; Ils apparaissent comme // GO: Condition de construction avant la déclaration de package et de support des opérateurs logiques (&&, || ,!) Pour les expressions complexes. 1. Ils permettent un code spécifique à la plate-forme, tel que l'utilisation // go: construire Linux pour les fichiers Linux uniquement. 2. Ils permettent de cibler des architectures spécifiques, comme // GO: construire ARM64 pour les systèmes ARM64. 3. Les balises personnalisées prennent en charge les modes de construction, où Go Build -Tags Experimental comprend des fichiers avec // Go: Build Experimental. Le nouveau // GO: Build Syntax (Go 1.17) est préféré au style de construction ancien //, bien que les deux puissent coexister pour la compatibilité. GO évalue ces balises aux c?tés de celles implicites (Goos, Goarch, CGO), et des outils comme go list -f '{{.gofiles}}' -Tags Aide expérimentale Inspecter les fichiers inclus, donnant un contr?le précis sur la compilation conditionnelle de manière propre et maintenable.

Les contraintes de construction, également appelées balises de construction , sont des commentaires spéciaux dans les fichiers source GO qui contr?lent lorsqu'un fichier doit être inclus dans une version. Ce sont un moyen de compiler conditionnellement le code en fonction de l'environnement, de la plate-forme, de l'architecture ou des conditions personnalisées, sans modification de la structure du code.

Ils ressemblent à des commentaires en haut d'un fichier go (avant la déclaration package ), mais la cha?ne d'outils de Go l'interprète en tant que directives.

Syntaxe et placement

Une étiquette de construction ressemble à ceci:

 // Go: Construction de l'état

Remarque: il n'y a pas d'espace entre // et go:build . C'est important.

Il doit compara?tre devant l'instruction package , généralement près du haut du fichier. Vous pouvez avoir plusieurs balises de construction, mais généralement on suffit.

Exemple:

 // Go: construire Linux
package principal

// Ce fichier ne sera compilé que lors de la construction sur Linux.

Vous pouvez également combiner des conditions:

Ou utilisez logique ou:

La négation est également soutenue:

Cela signifie: incluez ce fichier à moins de construire pour Windows.

Cas d'utilisation courants

1. Code spécifique à la plate-forme

Vous pourriez avoir différentes implémentations pour différents systèmes d'exploitation.

• server_linux.go → //go:build linux
• server_darwin.go → //go:build darwin
• server_windows.go → //go:build windows

GO inclura uniquement le fichier approprié en fonction du système d'exploitation cible.

2. Contraintes d'architecture

Vous pouvez cibler des architectures CPU spécifiques:

Utile lors de l'utilisation d'optimisations de l'assemblage ou de bas niveau.

3. Modes de construction (Dev vs prod)

Vous pouvez définir des balises personnalisées pour des fonctionnalités telles que le mode de débogage ou les fonctionnalités expérimentales.

Puis construire avec:

 aller construire -tags expérimental

Cela inclut uniquement les fichiers qui ont //go:build experimental (ou combiner avec d'autres).

Vous pouvez également définir plusieurs balises:

 Allez construire -tags "Dev Debug"

Et dans le code:

Vieux vs nouveau style

Il existe deux styles de contraintes de construction:

Ancien style (toujours pris en charge):

 // construire Linux

Nouveau style (GO 1.17 recommandé):

La syntaxe //go:build est plus cohérente avec d'autres directives GO et prend en charge les expressions booléennes appropriées.

Même si vous utilisez le nouveau style, il est courant d'inclure le commentaire à l'ancienne pour la compatibilité en arrière avec des outils plus anciens:

 // Go: construire Linux
// construire Linux

Mais pour de nouveaux projets, utilisez simplement //go:build .

Comment aller évalue les balises de construction

Lorsque vous exécutez go build , la cha?ne d'outils vérifie toutes les balises de construction à travers les fichiers et ne comprend que celles qui correspondent à l'environnement de construction actuel et à tous -tags fournis.

Par défaut, Go définit des balises implicites comme:

• GOOS (par exemple, linux , darwin , windows )
• GOARCH (par exemple, amd64 , arm64 )
• cgo (si le cgo est activé)

Afin que vous puissiez écrire:

Et il se compilera sur Linux, FreeBSD, etc., mais pas MacOS ou Windows.

Conseils pratiques

• Utilisez des noms de fichiers descriptifs (par exemple, config_linux.go , util_test.go ) pour indiquer que les fichiers sont limités.
• évitez de trop utiliser des étiquettes personnalisées - Conservez les constructions prévisibles.
• Testez avec différentes combinaisons de balises si vous maintenez le code multiplateforme.
• Utilisez go list pour voir quels fichiers sont inclus:

 go list -f '{{.gofiles}}' -tags expérimental

Fondamentalement, les contraintes de construction vous donnent un contr?le à grain fin sur ce que le code est compilé, en laissant aller agir comme un langage multi-plate-forme sans macros de préprocesseur désordonné. Ils sont simples, puissants et largement utilisés dans les projets GO dans le monde réel.

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!