CodeUtility
Faciliter la vie des développeurs !

Online Go Compiler

Write, compile, run, and debug Go code online in a full-featured browser IDE. Work with multiple files, save your workspace, and collaborate in real time—no setup required.

Bibliothèques préinstallées
🚀 204,185 exécutions totales (122 ce mois-ci)

Udemy Logo ✨ Les cours de Go les plus appréciés

Chargement…

💡 Vous cherchez à améliorer vos compétences ? Ces cours peuvent vous aider : consultez-les pendant que notre modèle d'IA traite votre demande.

🐹 À 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.

Bien plus qu’un exécuteur de code

Utilisez depuis le même exécuteur un éditeur multifichier, un terminal d’exécution isolé, des bibliothèques propres à chaque environnement, des espaces de travail persistants, le partage et la collaboration en temps réel.

Comment utiliser cet exécuteur ?

Choisissez un environnement d’exécution, ouvrez ou créez un fichier, écrivez votre code, puis sélectionnez Exécuter. La sortie s’affiche dans le terminal ; les utilisateurs connectés peuvent conserver leurs fichiers dans un espace de travail, installer des bibliothèques et collaborer grâce aux partages.

  1. Sélectionnez une version et modifiez le fichier actuel, ou ouvrez un autre fichier de l’espace de travail.
  2. Exécutez le code, saisissez les données demandées dans le terminal et consultez l’historique des exécutions enregistrées.
  3. Utilisez les bibliothèques, les outils de l’espace de travail, le partage et le chat lorsque votre tâche nécessite plusieurs extraits de code.

💡 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