Golang CLI Compiler Online

Führe Go-Code direkt im Browser aus – ohne Installation. Perfekt für schnelles Testen, Debugging und Lernen via CLI.

Version

Beispiel

🚀 194,995 Gesamt-Ausführungen (581 diesen Monat)

🎯 Empfohlene Go-Kurse - perfekt für dich

🐹 Über diesen Go-Online-Executor

Der CodeUtility Go Executor ermöglicht es dir, Go-Code direkt im Browser zu schreiben und auszuführen - keine Installation, kein Setup und keine lokale Umgebung erforderlich. Er wird von einer sicheren Sandbox betrieben, die die echten Go-Compilerversionen 1.19, 1.20 und 1.21 unterstützt.

Dieses Tool kompiliert und führt echte Go-Programme in der Cloud aus und bietet dir eine authentische Go-Umgebung. Du kannst kurze Snippets testen, mit Packages experimentieren und die leistungsstarken Concurrency-Features von Go mit Goroutinen und Channels erkunden.

Es eignet sich perfekt, um zentrale Go-Konzepte wie Variablen, Funktionen, Structs, Slices, Maps, Interfaces und Fehlerbehandlung zu lernen und zu üben - ganz ohne lokale Installation.

Egal, ob du Go zum ersten Mal erkundest, Backend-Logik testest oder verstehen willst, wie Concurrency funktioniert: Der CodeUtility Go Executor bietet eine einfache, schnelle und browserbasierte Möglichkeit, Go-Code sofort auszuführen.

⚙️ So verwendest du dieses Tool

1. Wähle oben im Editor eine Go-Version (1.19, 1.20 oder 1.21) im Dropdown aus.
2. Schreibe oder füge deinen Go-Code in den Editorbereich ein.
3. Klicke auf Ausführen, um dein Programm zu kompilieren und auszuführen - die Ausgabe erscheint in der Konsole darunter.
4. Während der Ausführung erscheint ein Stopp-Button - klicke darauf, um die Ausführung vorzeitig zu beenden.
5. Nutze Code korrigieren, um kleinere Formatierungs- oder Syntaxprobleme automatisch zu beheben.
6. Nach dem Korrigieren erscheint ein Korrekturen-Button - klicke darauf, um die letzten Änderungen anzusehen.
7. Verwende den Button Hochladen, um Code aus einer lokalen Datei zu importieren, oder Herunterladen, um deinen aktuellen Code aus dem Editor zu speichern.
8. Jede Ausführung läuft bis zu 20 Sekunden, bevor sie automatisch beendet wird.

🧠 Tipp: Diese Umgebung führt echten Go-Code sicher in deinem Browser aus - keine Anmeldung oder lokale Einrichtung erforderlich.

💡 Go-Grundlagen & Beispiele, die du oben ausprobieren kannst

1. Variablen und Konstanten deklarieren

Verwende var oder :=, um Variablen zu deklarieren. Verwende const für Konstanten.

package main

var x int = 10
const Pi = 3.14

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

2. Bedingungen (if / switch)

Go unterstützt if-else- und switch-Anweisungen mit klarer Syntax.

x := 2
if x == 1 {
    println("Eins")
} else if x == 2 {
    println("Zwei")
} else {
    println("Sonstiges")
}

switch x {
case 1:
    println("Eins")
case 2:
    println("Zwei")
default:
    println("Sonstiges")
}

3. Schleifen

Go verwendet nur die for-Schleife, sie kann jedoch auch wie eine while-Schleife genutzt werden.

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

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

4. Arrays

Arrays haben eine feste Größe. Verwende Slices für dynamische Listen.

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

5. Slice-Operationen

Verwende Slices sowie die eingebauten Funktionen append, len, copy und die Slicing-Syntax.

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

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

6. Konsolen-Ein-/Ausgabe

Verwende fmt.Print, fmt.Scan und fmt.Println.

import "fmt"

var name string
fmt.Print("Gib deinen Namen ein: ")
fmt.Scan(&name)
fmt.Println("Hallo", name)

7. Funktionen

Funktionen werden mit func deklariert und können mehrere Werte zurückgeben.

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

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

8. Maps

Maps sind Schlüssel-Wert-Speicher. Deklariere sie mit make().

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

9. Fehlerbehandlung

Go verwendet mehrere Rückgabewerte für Fehler anstelle von Exceptions.

import "errors"

func fail() error {
    return errors.New("etwas ist schiefgelaufen")
}

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

10. Datei-I/O

Verwende die Pakete os und io/ioutil, um Dateien zu lesen/zu schreiben.

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

ioutil.WriteFile("file.txt", []byte("Hallo Datei"), 0644)

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

11. String-Operationen

Verwende das Paket strings für String-Operationen.

import "strings"

text := "  Hallo Welt  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Hallo", "Hi"))

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

12. Structs & Objekte

Verwende Structs, um eigene Typen mit Methoden zu definieren.

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "Hi, ich bin " + p.Name
}

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

13. Referenzen (Pointer)

Go unterstützt Pointer mit * und &.

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