Nie mogę znaleźć file.ReadLinefunkcji w Go. Potrafię wymyślić, jak szybko napisać jeden, ale zastanawiam się, czy coś tutaj przeoczyłem. Jak czytać plik linia po linii?
Począwszy od wersji Go1.1 najlepszym sposobem na to jest bufio.Scanner.
Malcolm,
Odpowiedzi:
133
UWAGA: Akceptowana odpowiedź była poprawna we wczesnych wersjach Go. Zobacz najwyżej głosowaną odpowiedź zawiera najnowszy idiomatyczny sposób na osiągnięcie tego.
Pamiętaj, że jeśli linia nie mieści się w buforze odczytu, funkcja zwróci niekompletną linię. Jeśli chcesz zawsze czytać całą linię w programie za pomocą pojedynczego wywołania funkcji, musisz obudować ReadLinefunkcję we własnej funkcji, która wywołuje ReadLinepętlę for.
bufio.ReadString('\n')nie jest w pełni równoważne, ReadLineponieważ ReadStringnie jest w stanie obsłużyć przypadku, gdy ostatni wiersz pliku nie kończy się znakiem nowej linii.
Z dokumentacji: „ReadLine to podstawowy prymitywny odczyt linii. Większość osób dzwoniących powinna zamiast tego używać ReadBytes ('\ n') lub ReadString ('\ n') lub skanera.”
mdwhatcott,
12
@mdwhatcott, dlaczego ma to znaczenie, że jest to „prymitywne czytanie linii niskiego poziomu”? Jak dochodzi do wniosku, że „Większość dzwoniących powinna zamiast tego używać ReadBytes ('\ n') lub ReadString ('\ n') lub skanera.”?
Charlie Parker,
12
@CharlieParker - Nie jestem pewien, cytuję dokumenty, aby dodać kontekst.
mdwhatcott,
11
Z tych samych dokumentów .. „Jeśli ReadString napotka błąd przed znalezieniem separatora, zwraca dane odczytane przed błędem i sam błąd (często io.EOF).” Możesz więc po prostu sprawdzić, czy nie wystąpił błąd io.EOF i wiedzieć, że gotowe.
eduncan911
1
Należy pamiętać, że odczyt lub zapis może się nie powieść z powodu przerwanego wywołania systemowego, w wyniku czego odczyt lub zapis jest mniejszy niż oczekiwana liczba bajtów.
Justin Swanhart
598
W Go 1.1 i nowszych najprostszym sposobem na to jest użycie bufio.Scanner. Oto prosty przykład, który odczytuje wiersze z pliku:
Jest to najczystszy sposób czytania z Readerlinii po linii.
Jest jedno zastrzeżenie: skaner nie radzi sobie dobrze z liniami dłuższymi niż 65536 znaków. Jeśli jest to dla ciebie problem, prawdopodobnie powinieneś rzucić swój własny na Reader.Read().
A ponieważ OP poprosił o zeskanowanie pliku, najpierw byłoby trywialne, file, _ := os.Open("/path/to/file.csv")a następnie zeskanować uchwyt pliku:scanner := bufio.NewScanner(file)
Evan Plumlee
14
Nie zapomnij defer file.Close().
Kiril,
13
Problem polega na tym, że Scanner.Scan () ma rozmiar bufora 4096 [] bajtów na linię. Otrzymasz bufio.ErrTooLongbłąd, to znaczy, bufio.Scanner: token too longjeśli linia jest za długa. W takim przypadku będziesz musiał użyć bufio.ReaderLine () lub ReadString ().
eduncan911,
5
Tylko moje 0,02 $ - to jest najbardziej poprawna odpowiedź na stronie :)
Jeśli nie masz nic przeciwko temu, że linia może być bardzo długa (tj. Użyj dużo pamięci RAM). Zachowuje \nzwrócony koniec łańcucha.
reader.ReadLine()
Jeśli zależy Ci na ograniczeniu zużycia pamięci RAM i nie przeszkadza ci dodatkowa praca związana ze sprawą, w której linia jest większa niż rozmiar bufora czytnika.
Przetestowałem różne rozwiązania sugerowane przez napisanie programu do testowania scenariuszy, które zostały zidentyfikowane jako problemy w innych odpowiedziach:
Plik z linią 4 MB.
Plik, który nie kończy się podziałem linii.
Znalazłem to:
ScannerRozwiązanie nie obsługuje długie linie.
ReadLineRozwiązanie jest trudne do wykonania.
ReadStringRozwiązanie jest najprostszym i pracuje dla długich kolejkach.
Oto kod demonstrujący każde rozwiązanie, które można uruchomić za pomocą go run main.go:
package mainimport("bufio""bytes""fmt""io""os")
func readFileWithReadString(fn string)(err error){
fmt.Println("readFileWithReadString")
file, err := os.Open(fn)
defer file.Close()if err !=nil{return err}// Start reading from the file with a reader.
reader := bufio.NewReader(file)var line stringfor{
line, err = reader.ReadString('\n')
fmt.Printf(" > Read %d characters\n", len(line))// Process the line here.
fmt.Println(" > > "+ limitLength(line,50))if err !=nil{break}}if err != io.EOF {
fmt.Printf(" > Failed!: %v\n", err)}return}
func readFileWithScanner(fn string)(err error){
fmt.Println("readFileWithScanner - this will fail!")// Don't use this, it doesn't work with long lines...
file, err := os.Open(fn)
defer file.Close()if err !=nil{return err}// Start reading from the file using a scanner.
scanner := bufio.NewScanner(file)for scanner.Scan(){
line := scanner.Text()
fmt.Printf(" > Read %d characters\n", len(line))// Process the line here.
fmt.Println(" > > "+ limitLength(line,50))}if scanner.Err()!=nil{
fmt.Printf(" > Failed!: %v\n", scanner.Err())}return}
func readFileWithReadLine(fn string)(err error){
fmt.Println("readFileWithReadLine")
file, err := os.Open(fn)
defer file.Close()if err !=nil{return err}// Start reading from the file with a reader.
reader := bufio.NewReader(file)for{var buffer bytes.Buffervar l []bytevar isPrefix boolfor{
l, isPrefix, err = reader.ReadLine()
buffer.Write(l)// If we've reached the end of the line, stop reading.if!isPrefix {break}// If we're just at the EOF, breakif err !=nil{break}}if err == io.EOF {break}
line := buffer.String()
fmt.Printf(" > Read %d characters\n", len(line))// Process the line here.
fmt.Println(" > > "+ limitLength(line,50))}if err != io.EOF {
fmt.Printf(" > Failed!: %v\n", err)}return}
func main(){
testLongLines()
testLinesThatDoNotFinishWithALinebreak()}
func testLongLines(){
fmt.Println("Long lines")
fmt.Println()
createFileWithLongLine("longline.txt")
readFileWithReadString("longline.txt")
fmt.Println()
readFileWithScanner("longline.txt")
fmt.Println()
readFileWithReadLine("longline.txt")
fmt.Println()}
func testLinesThatDoNotFinishWithALinebreak(){
fmt.Println("No linebreak")
fmt.Println()
createFileThatDoesNotEndWithALineBreak("nolinebreak.txt")
readFileWithReadString("nolinebreak.txt")
fmt.Println()
readFileWithScanner("nolinebreak.txt")
fmt.Println()
readFileWithReadLine("nolinebreak.txt")
fmt.Println()}
func createFileThatDoesNotEndWithALineBreak(fn string)(err error){
file, err := os.Create(fn)
defer file.Close()if err !=nil{return err}
w := bufio.NewWriter(file)
w.WriteString("Does not end with linebreak.")
w.Flush()return}
func createFileWithLongLine(fn string)(err error){
file, err := os.Create(fn)
defer file.Close()if err !=nil{return err}
w := bufio.NewWriter(file)
fs :=1024*1024*4// 4MB// Create a 4MB long line consisting of the letter a.for i :=0; i < fs; i++{
w.WriteRune('a')}// Terminate the line with a break.
w.WriteRune('\n')// Put in a second line, which doesn't have a linebreak.
w.WriteString("Second line.")
w.Flush()return}
func limitLength(s string, length int)string{if len(s)< length {return s}return s[:length]}
Testowałem na:
wersja go go.7.7 windows / amd64
wersja go go1.6.3 linux / amd64
wersja go go1.7.4 darwin / amd64
Program testowy generuje:
Long lines
readFileWithReadString>Read4194305 characters>> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>Read12 characters>>Second line.
readFileWithScanner -this will fail!>Failed!: bufio.Scanner: token too long
readFileWithReadLine>Read4194304 characters>> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>Read12 characters>>Second line.No linebreak
readFileWithReadString>Read28 characters>>Doesnotendwith linebreak.
readFileWithScanner -this will fail!>Read28 characters>>Doesnotendwith linebreak.
readFileWithReadLine>Read28 characters>>Doesnotendwith linebreak.
Powinieneś dokładnie sprawdzić błąd, jak widać w dokumentach: play.golang.org/p/5CCPzVTSj6, tj. Jeśli err == io.EOF {break} else {return err}
Chuque
53
EDYCJA: W wersji go1.1 rozwiązaniem idiomatycznym jest użycie bufio.Scanner
Napisałem sposób na łatwy odczyt każdej linii z pliku. Funkcja Readln (* bufio.Reader) zwraca wiersz (sans \ n) z bazowej struktury bufio.Reader.
// Readln returns a single line (without the ending \n)// from the input buffered reader.// An error is returned iff there is an error with the// buffered reader.
func Readln(r *bufio.Reader)(string, error){var(isPrefix bool=true
err error =nil
line, ln []byte)for isPrefix && err ==nil{
line, isPrefix, err = r.ReadLine()
ln = append(ln, line...)}returnstring(ln),err}
Możesz użyć Readln do odczytania każdej linii z pliku. Poniższy kod czyta każdy wiersz w pliku i wysyła każdy wiersz na standardowe wyjście.
f, err := os.Open(fi)if err !=nil{
fmt.Printf("error opening file: %v\n",err)
os.Exit(1)}
r := bufio.NewReader(f)
s, e :=Readln(r)for e ==nil{
fmt.Println(s)
s,e =Readln(r)}
Napisałem tę odpowiedź, zanim ukazała się wersja Go 1.1. Go 1.1 ma pakiet skanera w stdlib. który zapewnia taką samą funkcjonalność jak moja odpowiedź. Polecam użycie skanera zamiast mojej odpowiedzi, ponieważ skaner jest w standardzie. Miłego hakowania! :-)
Malcolm,
30
Istnieją dwa popularne sposoby odczytu pliku wiersz po wierszu.
Użyj bufio.Scanner
Użyj ReadString / ReadBytes / ... w bufio.Reader
W moim teście ~ 250 MB, ~ 2 500 000 linii , bufio.Scanner (wykorzystany czas: 0,395491384s) jest szybszy niż bufio.Reader.ReadString (wykorzystany czas: 0,446867622s).
Pamiętaj, że ten bufio.Readerprzykład nie odczyta ostatniego wiersza w pliku, jeśli nie kończy się na nowej linii. ReadStringzwróci zarówno ostatnią linię, jak i io.EOFw tym przypadku.
ale to powoduje błąd, gdy istnieje linia większa niż bufor skanera.
Kiedy tak się stało, używam reader := bufio.NewReader(inFile)tworzenia i łączenia własnego bufora za pomocą ch, err := reader.ReadByte()lublen, err := reader.Read(myBuffer)
Innym sposobem, którego używam (zamień os.Stdin na plik jak wyżej), ten konkatuje, gdy linie są długie (isPrefix) i ignoruje puste linie:
// strip '\n' or read until EOF, return error if read error
func readline(reader io.Reader)(line []byte, err error){
line = make([]byte,0,100)for{
b := make([]byte,1)
n, er := reader.Read(b)if n >0{
c := b[0]if c =='\n'{// end of line break}
line = append(line, c)}if er !=nil{
err = er
return}}return}
Lubię rozwiązanie Lzap, jestem nowy w Go, chciałbym poprosić o lzap, ale nie mogłem tego zrobić Nie mam jeszcze 50 punktów .. Zmieniam trochę twoje rozwiązanie i uzupełniam kod ...
package main
import("bufio""fmt""io""os")
func main(){
f, err := os.Open("archiveName")if err !=nil{
fmt.Println(err)
os.Exit(1)}
defer f.Close()
r := bufio.NewReader(f)
line, err := r.ReadString(10)// line defined once for err != io.EOF {
fmt.Print(line)// or any stuff
line, err = r.ReadString(10)// line was defined before}}
Nie jestem pewien, dlaczego muszę ponownie przetestować „błąd”, ale w każdym razie możemy to zrobić. Ale głównym pytaniem jest ... dlaczego Go nie powoduje błędu w zdaniu => wiersz, err: = r.ReadString (10), wewnątrz pętli? Jest definiowany wielokrotnie za każdym razem, gdy pętla jest wykonywana. Unikam tej sytuacji wraz z moją zmianą, jakiś komentarz? Ustawiłem warunek EOF w „for” jako podobny do Chwila też. Dzięki
Oto przykład z funkcją, ReadFromStdin()która jest podobna, fmt.Scan(&name)ale pobiera wszystkie ciągi znaków z pustymi spacjami, takie jak: „Hello My Name Is ...”
Odpowiedzi:
UWAGA: Akceptowana odpowiedź była poprawna we wczesnych wersjach Go. Zobacz najwyżej głosowaną odpowiedź zawiera najnowszy idiomatyczny sposób na osiągnięcie tego.
W pakiecie znajduje się funkcja ReadLine
bufio
.Pamiętaj, że jeśli linia nie mieści się w buforze odczytu, funkcja zwróci niekompletną linię. Jeśli chcesz zawsze czytać całą linię w programie za pomocą pojedynczego wywołania funkcji, musisz obudować
ReadLine
funkcję we własnej funkcji, która wywołujeReadLine
pętlę for.bufio.ReadString('\n')
nie jest w pełni równoważne,ReadLine
ponieważReadString
nie jest w stanie obsłużyć przypadku, gdy ostatni wiersz pliku nie kończy się znakiem nowej linii.źródło
W Go 1.1 i nowszych najprostszym sposobem na to jest użycie
bufio.Scanner
. Oto prosty przykład, który odczytuje wiersze z pliku:Jest to najczystszy sposób czytania z
Reader
linii po linii.Jest jedno zastrzeżenie: skaner nie radzi sobie dobrze z liniami dłuższymi niż 65536 znaków. Jeśli jest to dla ciebie problem, prawdopodobnie powinieneś rzucić swój własny na
Reader.Read()
.źródło
file, _ := os.Open("/path/to/file.csv")
a następnie zeskanować uchwyt pliku:scanner := bufio.NewScanner(file)
defer file.Close()
.bufio.ErrTooLong
błąd, to znaczy,bufio.Scanner: token too long
jeśli linia jest za długa. W takim przypadku będziesz musiał użyć bufio.ReaderLine () lub ReadString ().Posługiwać się:
reader.ReadString('\n')
\n
zwrócony koniec łańcucha.reader.ReadLine()
Przetestowałem różne rozwiązania sugerowane przez napisanie programu do testowania scenariuszy, które zostały zidentyfikowane jako problemy w innych odpowiedziach:
Znalazłem to:
Scanner
Rozwiązanie nie obsługuje długie linie.ReadLine
Rozwiązanie jest trudne do wykonania.ReadString
Rozwiązanie jest najprostszym i pracuje dla długich kolejkach.Oto kod demonstrujący każde rozwiązanie, które można uruchomić za pomocą
go run main.go
:Testowałem na:
Program testowy generuje:
źródło
defer file.Close()
Powinny być po sprawdzeniu błędów; w przeciwnym razie po błędzie wpadnie w panikę.EDYCJA: W wersji go1.1 rozwiązaniem idiomatycznym jest użycie bufio.Scanner
Napisałem sposób na łatwy odczyt każdej linii z pliku. Funkcja Readln (* bufio.Reader) zwraca wiersz (sans \ n) z bazowej struktury bufio.Reader.
Możesz użyć Readln do odczytania każdej linii z pliku. Poniższy kod czyta każdy wiersz w pliku i wysyła każdy wiersz na standardowe wyjście.
Twoje zdrowie!
źródło
Istnieją dwa popularne sposoby odczytu pliku wiersz po wierszu.
W moim teście ~ 250 MB, ~ 2 500 000 linii , bufio.Scanner (wykorzystany czas: 0,395491384s) jest szybszy niż bufio.Reader.ReadString (wykorzystany czas: 0,446867622s).
Kod źródłowy: https://github.com/xpzouying/go-practice/tree/master/read_file_line_by_line
Czytaj plik użyj bufio.Scanner,
Czytaj plik użyj bufio.Reader,
źródło
bufio.Reader
przykład nie odczyta ostatniego wiersza w pliku, jeśli nie kończy się na nowej linii.ReadString
zwróci zarówno ostatnią linię, jak iio.EOF
w tym przypadku.Przykład z tego GIST
ale to powoduje błąd, gdy istnieje linia większa niż bufor skanera.
Kiedy tak się stało, używam
reader := bufio.NewReader(inFile)
tworzenia i łączenia własnego bufora za pomocąch, err := reader.ReadByte()
lublen, err := reader.Read(myBuffer)
Innym sposobem, którego używam (zamień os.Stdin na plik jak wyżej), ten konkatuje, gdy linie są długie (isPrefix) i ignoruje puste linie:
źródło
-1
?Możesz także użyć ReadString z \ n jako separatorem:
źródło
bufio.Reader.ReadLine () działa dobrze. Ale jeśli chcesz odczytać każdą linię za pomocą ciągu, spróbuj użyć ReadString ('\ n') . Nie trzeba od nowa wymyślać koła.
źródło
źródło
W poniższym kodzie czytam zainteresowania z interfejsu CLI, dopóki użytkownik nie kliknie Enter i korzystam z Readline:
źródło
Lubię rozwiązanie Lzap, jestem nowy w Go, chciałbym poprosić o lzap, ale nie mogłem tego zrobić Nie mam jeszcze 50 punktów .. Zmieniam trochę twoje rozwiązanie i uzupełniam kod ...
Nie jestem pewien, dlaczego muszę ponownie przetestować „błąd”, ale w każdym razie możemy to zrobić. Ale głównym pytaniem jest ... dlaczego Go nie powoduje błędu w zdaniu => wiersz, err: = r.ReadString (10), wewnątrz pętli? Jest definiowany wielokrotnie za każdym razem, gdy pętla jest wykonywana. Unikam tej sytuacji wraz z moją zmianą, jakiś komentarz? Ustawiłem warunek EOF w „for” jako podobny do Chwila też. Dzięki
źródło
Oto przykład z funkcją,
ReadFromStdin()
która jest podobna,fmt.Scan(&name)
ale pobiera wszystkie ciągi znaków z pustymi spacjami, takie jak: „Hello My Name Is ...”źródło