Zwei effiziente Tipps in der Go-Sprache

Dieser Artikel gibt Ihnen zwei effiziente Tipps in der Go-Sprache: Der eine besteht darin, nicht + und fmt.Sprintf zum Betreiben von Zeichenfolgen zu verwenden. Der andere besteht darin, temporäre Strukturen für Schlüssel-Wert-Paare fester Felder zu verwenden ]Schnittstelle{}.

1. Verwenden Sie nicht + und fmt.Sprintf, um Strings zu bedienen.

+ ist sehr praktisch, um Strings zu bedienen, aber die Verwendung von + in der Go-Sprache führt dazu, dass Ihr Programm ausgeführt wird schneller Es ist möglicherweise besser als eine Skriptsprache, Sie können einen Test selbst durchführen und 100.000 Mal iterieren. Python und Javascript sind viel schneller als Go.

func TestStr(t *testing.T) {
    str := ""
    for i := 0; i < 100000; i++ {
        str += "test"
    }
}

Testergebnis

PASS: TestStr (3,32s)

str=""
for i in range(100000):
    str+="test"

Testergebnis:

~/» Zeit python test.py                                                              1 % CPU 0,078 insgesamt

Als statische Sprache ist die Ausführungseffizienz von Go für einen so einfachen Code 100-mal langsamer als die von Python. Ist das nicht unglaublich? Es ist kein Go-Problem, aber die Verwendung von + zum Verarbeiten von Zeichenfolgen in Go ist sehr leistungsintensiv, und Python hätte die Optimierung der +-Operationszeichenfolge überlasten müssen. (Javascript + Betriebszeichenfolgen sind ebenfalls schnell)

Verwandte Tutorials:

Video-Tutorial ansehen

Am effektivsten ist die Verwendung von Puffer

strBuf := bytes.NewBufferString("")
for i := 0; i < 100000; i++ {
    strBuf.WriteString("test")
}

Die Ergebnisse können Sie selbst testen und Sie werden überrascht sein

Bei einigen ist die Verwendung von Buffer etwas aufwändiger .Sprintf() Kombination, der Quellcode in vielen Paketen wird auch auf diese Weise geschrieben. Tatsächlich ist Sprintf von fmt auch sehr langsam, wenn es keine komplexe Typkonvertierungsausgabe gibt, ist die Leistung bei der Verwendung von strings.Join viel höher

func TestStr(t *testing.T) {
    a, b := "Hello", "world"
    for i := 0; i < 1000000; i++ {
        fmt.Sprintf("%s%s", a, b)
        //strings.Join([]string{a, b}, "")
    }
}

PASS: TestStr (0,29s)

func TestStr(t *testing.T) {
    a, b := "Hello", "world"
    for i := 0; i < 1000000; i++ {
        //fmt.Sprintf("%s%s", a, b)
        strings.Join([]string{a, b}, "")
    }
}

PASS: TestStr (0,09 s)

Den Ergebnissen nach zu urteilen, ist strings.Join etwa viermal schneller als die Verwendung von Sprint.

2. Für Schlüssel-Wert-Paare fester Felder verwenden Sie temporäres Struct anstelle von map[string]interface{}

Geben Sie ein einfaches Beispiel

func TestData(t *testing.T) {

    for i := 0; i < 100000000; i++ {
        var a struct {
            Name string
            Age  int
        }
        a.Name = "Hello"
        a.Age = 10
    }
}

PASS: TestData ( 0,04s)

func TestData2(t *testing.T) {

    for i := 0; i < 100000000; i++ {
        var a = map[string]interface{}{}
        a["Name"] = "Hello"
        a["Age"] = 10
    }
}

PASS: TestData2 (38,30s)

Die Effizienz ist tausendmal anders!

Wenn die Felder bekannt sind, erfordert die Verwendung temporärer Strukturen keine dynamische Zuweisung von Inhalten während der Laufzeit und es besteht keine Notwendigkeit, den Index wie bei einer Karte zu überprüfen, sodass die Geschwindigkeit viel schneller ist.

Das obige ist der detaillierte Inhalt vonZwei effiziente Tipps in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!