Go Academy · Lekcja

Wartości domyślne i walidacja

Ustawiaj rozsądne wartości domyślne

Lekcja 4 z 413 kroki

Wartości domyślne i walidacja 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.

Ustawianie rozsądnych wartości domyślnych

Solidny konstruktor zaczyna od dobrych wartości domyślnych, a następnie pozwala opcjom je nadpisać. Dzięki temu można całkowicie uniknąć pułapki wartości zero.

Inicjalizacja przed zastosowaniem opcji

Najpierw utwórz konfigurację z wartościami domyślnymi, a następnie zastosuj opcje.

package main

import "fmt"

type Server struct {
	Port    int
	Timeout int
}
type Option func(*Server)

func WithPort(p int) Option { return func(s *Server) { s.Port = p } }

func NewServer(opts ...Option) *Server {
	s := &Server{Port: 8080, Timeout: 30}
	for _, o := range opts { o(s) }
	return s
}

func main() {
	fmt.Printf("%+v\n", *NewServer())
	fmt.Printf("%+v\n", *NewServer(WithPort(9000)))
}

Wartości domyślne obowiązują do ich nadpisania

Wywołanie bez opcji zwraca wartości domyślne, a opcja zastępuje tylko pole, którego dotyczy. To najlepsze rozwiązanie obu problemów.

Sprawdzanie po zastosowaniu opcji

Po zastosowaniu opcji sprawdź końcową konfigurację i zwróć błąd, jeśli jest nieprawidłowa. Konstruktor powinien zwracać (*T, error).

package main

import (
	"errors"
	"fmt"
)

type Server struct{ Port int }
type Option func(*Server)

func WithPort(p int) Option { return func(s *Server) { s.Port = p } }

func NewServer(opts ...Option) (*Server, error) {
	s := &Server{Port: 8080}
	for _, o := range opts { o(s) }
	if s.Port < 1 || s.Port > 65535 {
		return nil, errors.New("invalid port")
	}
	return s, nil
}

func main() {
	_, err := NewServer(WithPort(99999))
	fmt.Println(err)
}

Sprawdzanie wewnątrz opcji

Alternatywnie same opcje mogą zwracać błąd. Typ Option przyjmuje wtedy postać func(*Config) error.

package main

import (
	"errors"
	"fmt"
)

type Server struct{ Port int }
type Option func(*Server) error

func WithPort(p int) Option {
	return func(s *Server) error {
		if p < 1 {
			return errors.New("port must be positive")
		}
		s.Port = p
		return nil
	}
}

func NewServer(opts ...Option) (*Server, error) {
	s := &Server{Port: 8080}
	for _, o := range opts {
		if err := o(s); err != nil {
			return nil, err
		}
	}
	return s, nil
}

func main() {
	_, err := NewServer(WithPort(-1))
	fmt.Println(err)
}

Który styl sprawdzania wybrać

Sprawdzaj poprawność w opcjach, gdy chodzi o kontrole poszczególnych ustawień; sprawdzaj po zastosowaniu opcji, gdy chodzi o reguły między polami (np. TLS wymaga ścieżki do certyfikatu). Często stosuje się oba podejścia.

Dokumentowanie wartości domyślnych

Zawsze opisuj każdą wartość domyślną w komentarzu dokumentacyjnym konstruktora, aby użytkownicy wiedzieli, co otrzymają po pominięciu opcji.

Wymagane a opcjonalne

Rzeczywiście wymagane wartości pozostaw jako parametry pozycyjne, a opcje przeznacz tylko dla wartości naprawdę opcjonalnych. Nie ukrywaj wymaganych danych za opcją.

package main

import "fmt"

type Client struct {
	BaseURL string
	Retries int
}
type Option func(*Client)

func WithRetries(n int) Option { return func(c *Client) { c.Retries = n } }

func NewClient(baseURL string, opts ...Option) *Client {
	c := &Client{BaseURL: baseURL, Retries: 3}
	for _, o := range opts { o(c) }
	return c
}

func main() {
	fmt.Printf("%+v\n", *NewClient("https://api"))
}

Łączenie opcji

Możesz połączyć kilka opcji w jeden preset dla często używanych konfiguracji.

package main

import "fmt"

type Server struct{ Port, Timeout int }
type Option func(*Server)

func WithPort(p int) Option    { return func(s *Server) { s.Port = p } }
func WithTimeout(t int) Option { return func(s *Server) { s.Timeout = t } }

func Production() Option {
	return func(s *Server) {
		WithPort(443)(s)
		WithTimeout(60)(s)
	}
}

func NewServer(opts ...Option) *Server {
	s := &Server{Port: 8080, Timeout: 30}
	for _, o := range opts { o(s) }
	return s
}

func main() {
	fmt.Printf("%+v\n", *NewServer(Production()))
}

Dobre praktyki

Zaczynaj od wartości domyślnych, a następnie stosuj opcje
Po zastosowaniu opcji sprawdzaj reguły między polami
Wymagane wartości pozostaw jako parametry pozycyjne
Dokumentuj każdą wartość domyślną

Kompletne, solidne API

Połączenie wartości domyślnych, opcji i sprawdzania poprawności daje konstruktor, który jest elastyczny, bezpieczny, samodokumentujący się i łatwy do rozszerzania.

Szybkie sprawdzenie

Sprawdź swoją wiedzę o wartościach domyślnych i sprawdzaniu poprawności.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Ukończyłeś omawianie wzorca opcji funkcyjnych.

Ustawiaj wartości domyślne przed zastosowaniem opcji
Sprawdzaj poprawność po zastosowaniu opcji lub wewnątrz nich, gdy kontrolujesz poszczególne pola
Wymagane wartości pozostaw jako parametry pozycyjne
Łącz opcje w presety i dokumentuj wartości domyślne

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 „Wartości domyślne i walidacja” jest bezpłatna?

Tak — pełny tekst „Wartości domyślne i walidacja” 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 „Wartości domyślne i walidacja”?

Ustawiaj rozsądne wartości domyślne Ć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 „Wartości domyślne i walidacja”?

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