Respostas:
NOTA: A resposta aceita estava correta nas versões anteriores do Go. Veja a resposta mais votada contém a maneira idiomática mais recente de conseguir isso.
Existe a função ReadLine no pacote bufio
.
Observe que, se a linha não couber no buffer de leitura, a função retornará uma linha incompleta. Se você sempre quiser ler uma linha inteira no seu programa com uma única chamada para uma função, precisará encapsular a ReadLine
função na sua própria função, que chama ReadLine
em um loop for.
bufio.ReadString('\n')
não é totalmente equivalente a, ReadLine
porque ReadString
é incapaz de lidar com o caso em que a última linha de um arquivo não termina com o caractere de nova linha.
No Go 1.1 e mais recente, a maneira mais simples de fazer isso é com um bufio.Scanner
. Aqui está um exemplo simples que lê linhas de um arquivo:
package main
import (
"bufio"
"fmt"
"log"
"os"
)
func main() {
file, err := os.Open("/path/to/file.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
if err := scanner.Err(); err != nil {
log.Fatal(err)
}
}
Essa é a maneira mais limpa de ler uma Reader
linha por linha.
Há uma ressalva: o scanner não lida bem com linhas com mais de 65536 caracteres. Se isso é um problema para você, então você provavelmente deve rolar por conta própria Reader.Read()
.
file, _ := os.Open("/path/to/file.csv")
e depois digitalizar sobre o identificador de arquivo:scanner := bufio.NewScanner(file)
defer file.Close()
.
bufio.ErrTooLong
erro, ou seja, bufio.Scanner: token too long
se a linha for muito longa. Nesse caso, você precisará usar bufio.ReaderLine () ou ReadString ().
Usar:
reader.ReadString('\n')
\n
final da string retornado.reader.ReadLine()
Testei as várias soluções sugeridas escrevendo um programa para testar os cenários identificados como problemas em outras respostas:
Eu achei aquilo:
Scanner
solução não lida com longas filas.ReadLine
solução é complexa de implementar.ReadString
solução é a mais simples e funciona para longas filas.Aqui está o código que demonstra cada solução, que pode ser executado via go run main.go
:
package main
import (
"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 string
for {
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.Buffer
var l []byte
var isPrefix bool
for {
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, break
if 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]
}
Eu testei em:
O programa de teste gera:
Long lines
readFileWithReadString
> Read 4194305 characters
> > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
> Read 12 characters
> > Second line.
readFileWithScanner - this will fail!
> Failed!: bufio.Scanner: token too long
readFileWithReadLine
> Read 4194304 characters
> > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
> Read 12 characters
> > Second line.
No linebreak
readFileWithReadString
> Read 28 characters
> > Does not end with linebreak.
readFileWithScanner - this will fail!
> Read 28 characters
> > Does not end with linebreak.
readFileWithReadLine
> Read 28 characters
> > Does not end with linebreak.
defer file.Close()
deve ser após a verificação de erro; caso contrário, por erro, entrará em pânico.
Eu escrevi uma maneira de ler facilmente cada linha de um arquivo. A função Readln (* bufio.Reader) retorna uma linha (sans \ n) da estrutura subjacente do 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...)
}
return string(ln),err
}
Você pode usar o Readln para ler todas as linhas de um arquivo. O código a seguir lê todas as linhas de um arquivo e gera cada linha no stdout.
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)
}
Felicidades!
Existem duas maneiras comuns de ler o arquivo linha por linha.
No meu caso de teste, ~ 250MB, ~ 2.500.000 linhas , o bufio.Scanner (tempo usado: 0.395491384s) é mais rápido que o bufio.Reader.ReadString (time_used: 0.446867622s).
Código fonte: https://github.com/xpzouying/go-practice/tree/master/read_file_line_by_line
Leia o arquivo usando bufio.Scanner,
func scanFile() {
f, err := os.OpenFile(logfile, os.O_RDONLY, os.ModePerm)
if err != nil {
log.Fatalf("open file error: %v", err)
return
}
defer f.Close()
sc := bufio.NewScanner(f)
for sc.Scan() {
_ = sc.Text() // GET the line string
}
if err := sc.Err(); err != nil {
log.Fatalf("scan file error: %v", err)
return
}
}
Leia o arquivo usando bufio.Reader,
func readFileLines() {
f, err := os.OpenFile(logfile, os.O_RDONLY, os.ModePerm)
if err != nil {
log.Fatalf("open file error: %v", err)
return
}
defer f.Close()
rd := bufio.NewReader(f)
for {
line, err := rd.ReadString('\n')
if err != nil {
if err == io.EOF {
break
}
log.Fatalf("read file line error: %v", err)
return
}
_ = line // GET the line string
}
}
bufio.Reader
exemplo não lerá a última linha de um arquivo se não terminar com uma nova linha. ReadString
retornará a última linha e io.EOF
, neste caso.
Exemplo desta essência
func readLine(path string) {
inFile, err := os.Open(path)
if err != nil {
fmt.Println(err.Error() + `: ` + path)
return
}
defer inFile.Close()
scanner := bufio.NewScanner(inFile)
for scanner.Scan() {
fmt.Println(scanner.Text()) // the line
}
}
mas isso gera um erro quando há uma linha maior que o buffer do scanner.
Quando isso aconteceu, o que faço é reader := bufio.NewReader(inFile)
criar e concatenar meu próprio buffer, usando ch, err := reader.ReadByte()
oulen, err := reader.Read(myBuffer)
Outra maneira que eu uso (substitua os.Stdin pelo arquivo como acima), este concata quando as linhas são longas (isPrefix) e ignora as linhas vazias:
func readLines() []string {
r := bufio.NewReader(os.Stdin)
bytes := []byte{}
lines := []string{}
for {
line, isPrefix, err := r.ReadLine()
if err != nil {
break
}
bytes = append(bytes, line...)
if !isPrefix {
str := strings.TrimSpace(string(bytes))
if len(str) > 0 {
lines = append(lines, str)
bytes = []byte{}
}
}
}
if len(bytes) > 0 {
lines = append(lines, string(bytes))
}
return lines
}
-1
?
Você também pode usar o ReadString com \ n como um separador:
f, err := os.Open(filename)
if err != nil {
fmt.Println("error opening file ", err)
os.Exit(1)
}
defer f.Close()
r := bufio.NewReader(f)
for {
path, err := r.ReadString(10) // 0x0A separator = newline
if err == io.EOF {
// do something here
break
} else if err != nil {
return err // if you return error
}
}
bufio.Reader.ReadLine () funciona bem. Mas se você quiser ler cada linha por uma string, tente usar ReadString ('\ n') . Não precisa reinventar a roda.
// 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
}
No código abaixo, leio os interesses da CLI até que o usuário aperte enter e estou usando o Readline:
interests := make([]string, 1)
r := bufio.NewReader(os.Stdin)
for true {
fmt.Print("Give me an interest:")
t, _, _ := r.ReadLine()
interests = append(interests, string(t))
if len(t) == 0 {
break;
}
}
fmt.Println(interests)
Gosto da solução Lzap, sou novo no Go, gostaria de pedir para o lzap, mas não consegui fazê-lo ainda não tenho 50 pontos .. Troco um pouco a sua solução e complete o código ...
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
}
}
Não sei por que preciso testar 'err' novamente, mas de qualquer maneira podemos fazê-lo. Mas, a questão principal é .. por que o Go não produz erros com a frase => line, err: = r.ReadString (10), dentro do loop? É definido repetidamente toda vez que o loop é executado. Evito essa situação com a minha mudança, algum comentário? Defino a condição EOF em 'for' como semelhante a um While também. obrigado
import (
"bufio"
"os"
)
var (
reader = bufio.NewReader(os.Stdin)
)
func ReadFromStdin() string{
result, _ := reader.ReadString('\n')
witl := result[:len(result)-1]
return witl
}
Aqui está um exemplo com a função ReadFromStdin()
que é como, fmt.Scan(&name)
mas recebe todas as strings com espaços em branco como: "Olá, meu nome é ..."
var name string = ReadFromStdin()
println(name)
Outro método é usar as bibliotecas io/ioutil
e strings
para ler os bytes do arquivo inteiro, convertê-los em uma sequência e dividi-los usando um caractere " \n
" (nova linha) como delimitador, por exemplo:
import (
"io/ioutil"
"strings"
)
func main() {
bytesRead, _ := ioutil.ReadFile("something.txt")
file_content := string(bytesRead)
lines := strings.Split(file_content, "\n")
}
Tecnicamente, você não está lendo o arquivo linha por linha, mas é possível analisar cada linha usando essa técnica. Este método é aplicável a arquivos menores. Se você estiver tentando analisar um arquivo enorme, use uma das técnicas que lê linha por linha.