Compilatore CLI Go Online

Esegui, testa e debuggia il tuo code Go direttamente dal browser senza setup. Ideale per apprendimento veloce e test immediati.

Versione

Esempio

🚀 194,995 esecuzioni totali (581 questo mese)

👨‍💻 Diventa esperto in Go con corsi pratici

🐹 Informazioni su questo esecutore Go online

Il CodeUtility Go Executor ti permette di scrivere ed eseguire codice Go direttamente nel browser - senza installazioni, configurazioni o ambiente locale. È basato su una sandbox sicura che supporta le reali versioni del compilatore Go 1.19, 1.20 e 1.21.

Questo strumento compila ed esegue veri programmi Go nel cloud, fornendo un ambiente Go autentico. Puoi testare brevi snippet, sperimentare con i pacchetti ed esplorare le potenti funzionalità di concorrenza di Go usando goroutine e canali.

È perfetto per imparare ed esercitarsi con i concetti base di Go come variabili, funzioni, struct, slice, map, interfacce e gestione degli errori - tutto senza installare alcun tool in locale.

Che tu stia esplorando Go per la prima volta, testando logica backend o imparando come funziona la concorrenza, il CodeUtility Go Executor offre un modo pulito, veloce e basato sul browser per eseguire codice Go all'istante.

⚙️ Come usare questo strumento

1. Seleziona una versione di Go (1.19, 1.20 o 1.21) dal menu a discesa in alto nell'editor.
2. Scrivi o incolla il tuo codice Go nell'area dell'editor.
3. Clicca Esegui per compilare ed eseguire il programma - l'output apparirà nella console sottostante.
4. Durante l'esecuzione, appare un pulsante Interrompi - cliccalo per interrompere l'esecuzione in anticipo.
5. Usa Correggi codice per correggere automaticamente piccoli problemi di formattazione o sintassi.
6. Dopo la correzione, appare il pulsante Correzioni - cliccalo per rivedere le correzioni recenti.
7. Usa il pulsante Carica per importare codice da un file locale, oppure il pulsante Scarica per salvare il codice corrente dall'editor.
8. Ogni esecuzione dura fino a 20 secondi prima di terminare automaticamente.

🧠 Suggerimento: Questo ambiente esegue vero codice Go in modo sicuro nel tuo browser - nessun accesso o configurazione locale richiesta.

💡 Basi di Go ed esempi che puoi provare sopra

1. Dichiarare variabili e costanti

Usa var o := per dichiarare variabili. Usa const per le costanti.

package main

var x int = 10
const Pi = 3.14

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

2. Condizionali (if / switch)

Go supporta le istruzioni if-else e switch con una sintassi pulita.

x := 2
if x == 1 {
    println("Uno")
} else if x == 2 {
    println("Due")
} else {
    println("Altro")
}

switch x {
case 1:
    println("Uno")
case 2:
    println("Due")
default:
    println("Altro")
}

3. Cicli

Go usa solo il ciclo for, ma può comportarsi come un ciclo while.

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

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

4. Array

Gli array hanno dimensione fissa. Usa le slice per liste dinamiche.

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

5. Manipolazione delle slice

Usa le slice e le funzioni integrate append, len, copy e la sintassi di slicing.

fruits := []string{"mela", "banana"}
fruits = append(fruits, "ciliegia")
fruits = fruits[1:]  // slice
println(len(fruits))

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

6. Input/Output da console

Usa fmt.Print, fmt.Scan e fmt.Println.

import "fmt"

var name string
fmt.Print("Inserisci il tuo nome: ")
fmt.Scan(&name)
fmt.Println("Ciao", name)

7. Funzioni

Le funzioni si dichiarano con func e possono restituire più valori.

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

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

8. Mappe

Le mappe sono archivi chiave-valore. Dichiarale con make().

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

9. Gestione degli errori

Go usa valori di ritorno multipli per gli errori invece delle eccezioni.

import "errors"

func fail() error {
    return errors.New("qualcosa è andato storto")
}

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

10. I/O su file

Usa i pacchetti os e io/ioutil per leggere/scrivere file.

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

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

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

11. Manipolazione di stringhe

Usa il pacchetto strings per operazioni sulle stringhe.

import "strings"

text := "  Ciao mondo  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Ciao", "Ehi"))

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

12. Struct e oggetti

Usa le struct per definire tipi personalizzati con metodi.

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "Ciao, sono " + p.Name
}

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

13. Riferimenti (puntatori)

Go supporta i puntatori usando * e &.

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