Leggi il file
Avrai le competenze fondamentali per leggere i contenuti del file utilizzando il linguaggio di programmazione Go entro la fine di questo articolo.
Apri il file per la lettura
Il primo metodo quando si leggono qualsiasi file lo sta aprendo. Per aprire un file in GO, possiamo utilizzare i metodi Open () o OpenFile () dal pacchetto OS.
Per semplicità, ci atterremo al metodo Open ().
Il codice seguente mostra la sintassi per l'apertura di un file utilizzando il pacchetto OS:
File, err: = OS.Open ("FileName")
Ad esempio, per aprire un file chiamato "Ciao.txt "nella directory di lavoro attuale, possiamo fare:
File, err: = OS.Aperto ("Ciao.TXT")
È anche bene chiudere il file dopo aver completato le operazioni richieste. Possiamo chiudere il file usando il metodo chiuso come:
DEFER FILE.Vicino()
Assicurati che qualsiasi operazione eseguita sul file si trovi con il metodo Open () e Close ().
Golang ha letto il file.
Possiamo usare vari metodi e tecniche per leggere un file in Go. Discutiamo di alcuni comuni ed efficienti.
Leggi l'intero file.
Il metodo più comune e semplicistico per leggere i file è utilizzare il metodo ReadFile dal pacchetto IoUtil. Questo metodo leggerà l'intero file e lo memorizzerà come una stringa di grandi dimensioni.
Nonostante la sua natura semplicistica, questo metodo non è molto efficiente quando si tratta di lavorare con file di grandi dimensioni.
Usiamo un esempio per illustrare il lavoro con il metodo ReadFile ().
Inizia creando un file chiamato "Ciao.txt "nella tua attuale directory di lavoro.
$ touch ciao.TXT
Quindi, modifica il file con il tuo editor di testo e aggiungi quanto segue:
$ vim ciao.TXT
> Ciao da ciao.TXT
Chiudi e salva il file.
Ora possiamo usare il metodo ReadFile () per leggere il contenuto dell'intero file come:
Pacchetto principale
importazione (
"FMT"
"Io/IoUtil"
"tronco d'albero"
)
func main ()
Dati, err: = Ioutil.ReadFile ("Ciao.TXT")
Se err != nil
tronco d'albero.Fatale (err)
fmt.Println (string (dati))
Il programma sopra leggerà il file e stampa il suo contenuto sulla console. Si noti che dobbiamo convertire i dati in una stringa prima di stamparli. Altrimenti, otterrai una fetta di personaggi.
Leggi il file di blocchi
Un altro modo per leggere un file in go è leggerlo in blocchi. Ciò significa che non cariciamo l'intero contenuto in memoria ma invece tagliano piccole sezioni.
Questa può essere un'ottima tecnica quando si lavora con file di grandi dimensioni.
Per esempio:
Pacchetto principale
importazione (
"Bufio"
"FMT"
"io"
"tronco d'albero"
"OS"
)
func main ()
File, err: = OS.Aperto ("Ciao.TXT")
Se err != nil
tronco d'albero.Fatale (err)
DEFER FILE.Vicino()
lettore: = bufio.NewReader (file)
buffer: = make ([] byte, 8)
per
Leggi, err: = lettore.Leggi (buffer)
Se err != nil
Se err != io.Eof
tronco d'albero.Fatale (err)
rottura
fmt.Println (string (buffer [: leggi]))
Nell'esempio sopra, leggiamo il file in blocchi di 8 byte. Leggiamo i dati nel buffer utilizzando il metodo di lettura usando un loop. Infine, stampiamo il buffer dell'array usando il metodo println ().
I blocchi risultanti di lettura dei dati sono come mostrato:
$ vai a correre
Ciao fr
om the h
Ello.TXT
file
Leggi la riga del file per riga
Possiamo anche leggere file riga per riga utilizzando il pacchetto Bufio. Un esempio è come mostrato di seguito:
Pacchetto principale
importazione (
"Bufio"
"FMT"
"tronco d'albero"
"OS"
)
func main ()
File, err: = OS.Aperto ("Ciao.TXT")
Se err != nil
tronco d'albero.Fatale (err)
DEFER FILE.Vicino()
scanner: = bufio.NewsCanner (file)
per scanner.Scansione()
fmt.Println (scanner.Testo())
se err: = scanner.Err (); err != nil
tronco d'albero.Fatale (err)
Lo scanner scansionerà la riga e stampa una nuova riga ogni volta che incontra il carattere \ n.
Leggi Word File per parola
Possiamo anche usare il metodo scanword dal pacchetto bufio per leggere il file word by word. Un codice di esempio è come mostrato:
Pacchetto principale
importazione (
"Bufio"
"FMT"
"tronco d'albero"
"OS"
)
func main ()
File, err: = OS.Aperto ("Ciao.TXT")
Se err != nil
tronco d'albero.Fatale (err)
DEFER FILE.Vicino()
scanner: = bufio.NewsCanner (file)
scanner.Diviso (bufio.Scanwords)
per scanner.Scansione()
fmt.Println (scanner.Testo())
se err: = scanner.Err (); err != nil
tronco d'albero.Fatale (err)
Nell'esempio sopra, scansioniamo il file word per parola usando le parole scantane fornite dal pacchetto bufio.
L'output risultante è come:
Ciao
da
IL
Ciao.TXT
file
Conclusione
Questa guida discute metodi e tecniche comuni per leggere i file nel linguaggio di programmazione Go.
Continua a codificare!!