===================
Détails syntaxiques
===================
.. index::
single: Go Syntaxe
single: Go; Go Syntaxe
.. contents:: :depth: 3
:backlinks: top
####
--------------
Aperçu globale
--------------
:Liens_Web:
* `Apprendre X en Y minutes`_ : Ensemble de code commentée en français permettant d'avoir un
apperçu concis de l'ensemble des éléments de syntaxe du language.
.. _`Apprendre X en Y minutes`: https://learnxinyminutes.com/docs/fr-fr/go-fr/
####
------------
Basic Types
------------
Il y a 17 types de bases et 2 alias :
* bool
* string
* int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
.. note::
**int** et **uint** doivent être utilisés par défaut sauf si une taille spécifique est
necessaire. **int** et **unint** sont dépendent de la plateforme pour laquelle il sont
compilé. Il pourrons donc être soit un int/uint32 soit un int/uint64.
* byte
.. note::
**byte** est un alias de uint8. Il est utilisé pour représenter un byte de données.
* float32 float64
* rune
.. note::
**rune** est un alias de int32. il est utiliser pour représenter un caractère Unicode.
* complex64 complex128
#. Literal Value Exemple
+-----------+-----------------------------------------------------------+
| Types | Exemples |
+===========+===========================================================+
| int | 20, -20. |
| | Values can also be expressed in hex (0x14), octal (0o24), |
| | and binary notation (0b0010100). |
+-----------+-----------------------------------------------------------+
| uint | There are no unint literals. All literal whole numbers |
| | are treated as int values. |
+-----------+-----------------------------------------------------------+
| byte | There are no byte literals. Bytes are typically expressed |
| | as integer literals (such as 101) or run literals ('e') |
| | since byte type is an alias for the unint8 type. |
+-----------+-----------------------------------------------------------+
| float64 | 20.2, -20.2, 1.2e10, -1.2e10. |
| | Values can also be expressed in hex notation (0x2p10), |
| | Altrough the exposant is expressed in decimal digits. |
+-----------+-----------------------------------------------------------+
| bool | true, false |
+-----------+-----------------------------------------------------------+
| string | "Hello". Character sequences escaped with a backslash are |
| | interpreted if the value is enclosed in double quotes |
| | ("Hello\\n"). Escape sequences are not interpreted if the |
| | is enclosed backquotes (\`Hello\\n\`). |
+-----------+-----------------------------------------------------------+
| rune | \'A\', \'\\n\', \'\\u00A5\', \'€\'. |
| | Characters glyphs, and escape sequences are enclosed in |
| | single quotes. |
+-----------+-----------------------------------------------------------+
Conversion entre Basic types
============================
**Go** applique une règle stricte sur les conversions. Toutes les conversions doivent être
spécifiquement définie. Il n'est donc pas possible d'additionner un **int** avec un **float32**
.. warning::
**Impossible d'additionner des types différents**
.. code:: go
:number-lines:
:force:
func main() {
const price int = 275
const tax float32 = 27.50
fmt.Println(price + tax)
}
.. raw:: html
Results :
.. code:: go
./prog.go:8:14: invalid operation: price + tax (mismatched types int and float32)
Les 2 éléments étant de types différent, il n'est pas possible de les additionner
Définission du type
===================
Il y a plusieur façons de définir le type des éléments
Définission Explicite du type
-----------------------------
#. Définission Explicite simple
La définission explicite simple permet de déclarer un unique élément à la fois. Elle
comprend le mot clef de la déclaration (var, const, func ...) et le type. Un élément peut
être définie puis initialisé ultérieurement.
.. note::
**Définission Explicite Simple**
.. code:: go
:number-lines:
:force:
func main() {
var price int //La variable est déclarée, mais pas initialisée
price = 250 //La variable est initialisée par affectation d'une valeur
const tax float64 = 27.50 //La constante est déclarée et initialisée dans une même action
var qte int = 1 //La variable est déclarée et initialisée en dans une même action
fmt.Printf("'price' type: %T - Value: %v\n", price, price)
fmt.Printf("'tax' type: %T - Value: %v\n", tax, tax)
fmt.Printf("'qte' type: %T - Value: %v\n", qte, qte)
}
.. raw:: html
Results
.. code:: shell
'price' type: int - Value: 250
'tax' type: float64 - Value: 27.5
'qty' type: int - Value: 1
#. Définission Explicite chainées
Il est possible de définir plusieurs elément d'un coup si ces éléments sont de même type. Le
nom du type ne sera alors donné qu'une seule fois.
.. note::
**Définission Explicite Chainée**
.. code:: go
:number-lines:
:force:
func main() {
var price, qte int = 250, 1 //Les 2 variables sont définie et initialiser en une même action.
// N.B : le type 'int' n'est renseigné qu'une seule fois
fmt.Printf("'price' type: %T - Value: %v\n", price, price)
fmt.Printf("'qte' type: %T - Value: %v\n", qte, qte)
}
.. raw:: html
Results
.. code:: shell
'price' type: int - Value: 250
'qty' type: int - Value: 1
Définission Non-Explicite du type
---------------------------------
[WIP]
####
----------
Constantes
----------
Les constantes se déclarent avec le mot clef **const**. Une constante est une information stocké en
mémoire dont la valeur ne peut pas être modifiée après sa déclaration.
Il y a deux types de déclaration de constantes :
* Les déclaration Typées
* Les déclaration non-Typées
C'est déclaration peuvent être effectuées au niveau du module ou à l'interrieur d'une fonction.
Constantes typées
=================
Le type de la constante est définie de façon explicite. Le compilateur appliquera se type sur la
constante dans tous les cas.
.. note::
**Constantes Typées**
.. code:: go
:number-lines:
:force:
func main() {
const price float32 = 250
const tax float32 = 27.50
fmt.Printf("'price' type: %T - Value: %v\n", price, price)
fmt.Printf("'tax' type: %T - Value: %v\n", tax, tax)
fmt.Printf("'price'+'tax' type: %T - Value: %v\n", price+tax, price+tax)
}
.. raw:: html
Results
.. code:: shell
'price' type: float32 - Value: 250
'tax' type: float32 - Value: 27.5
'price'+'tax' type: float32 - Value: 277.5
Les 2 éléments sont de types float32. Il est donc possible de les additionner.
voir `Conversion entre Basic types`_
Constantes non-typées
=====================
Le type de la constante n'est pas définie au moment de la déclaration. Le compilateur deduira le
type en fonction de la valeur affecté. Ce type peut être ammené à être redéfinie en fonction du
contexte.
Ce mode d'affectation permet de faire du typage dynamique et donc d'additionner des éléments de
types différents.
.. note::
**Constantes non Typées**
.. code:: go
:number-lines:
:force:
func main() {
const price = 250
const tax = 27.50
fmt.Printf("'price' type: %T - Value: %v\n", price, price)
fmt.Printf("'tax' type: %T - Value: %v\n", tax, tax)
fmt.Printf("'price'+'tax' type: %T - Value: %v\n", price+tax, price+tax)
}
.. raw:: html
Results
.. code:: shell
'price' type: int - Value: 250
'tax' type: float64 - Value: 27.5
'price'+'tax' type: float64 - Value: 277.5
Ici, le type de 'price' est redéfinie dynamiquement en fonction du contexte. le type
passe alors de **int** à **float64** pour pouvoir additionner les deux valeur.
####
---------
Variables
---------
[WIP]
####
---------
Accolades
---------
La première accolade doit être positionnée sur la même ligne que l'élément au quel elles
appartient.
Exemple pour une fonction :
.. hint::
**Bonne Syntaxe**
.. code:: go
:number-lines:
:force:
func main() {
fmt.Println("Hello, world")
}
.. raw:: html
Results
.. code:: go
Hello, world
.. warning::
**Mauvaise Syntaxe**
.. code:: go
:number-lines:
:force:
func main ()
{ // <-- L'accolade doit être sur la même ligne que la déclaration de la fonction
fmt.Println("Hello, world")
}
.. raw:: html
Results
.. code:: go
./prog.go:8:1: syntax error: unexpected semicolon or newline before {
####
-------
main.go
-------
Tous les projets doivent avoir un fichier "main.go". C'est le fichier principale du programme. Ce
fichier doit contenir une fonction "main()". C'est cette fonction qui est appellée lors de
l'éxécution du programme.
.. note::
**Minimum code**
.. code:: go
:number-lines:
:force:
package main
func main() {
// put some cool code here
}
####
---------
Fonctions
---------
Une fonction peut être déclarée avec des prototypes plus ou moins complexes en fonction de si la
fonction reçoit des arguments, si elle retourne des arguments et si elle est lié à un struct ou à
un interface.
Forme simple
============
Cette forme ne prend pas d'argument, ne retourne rien et n'est pas liée à un autre élément.
.. image:: ./images/simpleFunction.svg
:width: 520 px
:align: center
####
--------
Weblinks
--------
.. target-notes::