Le langage Go a-t-il une indentation ?

La langue Go a une indentation. Dans le langage Go, l'indentation peut être formatée directement à l'aide de l'outil gofmt (gofmt utilise des onglets pour l'indentation) ; l'outil gofmt formatera le code source avec une indentation de style standard et un alignement vertical, et même les commentaires si nécessaire seront reformatés.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Style de code de langue Go

(1) Indentation et sauts de ligne

L'indentation peut être formatée directement à l'aide de l'outil gofmt (gofmt utilise l'indentation par tabulation). gofmt est un outil qui formate le code source avec des styles standard d'indentation et d'alignement vertical, et même les commentaires sont reformatés si nécessaire.

En termes de sauts de ligne, la longueur maximale d'une ligne ne doit pas dépasser 120 caractères. Si elle dépasse, veuillez utiliser des sauts de ligne pour afficher et essayer de garder le format aussi élégant que possible

Nous utilisons l'outil de développement GoLand et simplement utilisez la touche de raccourci : Ctrl+Alt+L.

(2) La fin de l'instruction

En langage Go, il n'est pas nécessaire de terminer par un point-virgule similaire à Java. Par défaut, une ligne est une donnée.

Si vous prévoyez d'écrire plusieurs déclarations sur la même ligne, elles doivent être utilisées.

(3) Crochets et espaces

En termes de crochets et d'espaces, vous pouvez également utiliser directement l'outil gofmt pour formater (go forcera l'accolade gauche à ne pas s'enrouler, et l'enroulement provoquera une erreur de syntaxe), parmi tous les opérateurs et opérandes Laissez des espaces entre.

//正确的方式
if a > 0 {

}
//错误的方式
if a>0  // a,>,0之间应该使用空格
{       //左大括号不可以换行，会报语法错误
	
}

(4) Spécifications de l'import

Dans le cas de plusieurs lignes d'import, goimports le formatera automatiquement pour vous. Si vous introduisez un package dans un fichier, il est recommandé d'utiliser le format suivant :

import {
	"fmt"
}

. Si votre package présente trois types de packages, des packages de bibliothèque standard, des packages internes au programme et des packages tiers, il est recommandé d'organiser vos packages de la manière suivante

inport{
	"encoding/json"
	"strings"
	
	"myproject/models"
	"myproject/controller"
	
	"github.com/astaxie/beego"
}

Introduisez les packages dans l'ordre. Le premier est en fait la quasi-bibliothèque, le deuxième est le package du projet et le troisième est le package tiers. [Recommandations associées : Tutoriel vidéo Go]

N'utilisez pas de chemins relatifs pour introduire des packages dans le projet

(5) Gestion des erreurs

Le principe de la gestion des erreurs est de ne pas ignorer tout appel qui renvoie une erreur, faites n'utilisez pas _discard , tout doit être traité. Lorsque vous recevez une erreur, renvoyez l'erreur ou utilisez le journal pour l'enregistrer

• Retournez dès que possible : Une fois qu'une erreur se produit, revenez immédiatement

• Essayez de ne pas paniquer à moins de savoir ce que vous faites

• Description de l'erreur s'il doit être en minuscules en anglais et ne nécessite pas de terminaisons de ponctuation

• Utilisez un flux d'erreurs indépendant pour le traitement

// 错误写法
if err != nil {
	// error handing
} else {
	//normal code
}

// 正确写法
if err != nil {
	// error handing
	return // or continue, etc.
}
//  normal code

(6) Test

La convention de dénomination des fichiers de test unitaire est example_test. go

Le nom de la fonction du scénario de test Test doit être utilisé pour chaque fonction importante. Les cas de test doivent être écrits en premier. Les cas de test sont soumis avec le code normal pour faciliter les tests de régression en langage go

.

gofmt est une commande distincte utilisée pour formater le code source de Go. Il utilise des onglets pour l'indentation et des espaces pour l'alignement. L'alignement suppose que l'éditeur utilise une police à largeur fixe. Si aucun chemin n'est explicitement spécifié, il traitera l'entrée standard ; étant donné un fichier, il traitera ce fichier ; étant donné un dossier, il traitera de manière récursive tous les fichiers .go du dossier (sauf les fichiers cachés). Par défaut, gofmt imprimera le code reformaté sur la sortie standard (plutôt que de mettre à jour directement le fichier source). L'utilisation est la suivante :

gofmt [flags] [path ...]

les drapeaux sont les suivants :

-d Le code reformaté n'est plus imprimé sur la sortie standard. Si le format du code du fichier n'est pas cohérent avec gofmt, imprimez la différence sur la sortie standard (cet indicateur est similaire à la commande git diff).

-e Imprimez toutes les erreurs (y compris les fausses).
-l Le code reformaté n'est plus imprimé sur la sortie standard. Si le format du code de fichier n'est pas cohérent avec gofmt, imprimez le nom du fichier sur la sortie standard. La règle
-r applique la règle de réécriture spécifiée avant de reformater le fichier source.
-s Après avoir appliqué les règles (le cas échéant), essayez de simplifier le code.
-w Le code reformaté n'est plus imprimé sur la sortie standard. Si le format du code du fichier n'est pas cohérent avec gofmt, utilisez la version gofmt pour la réécriture. Si une erreur se produit pendant le processus de réécriture, les fichiers originaux seront restaurés à l'aide d'une sauvegarde automatique.
Prise en charge du débogage :
-cpuprofile filename Écrit cpuprofile dans le fichier spécifié.

Remarque : La règle de réécriture spécifiée par l'indicateur -r doit être sous forme de chaîne :

• Le modèle et les pièces de remplacement doivent être une expression Go valide. Dans le modèle, les identifiants minuscules à un seul caractère sont utilisés comme caractères génériques pour correspondre à toutes les sous-expressions qui seront remplacées par le même identifiant en remplacement.

当gofmt从标准输入读取时，即接受一个完整的Go程序，也可以是一个程序片段。程序片段必须是语法上有效的声明列表，语句列表或表达式。格式化这种片段时，gofmt会保留前导缩进和前后的空格，以便Go程序的各个部分可以通过gofmt来格式化。

示例

假设源文件(hello.go)内容如下：

package main

import "fmt"

func main() {

    x := 2
y := 3// 该行未对齐

    str := "Hello Golang~"
    var greeting string

    greeting = (str)// 本行含有不必要的括号

    fmt.Println(greeting)
    fmt.Println("x*y =", ((x) * y))// 本行含有不必要的括号

    s := []int{1, 3, 5, 6, 7}// 切片

    start := 2

    sub := s[start:len(s)]// 本行可以优化切片s上界

    fmt.Println(s)
    fmt.Println(sub)
}

1.检查文件中不必要的括号（如果有，则输出文件名）：

gofmt -r '(a) -> a' -l *.go

将会输出hello.go

2.移除括号：

gofmt -r '(a) -> a' -w *.go

源文件将变成如下格式：

package main

import "fmt"

func main() {

    x := 2
    y := 3 // 该行未对齐

    str := "Hello Golang~"
    var greeting string

    greeting = str // 本行含有不必要的括号

    fmt.Println(greeting)
    fmt.Println("x*y =", x*y) // 本行含有不必要的括号

    s := []int{1, 3, 5, 6, 7} // 切片

    start := 2

    sub := s[start:len(s)] // 本行可以优化切片s上界

    fmt.Println(s)
    fmt.Println(sub)
}

注意看带注释的行发生的变化。

3.当前目录下，从显式切片上界转换为隐式切片上界：

gofmt -r 'α[β:len(α)] -> α[β:]' -w ./

源文件第22行将变成如下：

    sub := s[start:] // 本行可以优化切片上限

代码简化

使用-s调用gofmt时，将尽可能进行以下转换：

以下数组，切片或映射的复合字面量形式:

    []T{T{}, T{}}

将被简化为:

    []T{{}, {}}

以下切片表达式形式:

    s[a:len(s)]

将被简化为:

    s[a:]

以下range形式:

    for x, _ = range v {...}

将被简化为:

    for x = range v {...}

以下range形式:

    for _ = range v {...}

将被简化为:

    for range v {...}

注意：这些改变可能与早期版本的Go不兼容。另外，官方文档中指出：

• -r标识性能有点慢；

• -w如果失败，还原后的源文件可能会丢失某些文件属性。

更多编程相关知识，请访问：编程视频！！

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!