Tutoriel : votre premier fichier dans Turbo Go

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

# Tutoriel : votre premier fichier dans Turbo Go

À la fin de ce tutoriel, vous aurez compilé l'éditeur, écrit un petit programme Go à l'intérieur, vu les mots-clés se colorer au fil de la frappe, enregistré le fichier et exécuté le programme. Comptez une dizaine de minutes.

Aucune connaissance préalable de Turbo Go n'est nécessaire. Il vous faut Go 1.26 ou plus récent et un terminal — rien d'autre.

## Prérequis

Vérifiez que Go est présent :

```bash
go version
```

Vous devriez voir quelque chose comme :

```
go version go1.26.5 linux/arm64
```

Si cette commande échoue, installez d'abord Go : https://go.dev/dl/

## Étape 1 — Compiler l'éditeur

Depuis le répertoire du projet, tapez :

```bash
make build
```

Vous devriez voir :

```
go build -o bin/turbo-go .
```

puis plus rien. Le silence est le signe du succès : Go ne dit rien quand une compilation réussit.

Nous avons maintenant un exécutable dans `bin/turbo-go`. Retenons où il est, pour pouvoir le lancer de n'importe où :

```bash
export TURBO="$PWD/bin/turbo-go"
```

## Étape 2 — Créer un endroit où travailler

Turbo Go donne le meilleur de lui-même à l'intérieur d'un module Go ; créons-en un :

```bash
mkdir -p /tmp/hello && cd /tmp/hello
go mod init hello
```

Vous devriez voir :

```
go: creating new go.mod: module hello
```

Nous venons de créer un module Go vide.

## Étape 3 — Ouvrir l'éditeur

Lancez Turbo Go sur un fichier qui n'existe pas encore :

```bash
$TURBO main.go
```

L'écran se remplit d'un bureau bleu. Vous devriez voir :

- une **barre de menus** en haut : `File  Edit  Search  Run  Code  Options  Window  Snippets  Go  Help`
- une **fenêtre** encadrée d'un double trait, intitulée `main.go`
- une **barre d'état** en bas : `F1 Describe  F2 Save  F3 Open …`

Le curseur clignote ligne 1, colonne 1 — la barre d'état affiche `1:1` à droite.

Nous sommes dans l'éditeur.

## Étape 4 — Écrire un programme Go

Tapez ces cinq lignes, en appuyant sur Entrée à la fin de chacune :

```go
package main

import "fmt"

func main() {
```

Observez les couleurs pendant que vous tapez. `package`, `import` et `func` deviennent **blanc gras** dès que le mot est terminé : ce sont des mots-clés. `"fmt"` devient **vert** : c'est une chaîne. `main` devient **jaune gras** dès que vous tapez la `(` qui le suit, car cela en fait une fonction.

Appuyez maintenant sur **Tab**. Le curseur saute en colonne 9 — la barre d'état à droite passe à `5:2`, parce qu'une tabulation occupe un seul caractère dans le fichier même si elle remplit huit colonnes à l'écran.

Tapez le corps de la fonction :

```go
fmt.Println("Hello from Turbo Go!")
```

> Quand vous tapez le `.` après `fmt`, la barre d'état affiche brièvement un message à propos du serveur de langage. C'est normal : la complétion a besoin de `gopls`, que nous n'avons pas installé. Le [guide de la complétion](../how-to/enable-completion.md) s'en occupe plus tard ; ignorez-le pour l'instant.

Appuyez sur **Entrée**. Regardez la nouvelle ligne : le curseur est *déjà* en colonne 9. Turbo Go a recopié l'indentation de la ligne précédente, ce qui est ce que l'on veut neuf fois sur dix.

Cette fois nous n'en voulons pas : appuyez sur **Maj-Tab** pour retirer cette indentation, puis tapez l'accolade fermante :

```go
}
```

Le titre de la fenêtre affiche désormais `main.go *`. L'étoile signale des modifications non enregistrées.

Nous venons d'écrire un programme Go complet, coloré au fil de la frappe.

## Étape 5 — L'enregistrer

Appuyez sur **F2**.

L'étoile disparaît du titre et la barre d'état affiche :

```
Saved main.go
```

Nous venons d'écrire le fichier sur le disque.

## Étape 6 — Regarder le fichier depuis l'extérieur

Quittez l'éditeur avec **Alt-X**. Le terminal revient tel qu'il était.

Vérifiez ce que nous avons écrit :

```bash
cat main.go
```

Vous devriez voir :

```go
package main

import "fmt"

func main() {
	fmt.Println("Hello from Turbo Go!")
}
```

## Étape 7 — L'exécuter

```bash
go run main.go
```

Vous devriez voir :

```
Hello from Turbo Go!
```

C'est un programme Go qui fonctionne, écrit entièrement dans l'éditeur.

## Étape 8 — Changer de thème

Rouvrez le fichier :

```bash
$TURBO main.go
```

Appuyez sur **F10**. Le menu `File` se déroule. Appuyez cinq fois sur **→** : le menu se déplace le long de la barre jusqu'à `Options`, dont la première entrée, `Theme…`, est surlignée. Appuyez sur **Entrée**.

Une liste de onze apparaît, par ordre alphabétique, le thème que vous utilisez étant déjà mis en évidence :

```
borland-light
cappuccino
catppuccin-frappe
catppuccin-latte
cobalt
darcula
intellij-light
monochrome-dark
monochrome-light
turbo-classic
turbo-dark
```

`turbo-classic` est la ligne en évidence, puisque c'est le thème dans lequel vous êtes. Appuyez une fois sur **↓** pour aller sur `turbo-dark`, puis sur **Entrée**.

Tout l'éditeur se repeint en gris sombre, et la barre d'état affiche `Theme: Turbo Dark`.

Appuyez sur **Alt-X** pour quitter.

## Et maintenant ?

Vous avez compilé l'éditeur, écrit un programme Go dedans, l'avez enregistré, exécuté, et vous avez changé son apparence.

- Pour faire des choses précises — activer la complétion, écrire votre propre thème, chercher dans un fichier → voir les [guides pratiques](../how-to/)
- Pour retrouver une touche ou une entrée de menu → voir la [référence](../reference/)
- Pour comprendre comment fonctionnent réellement la coloration et la complétion → voir les [explications](../explanation/)