How to improve this file reading code

I currently have this piece of code that will read a file line by line (delimited by a \n)

file, _ := os.Open(filename) //deal with the error later
defer file.Close()

buf := bufio.NewReader(file)
for line, err := buf.ReadString('\n'); err != io.EOF; line, err = buf.ReadString('\n')
{
    fmt.Println(strings.TrimRight(line, "\n"))
}

However I don't feel comfortable with writing buf.ReadString("\n") twice in the for loop, does anyone have any suggestions for improvement?

> bufio.ReadString reads until the first occurrence of delim in the input,
> returning a string containing the data up to and including the
> delimiter. If ReadString encounters an error before finding a
> delimiter, it returns the data read before the error and the error
> itself (often io.EOF). ReadString returns err != nil if and only if
> the returned data does not end in delim.

If buf.ReadString('\n') returns an error other than io.EOF, for example bufio.ErrBufferFull, you will be in an infinite loop. Also, if the file doesn't end in a '\n', you silently ignore the data after the last '\n'.

Here's a more robust solution, which executes buf.ReadString('\n') once.

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strings"
)

func main() {
	filename := "FileName"
	file, err := os.Open(filename)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()
	buf := bufio.NewReader(file)
	for {
		line, err := buf.ReadString('\n')
		if err != nil {
			if err != io.EOF || len(line) > 0 {
				fmt.Println(err)
				return
			}
			break
		}
		fmt.Println(strings.TrimRight(line, "\n"))
	}
}

Most code that reads line by line can be improved by not reading line by line. If your goal is to read the file and access the lines, something like the following is almost always better.

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)

func main() {
    b, err := ioutil.ReadFile("filename")
    if err != nil {
        log.Fatal(err)
    }
    s := string(b)                 // convert []byte to string
    s = strings.TrimRight(s, "\n") // strip \n on last line
    ss := strings.Split(s, "\n")   // split to []string
    for _, s := range ss {
        fmt.Println(s)
    }
}

Any errors come to you at a single point so error handling is simplified. Stripping a newline off the last line allows for files that may or may not have that final newline, as Peter suggested. Most text files are tiny compared to available memory these days, so reading these in one gulp is appropriate.