Technický dotaz: Je io.WriteString rychlejší? []byte(str) kopíruje obsah paměti, ale podle dokumentace ResponseWriter má pouze metodu Write pro řez bajtů.
// WriteString writes the contents of the string s to w, which accepts a slice of bytes.
// If w implements a WriteString method, it is invoked directly.
// Otherwise, w.Write is called exactly once.
func WriteString(w Writer, s string) (n int, err error) {
if sw, ok := w.(stringWriter); ok {
return sw.WriteString(s)
}
return w.Write([]byte(s))
}
Pro informaci, když v GoDoc kliknete na název typu/funkce/metody, otevře se vám zdrojový soubor v místě definice daného typu/funkce/metody.
ty benchmarky jsem hodil sem, at to nemusite opisovat (taby atd...):
https://github.com/tisnik/go-root/blob/master/benchmarks/byte_output/io_write_string.go
https://github.com/tisnik/go-root/blob/master/benchmarks/byte_output/write_method.go
Při zápisu do souborů (s flushem) to vychází prakticky stejně. Připadá mi, že io.WriteString je nekdy nepatrně pomalejší, ale to je problém microbenchmarků - nedávají moc konzistentní data.
Benchmarky:
package main
import (
"bufio"
"bytes"
//"io"
"os"
"time"
)
func main() {
length := 100000000
var buffer bytes.Buffer
for i := 0; i < length; i++ {
buffer.WriteString("abc\n")
}
data := buffer.String()
f, _ := os.Create("/tmp/d1")
defer f.Close()
t1 := time.Now()
writer := bufio.NewWriter(f)
writer.Write([]byte(data))
writer.Flush()
elapsed := time.Since(t1)
println(elapsed)
}
package main
import (
"bufio"
"bytes"
"io"
"os"
"time"
)
func main() {
length := 100000000
var buffer bytes.Buffer
for i := 0; i < length; i++ {
buffer.WriteString("abc\n")
}
data := buffer.String()
f, _ := os.Create("/tmp/d2")
defer f.Close()
t1 := time.Now()
writer := bufio.NewWriter(f)
io.WriteString(writer, data)
writer.Flush()
elapsed := time.Since(t1)
println(elapsed)
}
Děkuji, ale asi jsme si úplně nerozuměli (nejasně jsem se vyjádřil), mně šlo o rychlost toho responsewriteru pro http. Našel jsem si v kódu, že WriteString ten (privátní) objekt implementující ResponseWriter podporuje, takže io.WriteString asi nakonec nekopíruje řetězec do []byte.
Ano, vypadá to tak, že by to nemělo mít prakticky žádný výkonnostní dopad (i když záleží, protože práce na úrovni bajtů je na moderních CPU obecně dost špatná :-)
Naše webové aplikace používají v podstatě jen REST API (+ statický obsah) s JSONem. Bude prosím zmínka o marshallingu/unmarshallingu do JSONu? Něco, co je zmíněno (dost hustě) tady? https://blog.golang.org/json-and-go
Bude, i když je popravdě řečeno řešení v Go dosti divoké ("pere" se tady statický a silný typový systém s dynamičností JSONu). Ale pokud používáte klasické REST API s nějakým schématem (swagger?), tak to je IMHO dobře zvládnutelné.
Když se použijí tagy (nebo jak se to v Go jmenuje), tak je práce s JSONem typově bezpečná, ne? Akorát tedy prý pomalá kvůli reflexi, v Go jsem rychlost zpracování JSONu neměřil. Osobně jsem zatím vždy používal map[string]interface{} (to jste měl asi na mysli).
Ono jde pohodlně použít obě metody, mít pevnou strukturu a demarshalovat do ní nebo použí map[string] interface{} a máte plně dynamickou strukturu a JSON typy otestujete reflexí. Případně použijete kombinaci.
Znovu jsem si ten článek prošel a dodatečně mě napadá, že by bylo vhodné zmínit, jak server udělat alespoň minimálně robustní. Možná v dalším díle by bylo vhodné stručně uvést, jak se nastavují timeouty a parametry SSL (přes crypto/tls). Ono to je na webu anglicky, ale když už píšete tak podrobné články, bylo by hezké mít vše podstatné v jedné sérii článků. Ať tak či onak, doufám, že brzy vyjde další díl :)