Syntaxe de base

La syntaxe de base du Go est très simple et facile à comprendre, commençons par un exemple très simple.

package main

import "fmt"

func main() {
   fmt.Println("Hello 世界!")
}

• Le mot-clé package déclare à quel paquet le fichier go actuel appartient. Le fichier d'entrée doit être déclaré comme paquet main, la fonction d'entrée est la fonction main. Lors de la personnalisation des paquets et des fonctions, les noms doivent éviter de se répéter avec ceux-ci.

• import est le mot-clé d'importation, suivi du nom du paquet importé.

• func est le mot-clé de déclaration de fonction, utilisé pour déclarer une fonction.

• fmt.Println("Hello 世界!") est une instruction qui appelle la fonction Println du paquet fmt pour effectuer une sortie.

Voici une introduction simple à la syntaxe, passons maintenant aux concepts de manière plus détaillée.

Paquet

En Go, les programmes sont construits en liant des paquets ensemble. L'unité de base pour l'importation en Go est un paquet, et non un fichier .go. Un paquet est en fait un dossier, nommé package en anglais. Le paquet partage toutes les variables, constantes et tous les types définis. Le style de nommage des paquets suggère d'utiliser des lettres minuscules et d'être aussi court que possible.

Visibilité

Comme mentionné précédemment, un paquet partage toutes les variables, constantes et tous les types définis en interne, mais ce n'est pas le cas pour l'extérieur du paquet. Parfois, vous ne voulez pas que d'autres accèdent à un certain type, il est donc nécessaire de contrôler la visibilité. Vous avez peut-être vu des mots-clés comme Public, Private dans d'autres langages OOP, mais il n'y a pas de tels mots-clés en Go. La manière dont Go contrôle la visibilité est très simple, les règles sont les suivantes :

• Un nom commençant par une lettre majuscule est un type/variable/constante public
• Un nom commençant par une lettre minuscule ou un underscore est un type/variable/constante privé

Par exemple, dans l'exemple ci-dessous, la constante MyName est publique, tandis que la constante mySalary est privée.

package example

// Public
const MyName = "jack"

// Privé
const mySalary = 20_000

Cette règle de visibilité s'applique partout dans le langage Go.

Importation

Importer un paquet pour utiliser les types/méthodes/fonctions/variables de ce paquet. La syntaxe d'importation est import suivi du nom du paquet.

package main

import "example"

Lors de l'importation de plusieurs paquets, vous pouvez écrire ainsi :

package main

import "example"
import "example1"

Ou les regrouper avec des parenthèses, cette méthode est plus couramment utilisée dans la pratique.

package main

import (
  "example"
  "example1"
)

Si des noms de paquets sont en double ou si les noms de paquets sont complexes, vous pouvez également leur donner des alias.

package main

import (
  e "example"
  e1 "example1"
)

Lorsque l'alias est un underscore _, il s'agit d'une importation anonyme. Le paquet importé anonymement ne peut pas être utilisé. Cela est généralement fait pour charger la fonction init du paquet, mais sans avoir besoin d'utiliser les types du paquet. Un exemple courant est l'enregistrement de pilotes de base de données, mais vous n'avez pas besoin d'utiliser manuellement le pilote.

package main

import (
  e "example"
  _ "mysql-driver-go"
)

Après avoir importé, pour accéder aux types du paquet, utilisez nom_paquet.identifiant. Par exemple, dans l'exemple ci-dessous, si vous essayez d'accéder à un type privé, le compilateur vous indiquera que l'accès est impossible.

package main

import (
  "example"
   "fmt"
)

func main() {
    fmt.Println(example.MyName)
}

Il existe une manière spéciale d'importer qui consiste à importer tous les types du paquet dans le champ d'application du paquet actuel. Avec cette méthode d'importation, les types n'ont plus besoin de l'opérateur . pour être accédés, mais s'il y a des types avec des noms identiques, la compilation échouera.

package main

import (
  . "example"
)

WARNING

Il est impossible d'avoir une importation circulaire en Go, qu'elle soit directe ou indirecte. Par exemple, si le paquet A importe le paquet B, et que le paquet B importe également le paquet A, il s'agit d'une importation circulaire directe. Si le paquet A importe le paquet C, que le paquet C importe le paquet B, et que le paquet B importe à nouveau le paquet A, il s'agit d'une importation circulaire indirecte. En cas d'importation circulaire, la compilation échouera.

Paquet interne

En Go, par convention, un paquet nommé internal dans un paquet est un paquet interne. Les paquets externes ne pourront accéder à aucun contenu du paquet interne, sinon la compilation échouera. Voici un exemple.

/home/user/go/
    src/
        crash/
            bang/              (code go dans le paquet bang)
                b.go
        foo/                   (code go dans le paquet foo)
            f.go
            bar/               (code go dans le paquet bar)
                x.go
            internal/
                baz/           (code go dans le paquet baz)
                    z.go
            quux/              (code go dans le paquet main)
                y.go

D'après la structure de fichiers, le paquet crash ne peut pas accéder aux types du paquet baz.

Commentaires

Go prend en charge les commentaires sur une seule ligne et les commentaires sur plusieurs lignes. Il est recommandé d'ajouter un espace entre les commentaires et le contenu, par exemple :

// Ceci est le paquet main
package main

// Importation du paquet fmt
import "fmt"

/*
*
Ceci est la fonction de démarrage main
*/
func main() {
  // Ceci est une instruction
  fmt.Println("Hello 世界!")
}

Identifiants

Un identifiant est un nom utilisé pour nommer les paquets, les fonctions, les variables, etc. Les règles de nommage sont les suivantes :

• Ne peut être composé que de lettres, de chiffres et de underscores
• Ne peut commencer que par une lettre ou un underscore
• Distingue strictement les majuscules et les minuscules
• Ne peut pas être identique à tout identifiant existant, c'est-à-dire unique dans le paquet
• Ne peut pas entrer en conflit avec les mots-clés intégrés de Go

Ci-dessous sont listés tous les mots-clés intégrés. Vous pouvez également consulter le Manuel de référence - Identifiants pour plus de détails.

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Opérateurs

Voici la hiérarchie des opérateurs pris en charge par le langage Go. Vous pouvez également consulter le Manuel de référence - Opérateurs pour plus de détails.

Précédence    Opérateur
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

Une petite remarque importante : Go n'utilise pas ~ comme opérateur de négation, mais réutilise le symbole ^. Lorsque ^ est utilisé entre deux nombres, par exemple a^b, c'est l'opérateur XOR. Lorsqu'il est utilisé sur un seul nombre, par exemple ^a, c'est l'opérateur de négation. Go prend également en charge les opérateurs d'affectation augmentée, comme suit :

a += 1
a /= 2
a &^= 2

TIP

Le langage Go n'a pas d'opérateurs d'auto-incrémentation et d'auto-décrémentation. Ils ont été rétrogradés au rang d'instructions statement, et il est stipulé qu'ils doivent être placés après l'opérande. Vous n'avez donc plus à vous soucier de la différence entre i++ et ++i.

a++ // Correct
++a // Erreur
a-- // Correct

Une autre chose à noter est qu'ils n'ont plus de valeur de retour, donc des expressions comme a = b++ sont incorrectes.

Littéraux

Un littéral, selon la terminologie de l'informatique, est un symbole utilisé pour exprimer une valeur fixe dans le code source, également appelé valeur littérale. Les deux termes signifient la même chose : ce qui est écrit est la valeur, la valeur est la valeur "au sens littéral".

Littéraux entiers

Pour faciliter la lecture, l'underscore _ est autorisé pour séparer les chiffres, mais uniquement après le signe préfixe et entre les chiffres.

24 // 24
024 // 24
2_4 // 24
0_2_4 // 24
10_000 // 10k
100_000 // 100k
0O24 // 20
0b00 // 0
0x00 // 0
0x0_0 // 0

Littéraux flottants

Différents préfixes permettent d'exprimer des nombres flottants dans différentes bases.

0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (soustraction entière)

Littéraux complexes

0i
0123i         // == 123i
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

Littéraux de caractères

Les littéraux de caractères doivent être entourés de guillemets simples ''. Les caractères en Go sont entièrement compatibles avec utf8.

'a'
'ä'
'你'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'

Caractères d'échappement

Caractères d'échappement disponibles en Go :

\a   U+0007 caractère de sonnerie
\b   U+0008 caractère de retour arrière
\f   U+000C caractère de saut de page
\n   U+000A caractère de nouvelle ligne
\r   U+000D caractère de retour chariot
\t   U+0009 caractère de tabulation horizontale
\v   U+000B caractère de tabulation verticale
\\   U+005C échappement de barre oblique inverse
\'   U+0027 échappement de guillemet simple (cet échappement n'est valide qu'à l'intérieur des caractères)
\"   U+0022 échappement de guillemet double (cet échappement n'est valide qu'à l'intérieur des chaînes)

Littéraux de chaînes

Les littéraux de chaînes doivent être entourés de guillemets doubles "" ou d'accent grave ` (les chaînes avec accent grave ne permettent pas l'échappement).

`abc`                // "abc"
`\n
\n`                  // "\\n\n\\n"
"\n"
"\""                 // `"`
"Hello, world!\n"
"今天天气不错"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"

Fonctions

La déclaration de fonction en Go se fait via le mot-clé func, similaire à la plupart des langages.

func main() {
  println(1)
}

Cependant, il y a deux différences dans les fonctions en Go. La première est que le type des paramètres vient après le nom, comme ci-dessous :

func Hello(name string) {
  fmt.Println(name)
}

La deuxième différence est la possibilité de retourner plusieurs valeurs, et elles peuvent avoir des noms.

func Pos() () (x, y float64) {
    ...
}

Style

En ce qui concerne le style de codage, Go impose un style uniforme à tous. Go fournit un outil de formatage gofmt qui peut être utilisé via la ligne de commande. Cet outil de formatage n'a aucun paramètre de formatage à transmettre ; les deux seuls paramètres disponibles affichent simplement le processus de formatage. Il ne prend donc pas en charge la personnalisation. Cela signifie que tout le code formaté avec cet outil aura le même style, ce qui réduira considérablement la charge cognitive des mainteneurs. Par conséquent,追求 la personnalité dans ce domaine n'est pas un choix judicieux.

Voici quelques règles simples à suivre lors de l'écriture de code.

Saut de ligne des accolades de fonction

La question de savoir s'il faut sauter une ligne après l'accolade d'une fonction est un débat que chaque programmeur peut justifier. En Go, aucune accolade ne doit être sur une nouvelle ligne.

// Exemple correct
func main() {
  fmt.Println("Hello 世界!")
}

Si vous faites ainsi, comme ci-dessous :

// Exemple incorrect
func main()
{
  fmt.Println("Hello 世界!")
}

Un tel code ne passera même pas la compilation, donc Go impose à tous les programmeurs de ne pas sauter de ligne après l'accolade de la fonction.

Indentation du code

Go utilise par défaut la tabulation Tab pour l'indentation, et n'utilise des espaces que dans certaines situations particulières.

Espacement du code

La plupart des espacements en Go ont un sens. Dans une certaine mesure, cela représente la façon dont le compilateur voit votre code. Par exemple, pour l'opération mathématique suivante :

2*9 + 1/3*2

Comme on le sait, la multiplication a une priorité plus élevée que l'addition. Après le formatage, l'espacement entre les symboles * sera plus compact, ce qui signifie qu'ils sont exécutés en premier. L'espacement autour du symbole + sera plus grand, ce qui signifie qu'il est exécuté plus tard.

Omission des accolades

Dans d'autres langages, les instructions if et for peuvent généralement être abrégées, comme ci-dessous :

for (int i=0; i < 10; i++) printf("%d", i)

Mais pas en Go. Vous pouvez écrire une seule ligne, mais vous devez ajouter des accolades.

for i := 0; i < 10; i++ {fmt.Println(i)}

Expression ternaire

Go n'a pas d'expression ternaire, donc le code suivant ne passera pas la compilation :

var c = a > b ? a : b

À travers cet article, vous pouvez avoir une compréhension préliminaire de la syntaxe de Go. Les sections suivantes développeront plus en détail.