Som ett programmeringsspråk har Go ett brett utbud av inbyggda funktioner, inklusive möjligheten att skapa, läsa och skriva filer som textfiler (.txt).

Filer är viktiga komponenter i vårt dagliga liv i den moderna världen. Textfiler är användbara för att lagra strukturerad, läsbar data utan användning av extern programvara eller databaser.

Om du undrar hur du kan börja manipulera textfiler i Go är den här artikeln rätt plats för dig.

Bufio-paketet i Go

De bufio paket, som är en del av Gos standardbibliotek, används för buffrade in- och utdataoperationer, därav namnet. De bufio paketet bygger på io. Läsare och io. Författare gränssnitt, som används flitigt i implementeringen av majoriteten av Gos standardpaket.

De bufio paketet går ett steg längre genom att implementera buffring, vilket gör det användbart för IO-operationer som involverar textdata.

Att använda bufio paket i ditt program, bör du importera det tillsammans med andra paket.

importera (
"fmt"
"bufio"
)

Du hörde säkert när du kom igång med Go

instagram viewer
att den kommer med allt du kan tänkas behöva som programmerare. För direkt kommunikation med ditt operativsystem finns ett paket som heter os som ger plattformsoberoende funktioner.

De os och bufio paket gör textfilmanipulering otroligt enkel.

Även om den stora majoriteten av os paketets funktioner är Unix-liknande, de använder alla Go-stilen för felhantering, vilket gör det enkelt att läsa felmeddelanden och felsöka kod.

Så, hur manipulerar du filer som innehåller text i Go?

Hur man läser data från en textfil

För att läsa data från textfiler måste du ringa till os paketets Öppen() funktion, som accepterar namnet på filen som ska läsas som en parameter. En annan metod för att få filen är att använda Öppna fil() fungera.

Den stora skillnaden mellan Öppen() och Öppna fil() är i deras genomförande. Öppen() öppnar en fil i skrivskyddat läge (med O_RDONLY flagga), medan Öppna fil() ger mer flexibilitet genom att acceptera tre parametrar nämligen:

  • Filnamn
  • Filöppningsläge: De giltiga filöppningslägena visas i tabellen nedan.
    Flagga Menande
    O_RDONLY Öppnar filen i skrivskyddat läge
    O_FULLT Öppnar filen i skrivskyddat läge
    O_RDWR Öppnar filen i läs-skrivläge
    O_APPEND Lägger till data till filen när du skriver
    O_SKAPA Skapar en ny fil om ingen finns
    O_EXCL Används med O_CREATE, för att indikera att filen bara ska skapas om den inte finns
    O_SYNC Öppnar fil för synkron I/O
    O_TRUNC Trunkera filen på öppen, om möjligt
  • Filbehörigheter: Samma som filbehörighetsbitar i Linux används för att ange regler för filåtkomst, t.ex. 0777 för att ge läs-, skriv- och exekveringsbehörigheter till alla användartyper.

Koden nedan visar hur man läser data från en textfil i Go med hjälp av os. Öppen(), och Skanna() som i detta fall löper i en Gå för loop.

paket huvud
importera (
"bufio"
"fmt"
"logga"
"os"
)
/**
 INNEHÅLL I DEN "testfile.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 huvud(){
 fil, fel := os. Öppen("testfile.txt")
// en annan metod som använder os. Öppna fil()
 // fil, err = os. Öppna fil("testfile.txt", os. O_RDONLY, 0644)
 om fel != noll {
logga.Dödlig(fela)
 }
uppskjutafil.Stänga()
 fmt. Println("Filen öppnades. Läser nu filinnehållet rad för rad:")
 // skapa scanner från de filtillläsatextfrån
 scanner := bufio. NewScanner (fil)
// skanna eller läs byte av text rad för rad
förscanner.Skanna() {
fmt.Skriv ut(scanner.Text())
 }
 om fel := skanner. Fela(); fel != noll {
logga.Dödlig(fela)
 }
}

När du kör koden ovan med kör filnamn.go, producerar den utdata som visas nedan:

Om du anger bara filnamnet och inte sökvägen till Öppen() eller Öppna fil() funktion för läsoperationer, Go antar att filen finns i den aktuella katalogen och returnerar ett felmeddelande om den inte hittar den. Du bör skicka in sökvägen till filen om du behöver arbeta med filer utanför den aktuella katalogen.

Hur man skriver data till en textfil

De bufio paketet tillhandahåller en buffrad Författare gränssnitt som lagrar bytes med data och skriver dem till en fil med hjälp av en Spola() fungera.

Nästa exempelkod är en fortsättning på den för att läsa en fil. I det här exemplet skrivs data till det befintliga testfile.txt använda O_FULLT och O_APPEND flaggor.

Lägg till följande kodrader i programmet ovan, före den avslutande krulliga klammern av main() fungera:

// skriv utdata till fil
fil, err = os. OpenFile("testfile.txt", os. O_APPEND|os. O_FOLKT, 0644)
om fel!= noll {
 logga. Dödlig (fel)
}
uppskjuta fil. Stänga()
fmt. Println("Fil öppnades framgångsrikt, förbereder nu för att skriva data till fil...")
// skapa buffrat Writer-objekt för att skriva data till fil
textWriter := bufio. NewWriter (fil)
// skriv sträng till buffert innan du sparar filen.
_, err = textWriter. WriteString("-Detta är en ny text har lagts till i filen.")
om fel!= noll {
 logga. Dödlig (fel)
}
textWriter. Spola()
fmt. Println("Data skrivs till filen framgångsrikt...")

Utdata från ditt kompletta program bör se ut så här:

När du öppnar testfile.txt fil, kommer du också att se den nya raden i slutet av filen precis som bilden nedan:

Filhantering i Go är lätt

Med Go kan du arbeta med en mängd olika filer, inte bara textfiler. Det finns många ytterligare inbyggda bibliotek och funktioner för att arbeta med olika typer av data från filer, inklusive JSON och CSV.

För att se hur de beter sig olika beroende på situationen kan du experimentera med de olika flaggorna och filbehörigheterna som är tillgängliga för användning med Öppna fil().