Go Academy · Lezione

strconv, math e sort

Conversione dei tipi, utilità matematiche e ordinamento

strconv, math e sort è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

strconv: conversioni di stringhe

Il pacchetto strconv converte stringhe e tipi di base da un formato all'altro:

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

func main() {
    // String to int
    n, err := strconv.Atoi("42")
    fmt.Println(n, err)           // 42 <nil>

    // Int to string
    s := strconv.Itoa(123)
    fmt.Println(s)                // "123"

    // String to float64
    f, _ := strconv.ParseFloat("3.14", 64)
    fmt.Println(f)                // 3.14

    // Float64 to string
    fs := strconv.FormatFloat(f, 'f', 2, 64)
    fmt.Println(fs)               // "3.14"
}

strconv.ParseInt e ParseBool

Analizza gli interi con una base e i valori booleani:

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

func main() {
    // Parse int with base
    n, _ := strconv.ParseInt("FF", 16, 64)   // hex
    fmt.Println(n)  // 255

    n2, _ := strconv.ParseInt("11111111", 2, 64) // binary
    fmt.Println(n2) // 255

    // Bool parsing
    b1, _ := strconv.ParseBool("true")
    b2, _ := strconv.ParseBool("1")
    b3, _ := strconv.ParseBool("T")
    fmt.Println(b1, b2, b3) // true true true
}

Gestione degli errori di strconv

Gestisci sempre gli errori di strconv: un input non valido restituisce un errore racchiuso in *strconv.NumError:

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

func safeAtoi(s string) (int, error) {
    n, err := strconv.Atoi(s)
    if err != nil {
        return 0, fmt.Errorf("invalid integer %q: %w", s, err)
    }
    return n, nil
}

func main() {
    n, err := safeAtoi("abc")
    fmt.Println(n, err)
    // 0 invalid integer "abc": strconv.Atoi: ...
}

Elementi essenziali del pacchetto math

Il pacchetto math fornisce costanti e funzioni matematiche:

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

func main() {
    fmt.Println(math.Pi)           // 3.141592653589793
    fmt.Println(math.E)            // 2.718281828459045
    fmt.Println(math.Sqrt(16))     // 4
    fmt.Println(math.Pow(2, 10))   // 1024
    fmt.Println(math.Abs(-5.5))    // 5.5
    fmt.Println(math.Floor(3.7))   // 3
    fmt.Println(math.Ceil(3.2))    // 4
    fmt.Println(math.Round(3.5))   // 4
    fmt.Println(math.Log(math.E))  // 1
    fmt.Println(math.Log2(8))      // 3
}

math.MaxInt e limiti dei float

Usa le costanti di math per i limiti degli interi e dei float:

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

func main() {
    fmt.Println(math.MaxInt)      // max int (platform-dependent)
    fmt.Println(math.MinInt)      // min int
    fmt.Println(math.MaxInt32)    // 2147483647
    fmt.Println(math.MaxFloat64)  // 1.7976931348623157e+308
    fmt.Println(math.SmallestNonzeroFloat64)
    fmt.Println(math.IsInf(math.Inf(1), 1)) // true
    fmt.Println(math.IsNaN(math.NaN()))     // true
}

math/rand — numeri casuali

Genera numeri casuali con math/rand (da Go 1.20 l'inizializzazione del generatore avviene automaticamente):

package main
import ("fmt"; "math/rand")

func main() {
    // Go 1.20+: automatically seeded
    fmt.Println(rand.Intn(100))     // random 0-99
    fmt.Println(rand.Float64())     // random [0.0, 1.0)

    // Shuffle a slice
    s := []int{1, 2, 3, 4, 5}
    rand.Shuffle(len(s), func(i, j int) {
        s[i], s[j] = s[j], s[i]
    })
    fmt.Println(s)
}

sort.Slice — ordinamento personalizzato rapido

Ordina qualsiasi slice con un comparatore personalizzato usando sort.Slice:

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

func main() {
    people := []struct{ Name string; Age int }{
        {"Alice", 30}, {"Bob", 25}, {"Carol", 35},
    }

    // Sort by age ascending
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })
    fmt.Println(people)
    // [{Bob 25} {Alice 30} {Carol 35}]
}

sort.Strings, sort.Ints, sort.Float64s

Funzioni di ordinamento integrate per i tipi di slice più comuni:

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

func main() {
    strs := []string{"banana", "apple", "cherry"}
    sort.Strings(strs)
    fmt.Println(strs)  // [apple banana cherry]

    nums := []int{5, 2, 8, 1, 9, 3}
    sort.Ints(nums)
    fmt.Println(nums)  // [1 2 3 5 8 9]

    // Check if already sorted:
    fmt.Println(sort.IntsAreSorted(nums)) // true
}

sort.Search — ricerca binaria

sort.Search esegue una ricerca binaria su una slice ordinata:

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

func main() {
    nums := []int{1, 3, 5, 7, 9, 11, 13}
    target := 7

    i := sort.Search(len(nums), func(i int) bool {
        return nums[i] >= target
    })

    if i < len(nums) && nums[i] == target {
        fmt.Printf("Found %d at index %d\n", target, i) // Found 7 at index 3
    }
}

Pacchetto slices (Go 1.21+)

Go 1.21 ha aggiunto il pacchetto slices, che contiene funzioni generiche per l'ordinamento e la ricerca:

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

func main() {
    nums := []int{5, 2, 8, 1}
    slices.Sort(nums)                  // in-place sort
    fmt.Println(nums)                  // [1 2 5 8]

    strs := []string{"c", "a", "b"}
    slices.Sort(strs)
    fmt.Println(strs)                  // [a b c]

    idx, found := slices.BinarySearch(nums, 5)
    fmt.Println(idx, found)            // 2 true
}

Verifica rapida

Quale funzione converte un intero nella relativa rappresentazione come stringa in Go?

Riepilogo: strconv, math, sort

Riepilogo:

strconv.Atoi/Itoa, ParseFloat/FormatFloat, ParseBool per le conversioni
math.Sqrt/Pow/Abs/Floor/Ceil/Round per i calcoli matematici
math.MaxInt/MaxFloat64 per i limiti dei tipi
sort.Slice per l'ordinamento personalizzato, sort.Strings/Ints per i tipi primitivi
sort.Search per la ricerca binaria
Il pacchetto slices (Go 1.21+) per alternative generiche

Domande Frequenti

La lezione «strconv, math e sort» è gratuita?

Sì — il testo completo di «strconv, math e sort» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «strconv, math e sort»?

Conversione dei tipi, utilità matematiche e ordinamento Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «strconv, math e sort»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy