Gino Luraschi

Posted on Aug 17, 2023

Novedades en Go 1.21 🚀

#go #programming

Introducción

Después de la versión 1.20, Go lanza la versión 1.21 con algunas pequeñas novedades para explotar un poco más el lenguaje, como siempre la nueva versión tiene retrocompatibilidad con versiones anteriores, por lo que cambiar a la nueva versión no debería impactar en lo que ya tengamos hecho. Sin más vamos a revisar cuales son las novedades en esta versión:

Cambios en el lenguaje

Min y Max

En esta nueva versión de Go encontramos funciones nuevas integradas como min y max, el cual toma un listado de valores y los compara devolviendo mínimo o máximo respectivamente.

package main

import "fmt"

func main() {
    x := 10
    y := 15
    mn := min(x, y) // m is the smaller of x and y
    fmt.Printf("The min is %d \n", mn)
    mx := max(x, y, 10) // m is the larger of x and y but at least 10
    fmt.Printf("The max is %d \n", mx)
    c := max(1, 2.0, 10) // c == 10.0 (floating-point kind)
    fmt.Printf("The max is %f \n", c)
    f := max(0, float32(x)) // type of f is float32
    fmt.Printf("The max is %f \n", f)
    // var s []string
    // _ = min(s...)// invalid: slice arguments are not permitted
    t := max("", "foo", "bar") // t == "foo" (string kind)
    fmt.Printf("The max is %s \n", t)
}

Clear

Otra novedad de la nueva versión de Go, es la función clear

package main

import "fmt"

func main() {
    var mapToClear = map[string]int{"k1": 1, "k2": 2, "k3": 3}
    clear(mapToClear) // Elimina todos los pares Key-Value (len(m) == 0)
    fmt.Printf("%v \n", mapToClear)
    var arr = []int{1, 2, 3, 4}
    clear(arr) // Vuelve todos los elementos al valor Zero del tipo
    fmt.Printf("%v \n", arr)
    /*
        var t = struct {
            // Name       string // Dato invalido para limpiar
            mapToClear map[string]int
        }{
            // Name:       "test",
            mapToClear: map[string]int{"k1": 1, "k2": 2, "k3": 3},
        }
         clear(t) // No se puede hacer esto, tira un error ya que t debe ser del tipo map o slice
    */
}

Otras cositas del lenguaje

En cuanto a los genéricos, se hicieron mejoras en cuanto a la inferencia de los tipos. Ahora se incluye una explicación sobre el proceso y como funciona en la documentación oficial.

Algo que planean hacer, que esta incluido en la version 1.21 de Go como experimental, es arreglar la captura de variables en los ciclos for, para eso recomiendan ir al caso escrito en LoopvarExperiment

Novedades de la SDK

Paquete log/slog

una de las cositas más interesantes que sumó esta nueva versión es el nuevo paquete log/slog para logging, el cual agrega funcionalidades a nuestro logging sin necesidad de sumar una librería:

package main

import (
    "log"
    "log/slog"
)

func main() {
    slog.Info("hello", "count", 3)
    // 2009/11/10 23:00:00 INFO hello count=3
    log.Println("hello", "count", 3)
    // 2009/11/10 23:00:00 hello count 3

    slog.Info("hello", "count", 1)
    // 2009/11/10 23:00:00 INFO hello count=1
    slog.Error("hello", "count", 2)
    // 2009/11/10 23:00:00 ERROR hello count=2
    slog.Warn("hello", "count", 3)
    // 2009/11/10 23:00:00 WARN hello count=3
    slog.Debug("hello", "count", 4)
    // 2009/11/10 23:00:00 DEBUG hello count=4

    // Print as json
    h := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})
    slog.SetDefault(slog.New(h))
    slog.Debug("it's a debug log")
}

Paquete slice

Nuevo paquete slice para manejo de slices justamente, esta incluye funcionalidades interesantes como métodos de ordenamiento o de búsquedas:

package main

import (
    "fmt"
    "slices"
)

func main() {
    arr := []int{8, 2, 4, 5, 1}
    slices.Sort(arr) // Es mutable, por lo que cambia el array original
    fmt.Println(arr) // [1 2 4 5 8]

    index, found := slices.BinarySearch(arr, 2)
    fmt.Println(found, index) // true 1
}

Paquete maps

Tambien se suma un nuevo paquete maps para los mapas pero con menos funciones:

package main

import (
    "fmt"
    "maps"
)

func main() {
    mapEx := map[string]int{"k1": 1, "k2": 2}
    mapClone := maps.Clone(mapEx)
    fmt.Println(mapClone) // map[k1:1 k2:2]

    equal := maps.Equal(mapEx, mapClone)
    fmt.Println(equal) // true
}

Paquete cmp

Tambien se agrega un nuevo paquete cmp para comparar elementos:

package main

import (
    "cmp"
    "fmt"
)

func main() {
    // -1 if x is less than y,
    // 0 if x equals y,
    // +1 if x is greater than y.
    x := 5
    y := 10
    res := cmp.Compare(x, y)
    fmt.Println(res) // -1
    res = cmp.Compare(y, x)
    fmt.Println(res) // 1
    res = cmp.Compare(5, x)
    fmt.Println(res) // 0

    isLess := cmp.Less(5, x)
    fmt.Println(isLess) // false
    isLess = cmp.Less(x, y)
    fmt.Println(isLess) // true
}

Profile Guided Optimization

La herramienta Profile Guided Optimization (PGO) anunciada en la versión 1.20 ahora está disponible sin necesidad de habilitarla. Con esta herramienta vamos a poder construir paquetes más optimizados. Incluso se ha medido el impacto en varios programas y se ve mejoras del 2% al 7%.

Mejoras en la performance

Además de lo mencionado en PGO, podemos ver:

El compilador de go fue reconstruido en la nueva versión con PGO habilitado, lo que logró hacerlo 2-4% más rápido dependiendo del sistema que lo ejecute.
Debido a la mejora en el Garbage Collector, se detecta una reducción del 40% en la latencia de cola.
Ahora la recolección de runtime/trace ahora reduce el costo para arquitectura arm64 y amd64.

Conclusión

Estas son algunas de las novedades que podemos detectar de la nueva versión de go, para más detalle puede ir a leer el blog oficial en https://go.dev/blog/go1.21. Espero les ayude este resumen a poder comprenderlo.

DEV Community