Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/maki-daisuke/go-lines
Makes it a bit easier to read lines from text files in Go
https://github.com/maki-daisuke/go-lines
cui go golang
Last synced: 2 months ago
JSON representation
Makes it a bit easier to read lines from text files in Go
- Host: GitHub
- URL: https://github.com/maki-daisuke/go-lines
- Owner: Maki-Daisuke
- License: bsd-2-clause
- Created: 2015-11-16T07:48:51.000Z (about 9 years ago)
- Default Branch: master
- Last Pushed: 2019-10-11T22:16:08.000Z (over 5 years ago)
- Last Synced: 2024-08-02T01:26:29.191Z (6 months ago)
- Topics: cui, go, golang
- Language: Go
- Size: 4.88 KB
- Stars: 8
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# go-lines
import lines "github.com/Maki-Daisuke/go-lines"
Package lines makes it a bit easier to read lines from text files in Go.
### Description
There are so many ways to read lines in Go! But, I wanted to write less lines of
code as possible. I think life is too short to write lines of code to read
lines.)
For example, you need to write code like the following to read line from STDIN:
```go
import (
"bufio"
"io"
"os"
)
func main(){
r := bufio.NewReader(os.Stdin)
line := ""
for {
l, isPrefix, err := r.ReadLine()
if err == io.EOF {
break
} else if err != nil {
panic(err)
}
line += l
if !isPrefix {
do_something_with(line) // this is what really I want to do.
line = ""
}
}
}
```
With go-lines package, you can write like this:
```go
import (
"os"
. "github.com/Maki-Daisuke/go-lines"
)
func main(){
for line := range Lines(os.Stdin) {
do_something_with(line)
}
}
```
Yay! It's much less lines of code!
Huh? How about error handling? Ok, you are not so lazy. You can use another
function `LinesWithError`:
```go
import (
"os"
. "github.com/Maki-Daisuke/go-lines"
)
func main(){
lines, errs := LinesWithError(os.Stdin)
for line := range lines {
do_something_with(line)
}
err := <-errs
if err != nil {
panic(err)
}
}
```
It's still less lines of code, isn't it?
## Usage
#### func Lines
```go
func Lines(r io.Reader) <-chan string
```
`Lines` converts a `io.Reader` to a channel that generates a line for each
receipt. This is actually a shorthand of LinesWithError, ignoring errors.
#### func LinesWithError
```go
func LinesWithError(r io.Reader) (lines <-chan string, err <-chan error)
```
`LinesWithError` converts a `io.Reader` to a channel that generates a line for
each receipt. If error occurs druing reading lines, it sends `error` to channel
`errs`. `errs` is sent at most one value. If there is no error, `err` receives
`nil`.
## License
The Simplified BSD License (2-clause).
See [LICENSE](LICENSE) file also.
## Author
Daisuke (yet another) Maki