Praca ze zmiennymi środowiskowymi w Go

Zmienne środowiskowe to pary klucz-wartość o dynamicznych nazwach, które są umieszczane w środowisku hosta i używane do wpływania na działanie programów.

Zmienne środowiskowe są popularne w przypadku interakcji z danymi wrażliwymi na aplikacje, ponieważ zapewniają abstrakcję interfejsu środowiska. Możesz użyć zmiennych środowiskowych, aby zwiększyć bezpieczeństwo swoich aplikacji.

Go zapewnia wbudowaną obsługę pracy ze zmiennymi środowiskowymi, a w ekosystemie Go istnieje wiele pakietów do pracy ze zmiennymi środowiskowymi i plikami zmiennych środowiskowych ( .env ).

Zmienne środowiskowe i pakiet os

Pakiet os zapewnia funkcjonalność umożliwiającą interakcję z systemem operacyjnym środowiska hosta. Pakiet os udostępnia metody ustawiania i pobierania par klucz-wartość zmiennych środowiskowych.

Zaimportuj te pakiety w celu ustawienia, załadowania i wydrukowania zmiennych środowiskowych na komputerze hosta.

import (
    "fmt"
    "log"
    "os"
    "strings"
)

Możesz ustawić pary klucz-wartość zmiennej środowiskowej za pomocą metody Setenv pakietu os . Metoda Setenv przyjmuje parę i zwraca możliwe błędy.

err: = os.Setenv("NAME", "John")
err = os.Setenv("OTHER", "DOE")
if err! = nil {
        return
    }

Możesz pobrać zmienne środowiskowe według kluczy (nazw) za pomocą metody Getenv . Metoda Getenv pobiera nazwę zmiennej środowiskowej i zwraca wartość powiązaną z kluczem.

name: = os.Getenv("NAME")
other: = os.Getenv("OTHER")

Metoda Environ umożliwia dostęp do wszystkich zmiennych środowiskowych na komputerze hosta. Metoda Environ zwraca wycinek ciągów znaków, przez który można przechodzić w pętli i uzyskiwać dostęp do kluczy zmiennych środowiskowych.

for _, variables: = range os.Environ() {
        envPair: = strings.SplitN(variables, "=", 2)
        fmt.Println(envPair[0])
}

Metoda SplitN pakietu strings pomaga w dzieleniu przez ogranicznik. W tym przypadku oddziela nazwę zmiennej od wartości.

Jak załadować zmienne środowiskowe z . Pliki env

Pakiet godotenv jest portem Go projektu Ruby dotenv do ładowania zmiennych środowiskowych z pliku dotenv.

Pakiet godotenv zapewnia funkcje do pracy z plikami dotenv w pakiecie os , możesz pisać i czytać z plików .env .

Uruchom to polecenie, aby utworzyć plik .env w katalogu roboczym.

touch. env

Polecenie touch służy do tworzenia nowych plików. Dodaj następujące wiersze kodu do pliku dotenv. Użyjesz pakietu godotenv do odczytania tych zmiennych środowiskowych w swoim programie Go.

# env
NAME="John"
OTHER="James"

Uruchom to polecenie w terminalu katalogu twojego projektu, aby zainstalować pakiet godotenv jako zależność projektu.

go get github.com/joho/godotenv

Zaimportuj te pakiety do pliku Go. Będziesz ich używać wraz z pakietem godotenv do ładowania zmiennych środowiskowych i drukowania ich w konsoli lub rejestrowania błędów.

import (
    "fmt"
    "github.com/joho/godotenv"
    "log"
    "os"
)

Możesz załadować plik .env za pomocą metody Load pakietu godotenv . Metoda Load przyjmuje nazwę pliku i zwraca możliwe błędy.

err: = godotenv.Load(".env")
if err! = nil {
        log.Fatalf("Error loading environment variables file")
    }

Po załadowaniu pliku dotenv możesz użyć metody Getenv pakietu os , aby załadować zmienne środowiskowe.

name: = os.Getenv("NAME")
other: = os.Getenv("OTHER")
fmt.Println(name)
fmt.Println(other)

Możesz pisać do plików dotenv za pomocą metody Write pakietu godotenv . Metoda Write przyjmuje mapę ciągów na ciągi i zwraca możliwe błędy.

func writeToDotEnv(){
    env, _: = godotenv.Unmarshal("KEY=value")
    err: = godotenv.Write(env, ".env")
    if err! = nil {
        log.Println("There was an error writing to the dotenv file")
}
}

Pakiet godotenv unmarshaluje ciąg pary klucz-wartość metodą Unmarshal , a zmienna env staje się odwzorowaniem typu string na string.

Funkcja writeToDotEnv zapisuje zawartość mapy do pliku .env w katalogu roboczym. Ta operacja zastępuje istniejące dane.

Zmienne środowiskowe zawsze się przydają

Zmienne środowiskowe ułatwiają ustawianie i zmianę parametrów wykonywania aplikacji bez zmiany kodu lub konfiguracji, zwiększając w ten sposób przenośność aplikacji.

Możesz mieć wiele zmiennych środowiskowych i plików dotenv dla różnych scenariuszy, aby przetestować działanie aplikacji w różnych parametrach lub warunkach.