Go Academy · Lekcja

Pakiety os i filepath

Zmienne środowiskowe, ścieżki i interakcja z systemem operacyjnym

Pakiety os i filepath to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 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.

os.Args — argumenty wiersza poleceń

os.Args przechowuje argumenty wiersza poleceń. os.Args[0] zawiera nazwę programu:

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

func main() {
    fmt.Println("Program:", os.Args[0])
    if len(os.Args) < 2 {
        fmt.Println("Usage: program <name>")
        os.Exit(1)
    }
    fmt.Printf("Hello, %s!\n", os.Args[1])
}

os.Getenv i os.Setenv

Odczytywanie i zapisywanie zmiennych środowiskowych:

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

func main() {
    // Read env var (returns "" if not set)
    home := os.Getenv("HOME")
    fmt.Println("HOME:", home)

    // Set env var
    os.Setenv("APP_ENV", "production")
    fmt.Println(os.Getenv("APP_ENV")) // production

    // Get with default pattern:
    port := os.Getenv("PORT")
    if port == "" { port = "8080" }
    fmt.Println("Port:", port)
}

os.Exit — kończenie programu

os.Exit kończy program z określonym kodem statusu. Kod 0 oznacza powodzenie, a kod różny od zera — błąd. Funkcje odroczone NIE zostaną wykonane:

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

func main() {
    config := os.Getenv("CONFIG_PATH")
    if config == "" {
        fmt.Fprintln(os.Stderr, "error: CONFIG_PATH not set")
        os.Exit(1)  // signals error to the shell
    }
    fmt.Println("config:", config)
}

os.Open, os.Create, os.ReadFile

Operacje na plikach z użyciem pakietu os:

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

func main() {
    // Read entire file
    data, err := os.ReadFile("/etc/hostname")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("hostname: %s", data)

    // Write file (overwrites if exists)
    err = os.WriteFile("/tmp/test.txt", []byte("hello\n"), 0644)
    fmt.Println("write err:", err)
}

os.Stat — informacje o pliku

os.Stat zwraca informacje o pliku lub katalogu:

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

func main() {
    info, err := os.Stat("/tmp")
    if err != nil {
        if os.IsNotExist(err) {
            fmt.Println("does not exist")
        }
        return
    }
    fmt.Println(info.Name())     // tmp
    fmt.Println(info.IsDir())    // true
    fmt.Println(info.Size())     // size in bytes
    fmt.Println(info.Mode())     // file permissions
    fmt.Println(info.ModTime())  // last modified time
}

os.MkdirAll i os.RemoveAll

Tworzenie i usuwanie całych drzew katalogów:

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

func main() {
    // Create nested directories
    err := os.MkdirAll("/tmp/myapp/data/logs", 0755)
    fmt.Println("mkdir:", err)

    // Remove a file
    err = os.Remove("/tmp/test.txt")
    fmt.Println("remove:", err)

    // Remove directory and all contents
    err = os.RemoveAll("/tmp/myapp")
    fmt.Println("removeAll:", err)
}

path/filepath: ścieżki niezależne od platformy

path/filepath obsługuje ścieżki plików, używając separatora ścieżek systemu operacyjnego (/ w systemach Unix, \ w systemie Windows):

package main
import ("fmt"; "path/filepath")

func main() {
    // Join path components correctly
    p := filepath.Join("/home", "user", "docs", "file.txt")
    fmt.Println(p)  // /home/user/docs/file.txt

    // Split path and file
    dir, file := filepath.Split(p)
    fmt.Println(dir, file) // /home/user/docs/ file.txt

    // Extension
    fmt.Println(filepath.Ext(p))  // .txt

    // Base name
    fmt.Println(filepath.Base(p)) // file.txt
}

filepath.Walk — przechodzenie po katalogach

Przechodzenie po całym drzewie katalogów z odwiedzaniem każdego pliku i katalogu:

package main
import ("fmt"; "os"; "path/filepath")

func main() {
    err := filepath.Walk("/tmp", func(path string, info os.FileInfo, err error) error {
        if err != nil { return err }
        if info.IsDir() {
            fmt.Println("[DIR]", path)
        } else {
            fmt.Printf("[FILE] %s (%d bytes)\n", path, info.Size())
        }
        return nil
    })
    if err != nil { fmt.Println("walk error:", err) }
}

filepath.Glob — dopasowywanie wzorców

Wyszukiwanie plików pasujących do wzorca glob:

package main
import ("fmt"; "path/filepath")

func main() {
    // Find all .go files in current directory
    matches, err := filepath.Glob("*.go")
    if err != nil {
        fmt.Println(err)
        return
    }
    for _, m := range matches {
        fmt.Println(m)
    }

    // Absolute path resolution
    abs, _ := filepath.Abs("../myfile.txt")
    fmt.Println(abs)
}

os.TempDir i os.CreateTemp

Bezpieczne tworzenie plików tymczasowych:

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

func main() {
    // System temp directory
    fmt.Println(os.TempDir()) // /tmp

    // Create a unique temp file
    f, err := os.CreateTemp("", "myapp-*.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer os.Remove(f.Name()) // clean up
    defer f.Close()
    fmt.Println("temp file:", f.Name())
    _, _ = f.WriteString(`{"status":"ok"}`)
}

Szybki test

Która funkcja prawidłowo łączy składniki ścieżki pliku w sposób niezależny od platformy?

Podsumowanie: os i filepath

Podsumowanie:

os.Args — argumenty polecenia; os.Getenv/Setenv — zmienne środowiskowe
os.ReadFile/WriteFile do prostych operacji wejścia-wyjścia na plikach
os.Stat — informacje o pliku; os.IsNotExist(err) do sprawdzania brakujących plików
os.MkdirAll/RemoveAll do zarządzania katalogami
filepath.Join/Split/Ext/Base do obsługi ścieżek niezależnych od platformy
filepath.Walk do przechodzenia po całych drzewach katalogów

Często zadawane pytania

Czy lekcja „Pakiety os i filepath” jest bezpłatna?

Tak — pełny tekst „Pakiety os i filepath” 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 „Pakiety os i filepath”?

Zmienne środowiskowe, ścieżki i interakcja z systemem operacyjnym Ć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 4 z 4.

Ile czasu zajmuje lekcja „Pakiety os i filepath”?

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