Arbeide med miljøvariabler i Go

Miljøvariabler er dynamisk navngitte nøkkelverdi-par satt til side i vertsmiljøet som brukes til å påvirke driften av programmer.

Miljøvariabler er populære for å samhandle med applikasjonssensitive data da de gir en abstraksjon over grensesnittet til miljøet. Du kan bruke miljøvariabler for å øke applikasjonens sikkerhet.

Go gir innebygd støtte for arbeid med miljøvariabler, og det finnes mange pakker for å jobbe med miljøvariabler og miljøvariablefiler (.env) i Go-økosystemet.

Miljøvariabler og OS-pakken

De os pakken gir funksjonalitet for samhandling med vertsmiljøets operativsystem. De os pakken gir metoder for å sette og hente miljøvariable nøkkel-verdi-par.

Importer disse pakkene for innstilling, lasting og utskrift av miljøvariablene på vertsmaskinen.

import (
"fmt"
"Logg"
"os"
"strenger"
)

Du kan angi nøkkelverdipar for miljøvariabler med Setenv metoden for os pakke. De Setenv metoden tar inn paret og returnerer mulige feil.

feil := os. Setenv("NAVN", "John")
feil = os. Setenv("ANNEN", "DOE")
hvis feil!= null {
komme tilbake
 }

Du kan hente miljøvariabler ved hjelp av tastene (navnene) med Getenv metode. De Getenv metoden tar inn miljøvariabelens navn og returnerer verdien knyttet til nøkkelen.

navn := os. Getenv("NAVN")
annet := os. Getenv("ANNEN")

De Environ metoden lar deg få tilgang til alle miljøvariablene på vertsmaskinen. De Environ metoden returnerer en del av strenger du kan gå gjennom og få tilgang til nøklene til miljøvariabler.

til _, variabler := område os. Environ() {
 envPair := strenger. DelN(variabler, "=", 2)
 fmt. Println (envPair[0]) 
}

De SplitN metoden for strenger-pakken hjelper med å dele opp med et skilletegn. I dette tilfellet deler den variabelnavnet fra verdien.

Hvordan laste inn miljøvariabler fra .env-filer

De godotenv pakken er en Go-port av Ruby dotenv-prosjektet for å laste miljøvariabler fra dotenv-filen.

De godotenv pakken gir funksjonalitet for arbeider med dotenv-filer over os pakke, du kan skrive og lese fra .env filer.

Kjør denne kommandoen for å lage en .env filen i arbeidskatalogen din.

trykk på .env

Berøringskommandoen brukes til å lage nye filer. Legg til følgende kodelinjer i dotenv-filen. Du vil bruke godotenv pakken for å lese disse miljøvariablene i Go-programmet.

# env
NAVN="John"
ANNET="James"

Kjør denne kommandoen i terminalen i prosjektets katalog for å installere godotenv pakke som en prosjektavhengighet.

gå skaff deg github.com/joho/godotenv

Importer disse pakkene til Go-filen din. Du vil bruke dem sammen med godotenv pakke for å laste miljøvariabler og skrive dem ut til konsollen eller logge feil.

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

Du kan laste en .env fil med Laste metoden for godotenv pakke. De Laste metoden tar inn filnavnet og returnerer mulige feil.

feil := godotenv. Laste(".env")
hvis feil!= null {
 Logg. Fatalf("Feil ved lasting av fil med miljøvariabler")
 }

Etter å ha lastet inn dotenv-filen, kan du bruke Getenv metoden for os pakke for å laste miljøvariablene.

navn := os. Getenv("NAVN")
annet := os. Getenv("ANNEN")
fmt. Println (navn)
fmt. Println (annet)

Du kan skrive til dotenv-filer med Skrive metoden for godotenv pakke. De Skrive metoden tar inn et kart over strenger til strenger og returnerer mulige feil.

funcwriteToDotEnv(){
 env, _ := godotenv. Unmarshal("KEY=verdi")
 feil := godotenv. Skriv (env, ".env")
hvis feil!= null {
 Logg. Println("Det oppsto en feil ved skriving til dotenv-filen")
}
}

De godotenv pakken unmarshals nøkkel-verdi-paret strengen med Unmarshal metoden, og env variabel blir et kart over streng til strengtype.

De writeToDotEnv funksjonen skriver kartets innhold til .env filen i arbeidskatalogen. Denne operasjonen overskriver eksisterende data.

Miljøvariabler kommer alltid til nytte

Miljøvariabler gjør det enkelt å stille inn og endre applikasjonens utførelsesparametere uten å endre kode eller konfigurasjoner, og dermed øke portabiliteten til applikasjonen din.

Du kan ha flere miljøvariabler og dotenv filer for forskjellige scenarier for å teste hvordan applikasjonen din kjører under forskjellige parametere eller forhold.