CodeUtility
Haz que programar sea más fácil.

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.

Bibliotecas preinstaladas
🚀 204,204 ejecuciones totales (141 este mes)

Udemy Logo 🎯 Cursos recomendados de Go ideales para ti

Cargando…

💡 ¿Buscas mejorar tus habilidades? Estos cursos pueden resultar útiles; consúltelos mientras nuestro modelo de IA procesa su solicitud.

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

Más que un ejecutor de código

Utiliza un editor de varios archivos, un terminal de ejecución aislado, bibliotecas específicas del entorno, espacios de trabajo persistentes, opciones para compartir y colaboración en tiempo real desde el mismo ejecutor.

¿Cómo se utiliza este ejecutor?

Elige un entorno de ejecución, abre o crea un archivo, escribe el código y selecciona Ejecutar. El resultado aparece en el terminal; los usuarios que han iniciado sesión pueden conservar archivos en un espacio de trabajo, instalar bibliotecas y colaborar mediante elementos compartidos.

  1. Selecciona una versión y edita el archivo actual o abre otro archivo del espacio de trabajo.
  2. Ejecuta el código, introduce datos en el terminal cuando se soliciten y revisa el historial de ejecuciones guardado.
  3. Utiliza bibliotecas, herramientas del espacio de trabajo, opciones para compartir y el chat cuando la tarea requiera más de un fragmento.

💡 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