Compilador CLI de Golang en Línea

Prueba y depura tu código Go en tiempo real desde el navegador con un CLI online. Sin instalación, ideal para aprendizaje y testing.

Versión

Ejemplo

🚀 194,995 ejecuciones totales (581 este mes)

🎯 Cursos recomendados de Go ideales para ti

🐹 Acerca de este ejecutor de Go en línea

El CodeUtility Go Executor te permite escribir y ejecutar código Go directamente en tu navegador - sin instalación, configuración ni entorno local. Está impulsado por un sandbox seguro que soporta versiones reales del compilador de Go 1.19, 1.20 y 1.21.

Esta herramienta compila y ejecuta programas reales de Go en la nube, ofreciéndote un entorno auténtico de Go. Puedes probar fragmentos cortos, experimentar con paquetes y explorar las potentes funciones de concurrencia de Go usando goroutines y canales.

Es perfecta para aprender y practicar los conceptos básicos de Go como variables, funciones, structs, slices, mapas, interfaces y manejo de errores - todo sin instalar herramientas localmente.

Ya sea que estés explorando Go por primera vez, probando lógica de backend o aprendiendo cómo funciona la concurrencia, el CodeUtility Go Executor ofrece una forma limpia, rápida y basada en el navegador para ejecutar código Go al instante.

⚙️ Cómo usar esta herramienta

1. Selecciona una versión de Go (1.19, 1.20 o 1.21) en el menú desplegable en la parte superior del editor.
2. Escribe o pega tu código Go en el área del editor.
3. Haz clic en Ejecutar para compilar y ejecutar tu programa - la salida aparecerá en la consola de abajo.
4. Mientras se ejecuta, aparece un botón Detener - haz clic para detener la ejecución de forma anticipada.
5. Usa Corregir código para corregir automáticamente problemas menores de formato o sintaxis.
6. Después de corregir, aparece un botón Correcciones - haz clic para revisar las correcciones recientes.
7. Usa el botón Subir para importar código desde un archivo local, o el botón Descargar para guardar tu código actual desde el editor.
8. Cada ejecución dura hasta 20 segundos antes de terminar automáticamente.

🧠 Consejo: Este entorno ejecuta código Go real de forma segura en tu navegador - sin inicio de sesión ni configuración local.

💡 Conceptos básicos de Go y ejemplos que puedes probar arriba

1. Declaración de variables y constantes

Usa var o := para declarar variables. Usa 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. Condicionales (if / switch)

Go soporta sentencias if-else y switch con una sintaxis clara.

x := 2
if x == 1 {
    println("Uno")
} else if x == 2 {
    println("Dos")
} else {
    println("Otro")
}

switch x {
case 1:
    println("Uno")
case 2:
    println("Dos")
default:
    println("Otro")
}

3. Bucles

Go solo usa el bucle for, pero puede comportarse como un bucle while.

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

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

4. Arreglos

Los arreglos tienen tamaño fijo. Usa slices para listas dinámicas.

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

5. Manipulación de slices

Usa slices y las funciones integradas append, len, copy y la sintaxis de slicing.

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

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

6. Entrada/Salida por consola

Usa fmt.Print, fmt.Scan y fmt.Println.

import "fmt"

var name string
fmt.Print("Ingresa tu nombre: ")
fmt.Scan(&name)
fmt.Println("Hola", name)

7. Funciones

Las funciones se declaran con func y pueden devolver múltiples valores.

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

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

8. Mapas

Los mapas son almacenes clave-valor. Decláralos con make().

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

9. Manejo de errores

Go usa múltiples valores de retorno para los errores en lugar de excepciones.

import "errors"

func fail() error {
    return errors.New("algo salió mal")
}

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

10. E/S de archivos

Usa los paquetes os y io/ioutil para leer/escribir archivos.

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

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

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

11. Manipulación de cadenas

Usa el paquete strings para operaciones con cadenas.

import "strings"

text := "  Hola Mundo  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Hola", "Buenas"))

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

12. Structs y objetos

Usa structs para definir tipos personalizados con métodos.

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "Hola, soy " + p.Name
}

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

13. Referencias (punteros)

Go admite punteros usando * y &.

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