Som programmeringssprog har Go en lang række indbyggede funktioner, herunder muligheden for at oprette, læse og skrive filer som tekstfiler (.txt).

Filer er vigtige komponenter i vores daglige liv i den moderne verden. Tekstfiler er nyttige til lagring af strukturerede menneskelæselige data uden brug af ekstern software eller databaser.

Hvis du undrer dig over, hvordan du kan begynde at manipulere tekstfiler i Go, er denne artikel det rigtige sted for dig.

Bufio-pakken i Go

Det bufio pakke, som er en del af Go's standardbibliotek, bruges til bufferede input og output operationer, deraf navnet. Det bufio pakken bygger på io. Læser og io. Forfatter grænseflader, som er flittigt brugt i implementeringen af ​​størstedelen af ​​Go’s standardpakker.

Det bufio pakken går et skridt videre ved at implementere buffering, hvilket gør den nyttig til IO-operationer, der involverer tekstdata.

For at bruge bufio pakke i dit program, bør du importere den sammen med andre pakker.

importere (
"fmt"
"bufio"
)

Du har sikkert hørt, når du

instagram viewer
kom i gang med Go at den kommer med alt, hvad du kan få brug for som programmør. Til direkte kommunikation med dit operativsystem er der en pakke kaldet os der giver platform-uafhængige funktioner.

Det os og bufio pakker gør tekstfilmanipulation utrolig enkel.

Selvom langt størstedelen af ​​de os pakkens funktioner er Unix-lignende, de anvender alle Go-stilen til fejlhåndtering, hvilket gør det nemt at læse fejlmeddelelser og fejlfindingskode.

Så hvordan manipulerer du filer, der indeholder tekst i Go?

Sådan læser du data fra en tekstfil

For at læse data fra tekstfiler skal du ringe til os pakkens Åben() funktion, som accepterer navnet på filen, der skal læses, som en parameter. En anden metode til at hente filen er ved at bruge Åben fil() fungere.

Den største forskel mellem Åben() og Åben fil() er i deres implementering. Åben() åbner en fil i skrivebeskyttet tilstand (med O_RDONLY flag), mens Åben fil() giver mere fleksibilitet ved at acceptere tre parametre, nemlig:

  • Filnavn
  • Filåbningstilstand: De gyldige filåbningstilstande er vist i tabellen nedenfor.
    Flag Betyder
    O_RDONLY Åbner filen i skrivebeskyttet tilstand
    O_FORREKT Åbner filen i skrivebeskyttet tilstand
    O_RDWR Åbner filen i læse-skrivetilstand
    O_APPEND Føjer data til filen under skrivning
    O_CREATE Opretter en ny fil, hvis der ikke findes nogen
    O_EXCL Brugt med O_CREATE, for at angive, at filen kun skal oprettes, hvis den ikke eksisterer
    O_SYNC Åbner fil til synkron I/O
    O_TRUNC Afkort filen på åben, hvis det er muligt
  • Filtilladelser: Samme som filtilladelsesbits i Linux bruges til at specificere filadgangsregler, f.eks. 0777 til at give læse-, skrive- og eksekveringstilladelser til alle brugertyper.

Koden nedenfor viser, hvordan man læser data fra en tekstfil i Go vha os. Åben(), og Scan() som i dette tilfælde løber i en Gå til loop.

pakke vigtigste
importere (
"bufio"
"fmt"
"log"
"os"
)
/**
 INDHOLD AF "testfil.txt" fil.
 lorem ipsum dolor sit amet
 LOREM IPSUM DOLOR SIT AMET
 Lorem ipsum dolor sit amet
 Lorem Ipsum Dolor Sit Amet
 LOREM iPSUM DOLOR SIT AMET
 LoReM IPSUM DoLoR SiT AmEt
*/
func vigtigste(){
 fil, fejl := os. Åben("testfil.txt")
// en anden metode, der bruger os. Åben fil()
 // fil, err = os. Åben fil("testfil.txt", os. O_RDONLY, 0644)
 hvis fejl != nul {
log.Fatal(fejl)
 }
udsættefil.Tæt()
 fmt. Println("Filen blev åbnet. Læser nu filindholdet linje for linje:")
 // skab scanner fra det filtilLæstekstfra
 scanner := bufio. NewScanner (fil)
// scan eller læs tekstens bytes linje for linje
tilscanner.Scan() {
fmt.Println(scanner.Tekst())
 }
 hvis fejl := scanner. Err(); fejl != nul {
log.Fatal(fejl)
 }
}

Når du kører koden ovenfor med kør filnavn.go, producerer det output vist nedenfor:

Hvis du kun indtaster filnavnet og ikke stien til Åben() eller Åben fil() funktion til læseoperationer, Go antager, at filen er i den nuværende mappe og returnerer en fejl, hvis den ikke finder den. Du skal sende stien til filen, hvis du skal arbejde med filer uden for den aktuelle mappe.

Sådan skriver du data til en tekstfil

Det bufio pakke giver en bufferet Forfatter grænseflade, der gemmer bytes af data og skriver dem til en fil ved hjælp af en Flush() fungere.

Den næste eksempelkode er en fortsættelse af den, der skal læse en fil. I dette eksempel skrives data til det eksisterende testfil.txt bruger O_FORREKT og O_APPEND flag.

Tilføj følgende kodelinjer til programmet ovenfor, før den afsluttende krøllede bøjle på hoved() fungere:

// skriv outputdata til fil
fil, err = os. OpenFile("testfil.txt", os. O_APPEND|os. O_FORREKT, 0644)
hvis fejl!= nul {
 log. Fatal (fejl)
}
udsætte fil. Tæt()
fmt. Println("Filen blev åbnet, forbereder nu at skrive data til filen...")
// oprette bufferet Writer-objekt for at skrive data til fil
textWriter := bufio. NewWriter (fil)
// skriv streng til buffer, før du gemmer filen.
_, fejl = tekstskriver. WriteString("-Dette er en ny tekst tilføjet til filen.")
hvis fejl!= nul {
 log. Fatal (fejl)
}
tekstforfatter. Flush()
fmt. Println("Data skrevet til fil med succes...")

Outputtet af dit komplette program skulle se sådan ud:

Når du åbner testfil.txt fil, vil du også se den nye linje tilføjet i slutningen af ​​filen ligesom billedet nedenfor:

Filhåndtering i Go er nemt

Go giver dig mulighed for at arbejde med en række forskellige filer, ikke kun tekstfiler. Der er adskillige yderligere indbyggede biblioteker og funktioner til at arbejde med forskellige typer data fra filer, inklusive JSON og CSV.

For at se, hvordan de opfører sig forskelligt afhængigt af situationen, kan du eksperimentere med de forskellige flag og filtilladelser, der er tilgængelige til brug med Åben fil().