ReadByte or Read

Author: iwdgo

src/readbyte/README.md

@@ -0,0 +1,23 @@
+# Reading each byte of a buffer
+
+Each byte (`bg`) can be read using:
+- `_, _ = bb.Read(bg)`
+- `bg, _ = bb.ReadByte()`
+
+So, if you're treating everybyte, a 30% benefit to use ReadByte.
+One less variable is part of the explanation.
+
+`src>go test -bench=. ./returnbyte` 
+
+**Results**
+
+```
+goos: windows
+goarch: amd64
+pkg: github.com/iWdGo/GoCompilerEfficiency/src/readbyte
+BenchmarkBufferRead-4             200000              8540 ns/op
+BenchmarkRBufferReadByte-4        200000              5971 ns/op
+PASS
+```
+ 
+ 

src/readbyte/readbyte.go

@@ -0,0 +1,53 @@
+package readbyte
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"strconv"
+)
+
+const (
+	filling = "Filling the buffer "
+	times   = 20
+	want    = len(filling)*times + 9 + 2*(times-9) // 9 one digit + 11 2-digits (11 to 19)
+)
+
+func fillBuffer(f int) *bytes.Buffer {
+	b := new(bytes.Buffer)
+	for i := 1; i <= f; i++ {
+		if c, err := fmt.Fprintf(b, "%s%d", filling, i); err != nil {
+			fmt.Println("filling buffer failed")
+		} else if c != len(filling)+len(strconv.Itoa(i)) {
+			fmt.Printf("incomplete sentence written (*bytes.Buffer): got %d, want %d\n", c, len(filling))
+		}
+	}
+	if b.Len() != want {
+		log.Fatalf("filling buffer failed: got %d, want %d\n", b.Len(), want)
+	}
+	return b
+}
+
+func ReadAllBytesRead(b *bytes.Buffer) (l int) {
+	var err error
+	var n int // avoid shadowing
+	gotb := make([]byte, 1)
+	for err != io.EOF {
+		n, err = b.Read(gotb)
+		l += n
+	}
+	return
+}
+
+func ReadAllBytesReadByte(b *bytes.Buffer) (l int) {
+	var err error
+	var gotb, e byte
+	for err != io.EOF {
+		gotb, err = b.ReadByte()
+		if gotb != e {
+			l++
+		}
+	}
+	return
+}

src/readbyte/readbyte_test.go

@@ -0,0 +1,44 @@
+package readbyte
+
+// Counting bytes until EOF
+import (
+	"testing"
+)
+
+func TestBufferRead(t *testing.T) {
+	b := fillBuffer(times)
+	if got := ReadAllBytesRead(b); got != want {
+		t.Fatalf("buffer read failed: want %d, got %d\n", want, got)
+	}
+}
+
+func TestBufferReadByte(t *testing.T) {
+	b := fillBuffer(times)
+	if got := ReadAllBytesReadByte(b); got != want {
+		t.Fatalf("buffer read failed: want %d, got %d\n", want, got)
+	}
+}
+
+/*
+func TestBufferReadDelim(t *testing.T) {
+}
+*/
+// w/o the for loop, no benchmarking occurs because of optimization
+func BenchmarkBufferRead(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		ReadAllBytesRead(fillBuffer(times))
+	}
+}
+func BenchmarkRBufferReadByte(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		ReadAllBytesReadByte(fillBuffer(times))
+	}
+}
+
+/*
+func BenchmarkReturnBufferBytes(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		ReturnBufferBytes(times)
+	}
+}
+*/