Go Academy · Lección

Packages fmt y strings

Formateo de la salida y manipulación de strings

Lección 1 de 412 pasos

Packages fmt y strings es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Descripción general del paquete fmt

El paquete fmt implementa E/S con formato. Funciones principales:

fmt.Print, fmt.Println, fmt.Printf: escriben en stdout
fmt.Sprint, fmt.Sprintf, fmt.Sprintln: devuelven cadenas
fmt.Fprint, fmt.Fprintf: escriben en cualquier io.Writer
fmt.Scan, fmt.Scanf: leen de stdin

Verbos de formato de fmt

Verbos de formato comunes para fmt.Printf:

package main
import "fmt"

func main() {
    name := "Gopher"
    age := 15
    score := 98.6

    fmt.Printf("%s is %d years old\n", name, age)
    fmt.Printf("Score: %.1f%%\n", score)
    fmt.Printf("Type: %T, Value: %v\n", age, age)
    fmt.Printf("Hex: %x, Binary: %b\n", 255, 255)
    fmt.Printf("Padded: %10s|%-10s\n", name, name)
}

fmt.Sprintf para construir cadenas

fmt.Sprintf devuelve una cadena con formato sin imprimirla; resulta útil para construir cadenas:

package main
import "fmt"

func formatUser(name string, age int) string {
    return fmt.Sprintf("User{name: %q, age: %d}", name, age)
}

func main() {
    fmt.Println(formatUser("Alice", 30))
    // User{name: "Alice", age: 30}

    // %q adds quotes; %+v prints struct field names
    type Point struct{X, Y int}
    p := Point{1, 2}
    fmt.Printf("%+v\n", p) // {X:1 Y:2}
}

fmt.Errorf para dar formato a errores

fmt.Errorf crea valores de error con formato:

package main
import "fmt"

func getUser(id int) error {
    return fmt.Errorf("getUser(%d): user not found", id)
}

func main() {
    err := getUser(42)
    fmt.Println(err) // getUser(42): user not found

    // Wrap errors with %w for unwrapping:
    base := fmt.Errorf("base error")
    wrapped := fmt.Errorf("context: %w", base)
    fmt.Println(wrapped)
}

Paquete strings: funciones comunes

El paquete strings proporciona funciones para manipular cadenas:

package main
import ("fmt"; "strings")

func main() {
    s := "  Hello, Go World!  "

    fmt.Println(strings.TrimSpace(s))           // "Hello, Go World!"
    fmt.Println(strings.ToUpper(s))             // "  HELLO, GO WORLD!  "
    fmt.Println(strings.ToLower(s))             // "  hello, go world!  "
    fmt.Println(strings.Contains(s, "Go"))      // true
    fmt.Println(strings.HasPrefix(s, "  Hel")) // true
    fmt.Println(strings.Count(s, "l"))          // 3
}

strings.Split y strings.Join

strings.Split divide una cadena y strings.Join une un slice:

package main
import ("fmt"; "strings")

func main() {
    csv := "alice,bob,carol,dave"
    names := strings.Split(csv, ",")     // ["alice" "bob" "carol" "dave"]
    fmt.Println(names)

    upper := make([]string, len(names))
    for i, n := range names {
        upper[i] = strings.ToUpper(n)
    }
    result := strings.Join(upper, " | ")
    fmt.Println(result) // ALICE | BOB | CAROL | DAVE
}

strings.Replace y strings.ReplaceAll

Reemplace las apariciones de una subcadena:

package main
import ("fmt"; "strings")

func main() {
    s := "foo bar foo baz foo"

    // Replace first 2 occurrences
    fmt.Println(strings.Replace(s, "foo", "XXX", 2))
    // XXX bar XXX baz foo

    // Replace all
    fmt.Println(strings.ReplaceAll(s, "foo", "GO"))
    // GO bar GO baz GO
}

strings.Builder para una concatenación eficiente

Use strings.Builder para construir cadenas de forma eficiente; evita reservar una cadena nueva para cada concatenación:

package main
import ("fmt"; "strings")

func join(parts []string, sep string) string {
    var sb strings.Builder
    for i, p := range parts {
        if i > 0 { sb.WriteString(sep) }
        sb.WriteString(p)
    }
    return sb.String()
}

func main() {
    fmt.Println(join([]string{"a", "b", "c"}, "-")) // a-b-c
}

strings.NewReader y strings.Reader

strings.NewReader crea un io.Reader a partir de una cadena; resulta útil para probar funciones que aceptan lectores:

package main
import ("fmt"; "io"; "strings")

func readAll(r io.Reader) string {
    data, _ := io.ReadAll(r)
    return string(data)
}

func main() {
    r := strings.NewReader("Hello from a string reader")
    fmt.Println(readAll(r))

    // Also: strings.NewReplacer for multiple replacements
    rep := strings.NewReplacer("<", "&lt;", ">", "&gt;")
    fmt.Println(rep.Replace("<b>bold</b>"))
}

strings.Fields y strings.Map

Otras funciones útiles de strings:

package main
import ("fmt"; "strings")

func main() {
    // Fields splits on any whitespace (like awk)
    words := strings.Fields("  one  two   three  ")
    fmt.Println(words) // [one two three]

    // Map applies a function to each rune
    rot13 := func(r rune) rune {
        if r >= 'a' && r <= 'z' { return 'a' + (r-'a'+13)%26 }
        if r >= 'A' && r <= 'Z' { return 'A' + (r-'A'+13)%26 }
        return r
    }
    fmt.Println(strings.Map(rot13, "Hello, World!"))
}

Comprobación rápida

¿Qué función debe utilizar para concatenar muchas cadenas de forma eficiente en Go?

Responde en la lección interactiva

Resumen: fmt y strings

Resumen:

fmt.Printf/Sprintf para mostrar resultados o crear cadenas con formato mediante verbos de formato (%s %d %f %v %T %q)
fmt.Errorf para errores con formato; %w para envolver errores
strings.Split/Join, Contains, Replace, TrimSpace, ToUpper/Lower
strings.Builder para una concatenación eficiente
strings.NewReader para utilizar una cadena como io.Reader

Gratis para empezar

Aprende Go con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Packages fmt y strings» es gratis?

Sí — el texto completo de «Packages fmt y strings» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Packages fmt y strings»?

Formateo de la salida y manipulación de strings Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Packages fmt y strings»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy