Elementary usage of template

Author: iwdgo

src/tmplhtml/README.md

@@ -0,0 +1,17 @@
+# Using template to update one value
+
+Using a template when an elementary Fprint() suffices is costly.
+
+`src>go test -bench=. ./tmplhtml` 
+
+**Results**
+
+```
+go version go1.12.5 windows/amd64
+pkg: github.com/iWdGo/GoCompilerEfficiency/src/tmplhtml
+BenchmarkHTMLOutputTmpl-4         500000              3717 ns/op
+BenchmarkHTMLOutputBuffer-4      5000000               354 ns/op
+PASS
+```
+ 
+ 

src/tmplhtml/tmplhtml.go

@@ -0,0 +1,42 @@
+package tmplhtml
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"log"
+)
+
+const docPage = "efficiency"
+
+var (
+	tmpl = `<a href="http://golang.org/{{.V}}">documentation</a>`
+	// 10x faster than parsing every time as elsewhere
+	tmplT = template.Must(template.New("mytmpl").Parse(tmpl))
+)
+
+type data = struct {
+	V string
+}
+
+// The test only executes the template with one variable value.
+func hTMLOutputTmpl(d *data) *bytes.Buffer {
+	/* Passing the string or the struct does not change much the performance
+	d := new(data)
+	d.V = s
+
+	*/
+	b := new(bytes.Buffer)
+	if err := tmplT.Execute(b, d); err != nil {
+		log.Fatalf("parse: %v", err)
+	}
+	return b
+}
+
+func hTMLOutputBuffer(s string) *bytes.Buffer {
+	b := new(bytes.Buffer)
+	if _, err := fmt.Fprint(b, `<a href="http://golang.org/`+s+`">documentation</a>`); err != nil {
+		log.Fatalf("fprint: %v", err)
+	}
+	return b
+}

src/tmplhtml/tmplhtml_test.go

@@ -0,0 +1,43 @@
+package tmplhtml
+
+import "testing"
+
+const (
+	page      = "efficiency"
+	linkValue = `<a href="http://golang.org/efficiency">documentation</a>`
+)
+
+func TestHTMLOutputTmpl(t *testing.T) {
+	p := new(data)
+	p.V = page
+	for i := 0; i < 5; i++ {
+		if got := hTMLOutputTmpl(p); got.String() != linkValue {
+			t.Fatalf("want %s, got %s\n", linkValue, got)
+		}
+	}
+}
+
+func TestHTMLOutputString(t *testing.T) {
+	// For fairness but no change
+	var s string
+	s = page
+	for i := 0; i < 5; i++ {
+		if got := hTMLOutputBuffer(s); got.String() != linkValue {
+			t.Fatalf("want %s, got %s\n", linkValue, got)
+		}
+	}
+}
+
+// w/o the for loop, no benchmarking occurs because of optimization
+func BenchmarkHTMLOutputTmpl(b *testing.B) {
+	p := new(data)
+	p.V = page
+	for n := 0; n < b.N; n++ {
+		hTMLOutputTmpl(p)
+	}
+}
+func BenchmarkHTMLOutputBuffer(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		hTMLOutputBuffer(page)
+	}
+}

src/writestring/writestring.go

@@ -26,3 +26,5 @@ func ioWriteString(s string) *bytes.Buffer {
 	}
 	return b
 }
+
+// TODO using defaunt print() after re-directing StdOut