Názory k článku Vývoj síťových aplikací v programovacím jazyku Go (pokračování)

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/un­marshallingu 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]in­terface{} (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 :)