Compilateur CLI Golang en Ligne

Testez du code Go en temps réel via une CLI online. Aucune installation requise, parfait pour apprendre, coder et déboguer.

Version

Exemple

🚀 194,995 exécutions totales (581 ce mois-ci)

📚 Tout le monde apprend Go - et vous ?

🐹 À propos de cet exécuteur Go en ligne

Le CodeUtility Go Executor vous permet d’écrire et d’exécuter du code Go directement dans votre navigateur - aucune installation, configuration ni environnement local requis. Il est propulsé par un bac à sable sécurisé qui prend en charge les véritables versions du compilateur Go 1.19, 1.20 et 1.21.

Cet outil compile et exécute de vrais programmes Go dans le cloud, vous offrant un environnement Go authentique. Vous pouvez tester de courts extraits, expérimenter avec des packages et explorer les puissantes fonctionnalités de concurrence de Go à l’aide des goroutines et des canaux.

C’est idéal pour apprendre et pratiquer les concepts clés de Go tels que variables, fonctions, structs, slices, maps, interfaces et gestion des erreurs - le tout sans installer d’outils en local.

Que vous découvriez Go pour la première fois, testiez de la logique back-end ou appreniez le fonctionnement de la concurrence, le CodeUtility Go Executor offre une façon simple, rapide et basée sur le navigateur d’exécuter du code Go instantanément.

⚙️ Comment utiliser cet outil

1. Sélectionnez une version de Go (1.19, 1.20 ou 1.21) dans la liste déroulante en haut de l’éditeur.
2. Écrivez ou collez votre code Go dans la zone d’édition.
3. Cliquez sur Exécuter pour compiler et exécuter votre programme - la sortie s’affichera dans la console ci-dessous.
4. Pendant l’exécution, un bouton Arrêter apparaît - cliquez dessus pour interrompre l’exécution.
5. Utilisez Corriger le code pour corriger automatiquement les problèmes mineurs de formatage ou de syntaxe.
6. Après correction, un bouton Corrections apparaît - cliquez dessus pour consulter les corrections récentes.
7. Utilisez le bouton Téléverser pour importer du code depuis un fichier local, ou le bouton Télécharger pour enregistrer votre code actuel depuis l’éditeur.
8. Chaque exécution dure jusqu’à 20 secondes avant de se terminer automatiquement.

🧠 Astuce : Cet environnement exécute du vrai code Go en toute sécurité dans votre navigateur - aucun compte ni configuration locale requis.

💡 Les bases de Go et des exemples à essayer ci-dessus

1. Déclarer des variables et des constantes

Utilisez var ou := pour déclarer des variables. Utilisez const pour les constantes.

package main

var x int = 10
const Pi = 3.14

func main() {
    name := "Alice"
    isActive := true
    println(x, Pi, name, isActive)
}

2. Instructions conditionnelles (if / switch)

Go prend en charge les instructions if-else et switch avec une syntaxe simple.

x := 2
if x == 1 {
    println("Un")
} else if x == 2 {
    println("Deux")
} else {
    println("Autre")
}

switch x {
case 1:
    println("Un")
case 2:
    println("Deux")
default:
    println("Autre")
}

3. Boucles

Go n’a qu’une seule boucle for, mais elle peut se comporter comme une boucle while.

for i := 0; i < 3; i++ {
    println(i)
}

n := 3
for n > 0 {
    println(n)
    n--
}

4. Tableaux

Les tableaux ont une taille fixe. Utilisez des slices pour des listes dynamiques.

var nums = [3]int{10, 20, 30}
println(nums[1])

5. Manipulation de slices

Utilisez les slices et les fonctions intégrées append, len, copy, ainsi que la syntaxe de découpage.

fruits := []string{"apple", "banana"}
fruits = append(fruits, "cherry")
fruits = fruits[1:]  // découpage
println(len(fruits))

for _, fruit := range fruits {
    println(fruit)
}

6. Entrée/Sortie console

Utilisez fmt.Print, fmt.Scan et fmt.Println.

import "fmt"

var name string
fmt.Print("Entrez votre nom : ")
fmt.Scan(&name)
fmt.Println("Bonjour", name)

7. Fonctions

Les fonctions se déclarent avec func et peuvent renvoyer plusieurs valeurs.

func greet(name string) string {
    return "Bonjour, " + name
}

message := greet("Alice")
println(message)

8. Maps

Les maps sont des structures clé-valeur. Déclarez-les avec make().

ages := map[string]int{"Alice": 30}
ages["Bob"] = 25
println(ages["Alice"])

9. Gestion des erreurs

Go utilise des valeurs de retour multiples pour les erreurs, au lieu d’exceptions.

import "errors"

func fail() error {
    return errors.New("quelque chose s'est mal passé")
}

err := fail()
if err != nil {
    println(err.Error())
}

10. E/S fichier

Utilisez les packages os et io/ioutil pour lire/écrire des fichiers.

import (
  "fmt"
  "os"
  "io/ioutil"
)

ioutil.WriteFile("file.txt", []byte("Bonjour fichier"), 0644)

data, _ := ioutil.ReadFile("file.txt")
fmt.Println(string(data))

11. Manipulation de chaînes

Utilisez le package strings pour les opérations sur les chaînes.

import "strings"

text := "  Bonjour le monde  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Bonjour", "Salut"))

words := strings.Split(text, " ")
fmt.Println(words)

12. Structs et objets

Utilisez des structs pour définir des types personnalisés avec des méthodes.

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "Salut, je m'appelle " + p.Name
}

p := Person{Name: "Alice"}
println(p.Greet())

13. Références (pointeurs)

Go prend en charge les pointeurs avec * et &.

x := 10
ptr := &x
*ptr = 20
println(x) // 20