CodeUtility
Mach dir das Coderleben leicht!

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.

Vorinstallierte Bibliotheken
🚀 204,205 Gesamt-Ausführungen (142 diesen Monat)

Udemy Logo 🎯 Empfohlene Go-Kurse - perfekt für dich

Wird geladen…

💡 Möchten Sie Ihre Fähigkeiten verbessern? Diese Kurse können hilfreich sein – schauen Sie sich sie an, während unser KI-Modell Ihre Anfrage bearbeitet.

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

Mehr als nur ein Code-Runner

Nutzen Sie im selben Executor einen Editor für mehrere Dateien, ein isoliertes Ausführungsterminal, laufzeitspezifische Bibliotheken, persistente Arbeitsbereiche, Freigaben und Zusammenarbeit in Echtzeit.

Wie verwende ich diesen Executor?

Wählen Sie eine Laufzeit aus, öffnen oder erstellen Sie eine Datei, schreiben Sie Ihren Code und wählen Sie Ausführen. Die Ausgabe erscheint im Terminal. Angemeldete Benutzer können Dateien in einem Arbeitsbereich speichern, Bibliotheken installieren und über Freigaben zusammenarbeiten.

  1. Wählen Sie eine Version aus und bearbeiten Sie die aktuelle Datei oder öffnen Sie eine andere Datei aus dem Arbeitsbereich.
  2. Führen Sie den Code aus, geben Sie bei Aufforderung Daten im Terminal ein und prüfen Sie den gespeicherten Ausführungsverlauf.
  3. Nutzen Sie Bibliotheken, Arbeitsbereichswerkzeuge, Freigaben und den Chat, wenn Ihre Aufgabe mehr als ein einzelnes Codefragment erfordert.

💡 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