Syntaxe de base du langage Go

Dans le chapitre précédent, nous avons appris la composition et la structure de base du langage Go. Dans ce chapitre, nous allons apprendre la syntaxe de base du langage Go.

Jetons Go

Un programme Go peut être composé de plusieurs jetons, qui peuvent être des mots-clés, des identifiants, des constantes, des chaînes de caractères et des symboles. Par exemple, l'instruction Go suivante se compose de 6 jetons :

fmt.Println("Hello, World!")

Les 6 jetons sont (un par ligne) :

1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )

Séparateur de ligne

Dans un programme Go, une ligne représente la fin d'une instruction. Chaque instruction n'a pas besoin de se terminer par un point-virgule ; comme dans les autres langages de la famille C, car ces tâches sont automatiquement accomplies par le compilateur Go.

Si vous avez l'intention d'écrire plusieurs instructions sur la même ligne, elles doivent être séparées manuellement par ;, mais cette pratique n'est pas encouragée dans le développement réel.

Les deux instructions suivantes :

fmt.Println("Hello, World!")
fmt.Println("Example: example.com")

Commentaires

Les commentaires ne sont pas compilés, et chaque package doit avoir des commentaires associés.

Les commentaires sur une seule ligne sont la forme la plus courante de commentaires. Vous pouvez utiliser des commentaires sur une seule ligne commençant par // n'importe où. Les commentaires multilignes, aussi appelés commentaires de bloc, commencent tous par /* et se terminent par */. Par exemple :

// 单行注释
/*
 Author by Example
 我是多行注释
 */

Identificateurs

Les identifiants sont utilisés pour nommer des entités de programme telles que des variables et des types. Un identifiant est en fait une séquence composée d'une ou plusieurs lettres (A~Z et a~z), de chiffres (0~9) et de traits de soulignement _, mais le premier caractère doit être une lettre ou un trait de soulignement et ne peut pas être un chiffre.

Voici des identifiants valides :

mahesh   kumar   abc   move_name   a_123
myname50   _temp   j   a23b9   retVal

Voici des identifiants non valides :

1ab (commence par un chiffre)
case (un mot-clé du langage Go)
a+b (les opérateurs ne sont pas autorisés)

Concaténation de chaînes

La concaténation de chaînes en Go peut être effectuée via+Implémentation :

Exemple

package main
import "fmt"
func main() {
fmt.Println("Google" + "Example")
}

La sortie de l'exemple ci-dessus est :

GoogleExample

Mots-clés

La liste suivante répertorie les 25 mots-clés ou mots réservés qui seront utilisés dans le code Go :

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

En plus des mots-clés introduits ci-dessus, le langage Go possède également 36 identifiants prédéfinis :

append	bool	octet	cap	close	complexe	complex64	complex128	uint16
copy	false	float32	float64	imag	int	⟦0⟧	int16	uint32
int32	int64	iota	len	make	nouveau	nil	panic	uint64
print	println	real	recover	string	vrai	uint	uint8	uintptr

Un programme est généralement composé de mots-clés, de constantes, de variables, d'opérateurs, de types et de fonctions.

Le programme peut utiliser ces délimiteurs : les parenthèses (), les crochets [] et les accolades {}.

Le programme peut utiliser ces signes de ponctuation :.、,、;、:et…。

Les espaces blancs en Go

Dans le langage Go, les espaces sont généralement utilisés pour séparer les identificateurs, les mots-clés, les opérateurs et les expressions, ce qui améliore la lisibilité du code.

En Go, les déclarations de variables doivent être séparées par des espaces, par exemple :

var x int
const Pi float64 = 3.14159265358979323846

Utiliser des espaces entre les opérateurs et les opérandes peut rendre le programme plus facile à lire :

Pas d'espaces :

fruit=apples+oranges;

Ajouter des espaces entre les variables et les opérateurs rend le programme plus beau, par exemple :

fruit = apples + oranges;

Des espaces doivent être utilisés entre les mots-clés et les expressions.

Par exemple :

if x > 0 {
    // do something
}

Lors de l'appel d'une fonction, des espaces doivent être utilisés entre le nom de la fonction et le signe égal à gauche, ainsi qu'entre les paramètres.

Par exemple :

result := add(2, 3)

Formater une chaîne

En langage Go, utilisezfmt.Sprintfoufmt.Printfpour formater une chaîne et l'assigner à une nouvelle chaîne :

SprintfGénère une chaîne formatée selon les paramètres de formatage et renvoie la chaîne.
PrintfGénère une chaîne formatée selon les paramètres de formatage et l'écrit sur la sortie standard.

Exemple de Sprintf

package main

import (
"fmt"
)

func main() {
// %d représente un entier, %s représente une chaîne
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
var target_url=fmt.Sprintf(url,stockcode,enddate)
fmt.Println(target_url)
}

Le résultat de sortie est:

Code=123&endDate=2020-12-31

Exemple Printf

package main

import (
"fmt"
)

func main() {
// %d représente un entier, %s représente une chaîne
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
fmt.Printf(url,stockcode,enddate)
}

Le résultat de sortie est:

Code=123&endDate=2020-12-31

Pour plus de contenu, voir :

autres extensions