Golang : bases
Paquets
<syntaxhighlight lang="go"> package main
import ( "fmt" "math/rand" )
func main() { fmt.Println("My favorite number is", rand.Intn(10)) } </syntaxhighlight>
Les programmes sont composés de paquets; ils commencent l'éxecution dans le paquet main. Le programme ci-dessus utilise fmt et math/rand; par convention, le nom du paquet est le même que le dernier élément du chemin d'importation. Par exemple, le paquet "math/rand" comprend les fichiers qui commencent avec la déclaration du paquet rand.
imports
Une bonne pratique consiste à factoriser les imports:
<syntaxhighlight lang="go"> import ( "fmt" "math" ) </syntaxhighlight>
Identifiants exportés
Un élément est exporté d'un paquet si il commence par une majuscule (en python, je peux faire random.randint et randint sera exporté; en Go, il faudra faire math.Pi pour accéder à l'identifiant "pi").
Fonctions
Une fonction peut prendre 0 ou plusieurs arguments; la déclaration se fait en *nom_variable* type_variable :
<syntaxhighlight lang="go"> package main
import "fmt"
func add(x int, y int) int { return x + y }
func main() { fmt.Println(add(42, 13)) }
//En détail //func est le mot clef des fonctions //Les variables sont renvoyées par valeur *dans le cas présent, en tout cas* //Si plusieurs retours, utiliser des parenthèses
func nom_fonction(entrée1 type, entrée2 type) type_retour {
opérations
return valeur
}
//Quand on déclare plusieurs variables du même type, on peut ne mettre le type qu'à la fin : func add(x, y int) int { return x + y }
//Exemple de retour multiple func swap(x, y string) (string, string) { return y, x }
func main() { a, b := swap("hello", "world") fmt.Println(a, b) }
//On peut renvoyer les valeurs comme étant nommées //Ce qui est encouragé dans les fonctions de plus de quelques lignes //Je ne sais pas si c'est une référence ou simplement une nouvelle assignation func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return }
func main() { fmt.Println(split(17)) }
</syntaxhighlight>
Variables
L'instruction var déclare une liste de variables, comme dans les listes d'arguments de fonction, le type est en dernier.
Une instruction var peut être au niveau du paquet ou au niveau de la fonction. On voit les deux dans cet exemple.
<syntaxhighlight lang="go"> package main
import "fmt"
var c, python, java bool
func main() { var i int fmt.Println(i, c, python, java) } </syntaxhighlight>
Initialisation
On peut initialiser les variables directement (une initialisation par variable). Si c'est le cas, préciser le type est facultatif:
<syntaxhighlight lang="go">
var i, j int = 1, 2
func main() { var c, python, java = true, false, "no!" fmt.Println(i, j, c, python, java) } </syntaxhighlight>
Initialisation courte
- Dans une fonction*, on peut initialiser une variable de façon courte avec l'opérateur :=
<syntaxhighlight lang="go"> func main() { var i, j int = 1, 2 k := 3 c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java) } </syntaxhighlight>
Types de base
Les types de base, proches du C, sont:
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias pour uint8
rune // alias pour int32
// représente un "code point" Unicode
float32 float64
complex64 complex128
Un exemple auquel je ne comprend pas tout:
<syntaxhighlight lang="go"> package main
import ( "fmt" "math/cmplx" )
var ( ToBe bool = false MaxInt uint64 = 1<<64 - 1 z complex128 = cmplx.Sqrt(-5 + 12i) )
func main() { const f = "%T(%v)\n" fmt.Printf(f, ToBe, ToBe) fmt.Printf(f, MaxInt, MaxInt) fmt.Printf(f, z, z) } </syntaxhighlight>
Valeur 0
Une variable déclarée mais pas initialisée reçoit une valeur dite 0:
- 0 pour les types numériques
- False pour un bool
- "" Pour un str
Conversions de types
L'expression T(v) convertit la valeur v au type T.
Quelques conversions numériques :
var i int = 42 var f float64 = float64(i) var u uint = uint(f)
Ou, plus simplement :
i := 42 f := float64(i) u := uint(f)
Contrairement au C, en Go l'affectation entre les éléments de type différent exige une conversion explicite.
<syntaxhighlight lang="go">
func main() {
var x, y int = 3, 4
var f float64 = math.Sqrt(float64(x*x + y*y))
var z uint = uint(f)
fmt.Println(x, y, z)
}
</syntaxhighlight>
Inférence de type
Lors de la déclaration d'une variable sans préciser un type explicite (soit en utilisant la syntaxe := ou var =), le type de la variable est déduit de la valeur sur le côté droit.
Lorsque le côté droit de la déclaration est typé, la nouvelle variable est de ce même type :
var i int j := i // j est un entier
Mais quand le côté droit contient une constante numérique non typée, la nouvelle variable peut être un int , float64, ou complex128 en fonction de la précision de la constante :
i := 42 // int f := 3.142 // float64 g := 0.867 + 0.5i // complex128
Constantes
Les constantes sont déclarées comme des variables, mais avec le mot-clé const.
Les constantes peuvent être un caractère, une chaîne, un booléen, ou des valeurs numériques.
Les constantes ne peuvent pas être déclarées en utilisant la syntaxe := .
<syntaxhighlight lang="go">
package main
import "fmt"
const Pi = 3.14
func main() { const World = "世界" fmt.Println("Hello", World) fmt.Println("Happy", Pi, "Day")
const Truth = true fmt.Println("Go rules?", Truth) } </syntaxhighlight>
Constantes numériques
Les constantes numériques sont des valeurs de haute précision. Une constante non typée prend le type requis par son contexte. (Un int peut stocker au maximum un entier de 64 bits et parfois moins.)
Pas tout compris...
<syntaxhighlight lang="go> package main
import "fmt"
const ( Big = 1 << 100 Small = Big >> 99 )
func needInt(x int) int { return x*10 + 1 } func needFloat(x float64) float64 { return x * 0.1 }
func main() { fmt.Println(needInt(Small)) fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) } </syntaxhighlight>