Go Academy · Lekcja

strconv, math i sort

Konwersja typów, narzędzia matematyczne i sortowanie

Lekcja 2 z 412 kroki

strconv, math i sort to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

strconv: konwersje łańcuchów znaków

Pakiet strconv konwertuje łańcuchy znaków na typy podstawowe i odwrotnie:

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 i ParseBool

Parsuj liczby całkowite z określoną podstawą oraz wartości boolowskie:

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
}

Obsługa błędów strconv

Zawsze obsługuj błędy strconv — nieprawidłowe dane wejściowe powodują zwrócenie błędu opakowanego w *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: ...
}

Najważniejsze informacje o pakiecie math

Pakiet math udostępnia stałe i funkcje matematyczne:

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 i ograniczenia typów zmiennoprzecinkowych

Używaj stałych pakietu math do określania ograniczeń typów całkowitoliczbowych i zmiennoprzecinkowych:

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 — liczby losowe

Generuj liczby losowe za pomocą math/rand (od Go 1.20 generator jest inicjowany ziarnem automatycznie):

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 — szybkie sortowanie niestandardowe

Sortuj dowolny wycinek za pomocą niestandardowego komparatora, używając 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

Wbudowane funkcje sortowania dla popularnych typów wycinków:

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 — wyszukiwanie binarne

sort.Search wykonuje wyszukiwanie binarne w posortowanym wycinku:

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

Pakiet slices (Go 1.21+)

W Go 1.21 dodano pakiet slices z generycznymi funkcjami sortowania i wyszukiwania:

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
}

Szybki test

Która funkcja konwertuje liczbę całkowitą na jej reprezentację tekstową w Go?

Odpowiedz w interaktywnej lekcji

Podsumowanie: strconv, math, sort

Podsumowanie:

strconv.Atoi/Itoa, ParseFloat/FormatFloat, ParseBool do konwersji
math.Sqrt/Pow/Abs/Floor/Ceil/Round do obliczeń matematycznych
math.MaxInt/MaxFloat64 do określania limitów typów
sort.Slice do sortowania niestandardowego, sort.Strings/Ints do sortowania typów podstawowych
sort.Search do wyszukiwania binarnego
pakiet slices (Go 1.21+) jako generyczna alternatywa

Bezpłatny start

Ucz się Go dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „strconv, math i sort” jest bezpłatna?

Tak — pełny tekst „strconv, math i sort” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „strconv, math i sort”?

Konwersja typów, narzędzia matematyczne i sortowanie Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „strconv, math i sort”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy