Go Academy · Aula

strconv, math e sort

Conversão de tipos, utilitários matemáticos e ordenação

strconv, math e sort é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

strconv: conversões de cadeias de caracteres

O pacote strconv converte entre cadeias de caracteres e tipos básicos:

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

Analise inteiros com uma base e valores booleanos:

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
}

Tratamento de erros do strconv

Sempre trate os erros de strconv — uma entrada inválida retorna um erro encapsulado em *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: ...
}

Fundamentos do pacote math

O pacote math fornece constantes e funções matemáticas:

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 limites de ponto flutuante

Utilize as constantes de math para limites de inteiros e números de ponto flutuante:

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 — números aleatórios

Gere números aleatórios com math/rand (o Go 1.20+ inicializa a semente 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 — ordenação personalizada rápida

Ordene qualquer fatia com um comparador personalizado utilizando 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

Funções de ordenação integradas para tipos comuns de fatias:

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 — busca binária

sort.Search realiza uma busca binária em uma fatia ordenada:

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
    }
}

Pacote slices (Go 1.21+)

O Go 1.21 adicionou o pacote slices, com funções genéricas de ordenação e busca:

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ção rápida

Qual função converte um inteiro em sua representação textual em Go?

Revisão: strconv, math, sort

Resumo:

strconv.Atoi/Itoa, ParseFloat/FormatFloat, ParseBool para conversões
math.Sqrt/Pow/Abs/Floor/Ceil/Round para cálculos matemáticos
math.MaxInt/MaxFloat64 para limites de tipos
sort.Slice para ordenação personalizada, sort.Strings/Ints para tipos primitivos
sort.Search para busca binária
Pacote slices (Go 1.21+) para alternativas genéricas

Perguntas Frequentes

A aula “strconv, math e sort” é grátis?

Sim — o texto completo de “strconv, math e sort” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “strconv, math e sort”?

Conversão de tipos, utilitários matemáticos e ordenação Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “strconv, math e sort”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy