Compilador Golang CLI Online

Execute e teste código Go diretamente no navegador com esta CLI online. Ideal para aprender, testar e depurar sem configuração.

Versão

Exemplo

🚀 194,995 execuções totais (581 este mês)

🎯 Cursos de Go escolhidos especialmente para você

🐹 Sobre este Executor Go online

O CodeUtility Go Executor permite escrever e executar código Go diretamente no seu navegador - sem instalação, configuração ou ambiente local. É alimentado por um sandbox seguro que suporta versões reais do compilador Go 1.19, 1.20 e 1.21.

Esta ferramenta compila e executa programas Go reais na nuvem, oferecendo um ambiente autêntico de Go. Você pode testar trechos curtos, experimentar com pacotes e explorar os poderosos recursos de concorrência do Go usando gorrotinas e canais.

É perfeita para aprender e praticar os conceitos fundamentais de Go, como variáveis, funções, structs, slices, maps, interfaces e tratamento de erros - tudo isso sem instalar nada localmente.

Seja explorando Go pela primeira vez, testando lógica de backend ou aprendendo como a concorrência funciona, o CodeUtility Go Executor oferece uma forma limpa, rápida e baseada no navegador de executar código Go instantaneamente.

⚙️ Como usar esta ferramenta

1. Selecione uma versão do Go (1.19, 1.20 ou 1.21) no menu suspenso no topo do editor.
2. Escreva ou cole seu código Go na área do editor.
3. Clique em Executar para compilar e executar seu programa - a saída aparecerá no console abaixo.
4. Enquanto estiver rodando, um botão Parar aparece - clique nele para interromper a execução antes do término.
5. Use Corrigir código para corrigir automaticamente pequenos problemas de formatação ou sintaxe.
6. Após corrigir, aparece um botão Correções - clique nele para revisar as correções recentes.
7. Use o botão Enviar para importar código de um arquivo local, ou o botão Baixar para salvar o código atual do editor.
8. Cada execução roda por até 20 segundos antes de encerrar automaticamente.

🧠 Dica: Este ambiente executa código Go real com segurança no seu navegador - sem necessidade de login ou configuração local.

💡 Noções básicas de Go e exemplos que você pode testar acima

1. Declarando variáveis e constantes

Use var ou := para declarar variáveis. Use const para constantes.

package main

var x int = 10
const Pi = 3.14

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

2. Condicionais (if / switch)

Go suporta instruções if-else e switch com uma sintaxe limpa.

x := 2
if x == 1 {
    println("Um")
} else if x == 2 {
    println("Dois")
} else {
    println("Outro")
}

switch x {
case 1:
    println("Um")
case 2:
    println("Dois")
default:
    println("Outro")
}

3. Loops

Go usa apenas o loop for, mas ele pode agir como um loop while.

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

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

4. Arrays

Arrays têm tamanho fixo. Use slices para listas dinâmicas.

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

5. Manipulação de slices

Use slices e as funções internas append, len, copy e a sintaxe de fatiamento.

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

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

6. Entrada/Saída no console

Use fmt.Print, fmt.Scan e fmt.Println.

import "fmt"

var name string
fmt.Print("Digite seu nome: ")
fmt.Scan(&name)
fmt.Println("Olá", name)

7. Funções

Funções são declaradas com func e podem retornar múltiplos valores.

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

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

8. Maps

Maps são armazenamentos chave-valor. Declare com make().

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

9. Tratamento de erros

Go usa múltiplos valores de retorno para erros em vez de exceções.

import "errors"

func fail() error {
    return errors.New("algo deu errado")
}

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

10. E/S de arquivos

Use os pacotes os e io/ioutil para ler/gravar arquivos.

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

ioutil.WriteFile("file.txt", []byte("Olá Arquivo"), 0644)

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

11. Manipulação de strings

Use o pacote strings para operações com strings.

import "strings"

text := "  Olá Mundo  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Olá", "Oi"))

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

12. Structs e objetos

Use structs para definir tipos personalizados com métodos.

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "Oi, eu sou " + p.Name
}

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

13. Referências (ponteiros)

Go suporta ponteiros usando * e &.

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