Contactez-nous

Go : prise en main rapide et essentielle

Formation accélérée Go (Golang) : assimilez vite les fondamentaux du langage, de la syntaxe aux goroutines. Un parcours intensif couvrant l'essentiel pour écrire du code Go efficace et être opérationnel rapidement. Idéal pour un démarrage rapide.

Table des matières

  1. Démarrage rapide et syntaxe essentielle
    1. Premiers pas et environnement
      1. Pourquoi Go ? Installation rapide
      2. Mon premier programme Go (`go run`, `go build`)
      3. Variables (`var`, `:=`), types de base (int, float, string, bool)
      4. Formatage automatique (`go fmt`)
    2. Structures de contrôle et fonctions
      1. Conditions (`if`/`else`)
      2. Boucles (`for` - formes principales)
      3. Aiguillage (`switch` - bases)
      4. Déclarer et appeler des fonctions (paramètres, retours multiples)
      5. Paquets : `package main`, `import`, visibilité (majuscule/minuscule)
  2. Structures de données et organisation
    1. Collections fondamentales
      1. Slices (création, `len`, `cap`, `append`)
      2. Itérer sur les slices (et autres collections) avec `range`
      3. Maps (création, accès, ajout/suppression, vérification d'existence)
      4. Structs (définition, création, accès aux champs)
      5. Pointeurs : l'essentiel (opérateurs `&` et `*`, quand les utiliser simplement)
    2. Méthodes, interfaces et erreurs
      1. Méthodes (receveurs valeur vs pointeur - focus sur le besoin de modifier)
      2. Interfaces : concept et implémentation implicite
      3. L'interface `error` et le pattern `if err != nil`
      4. Créer des erreurs simples (`errors.New`, `fmt.Errorf`)
  3. Concurrence de base et outils clés
    1. Introduction à la concurrence Go
      1. Goroutines : lancer des fonctions en parallèle (`go ...`)
      2. Canaux (Channels) : communication basique (`make`, `<-`, `close`)
      3. Synchronisation simple avec `sync.WaitGroup`
      4. La boucle `for range` sur les canaux
    2. Modules, tests et paquets utiles
      1. Gestion des dépendances avec Go Modules (`go mod init`, `go get`, `go mod tidy`)
      2. Ecrire un test unitaire simple (`testing`, `go test`)
      3. Paquets standards courants : `fmt`, `strings`, `encoding/json` (bases)
      4. Exemple rapide : serveur web simple avec `net/http`
  4. Conclusion et bonnes pratiques
    1. Synthèse et aller plus loin
      1. Récapitulatif : la philosophie Go (simplicité, concurrence, outillage)
      2. Bonnes pratiques essentielles (nommage, gestion erreurs, formatage)
      3. Pistes pour approfondir (Effective Go, doc stdlib, `context`, `select`)