Allgemeine Tipps zur Verarbeitung von Go-Strings

1. Mehrzeilige Zeichenfolgen

str := `This is a
multiline
string.`

Hinweis: Alle Einrückungen, die Sie in die Zeichenfolge einfügen, bleiben im Endergebnis erhalten.

str := `This string
    will have
    tabs in it`

2. Effiziente String-Verkettung

Go ermöglicht die Verkettung von Strings über „+“, aber diese Methode ist in Szenarien, in denen eine große Anzahl von String-Verkettungen verarbeitet wird, sehr langsam. Die Verwendung von bytes.Buffer zum Verketten von Zeichenfolgen ist eine effizientere Methode, da alles auf einmal zu einer Zeichenfolge verkettet wird.

package main
import (
    "bytes"
    "fmt"
)
func main() {
    var b bytes.Buffer
    for i := 0; i < 1000; i++ {
        b.WriteString(randString())
    }
    fmt.Println(b.String())
}
func randString() string {
    // 模拟返回一个随机字符串
    return "abc-123-"
}

Wenn Sie alle Strings im Voraus vorbereiten, können Sie dies auch über strings.Join erreichen.

package main
import (
    "fmt"
    "strings"
)
func main() {
    var strs []string
    for i := 0; i < 1000; i++ {
        strs = append(strs, randString())
    }
    fmt.Println(strings.Join(strs, ""))
}
func randString() string {
    // 模拟返回一个随机字符串
    return "abc-123-"
}

3. Konvertieren Sie eine Ganzzahl (oder einen beliebigen Datentyp) in einen String.

In den meisten Sprachen können Sie jeden Datentyp zum Spleißen problemlos in einen String konvertieren oder die Zeichenfolgeneinfügung verwenden (z. B. „ID =#{id}" in Ruby). Leider erhalten Sie nicht die erwarteten Ergebnisse, wenn Sie versuchen, eine so offensichtliche Operation in Go durchzuführen, beispielsweise die Konvertierung einer Ganzzahl in eine Zeichenfolge zu erzwingen.

i := 123
s := string(i)

Wie soll die Ausgabe von s aussehen? Wenn Sie wie die meisten Menschen „123“ geraten hätten, könnten Sie nicht falscher liegen. Stattdessen erhalten Sie so etwas wie „E“. Das ist überhaupt nicht das, was wir wollen!

Stattdessen sollten Sie ein Paket wie [strconv] (https://golang.org/pkg/strconv/) oder eine Funktion wie fmt.Sprintf verwenden. Hier ist beispielsweise ein Beispiel für die Verwendung von strconv.Itoa zum Konvertieren einer Ganzzahl in eine Zeichenfolge.

package main
import (
    "fmt"
    "strconv"
)
func main() {
    i := 123
    t := strconv.Itoa(i)
    fmt.Println(t)
}

Sie können die Funktion fmt.Sprintf auch verwenden, um fast jeden Datentyp in eine Zeichenfolge zu konvertieren. Dies sollte jedoch im Allgemeinen für Fälle reserviert sein, in denen die von Ihnen erstellte Zeichenfolge eingebettete Daten enthält, und nicht, wenn Sie eine Verwendung erwarten beim Konvertieren einer einzelnen Ganzzahl in eine Zeichenfolge.

package main
import "fmt"
func main() {
    i := 123
    t := fmt.Sprintf("We are currently processing ticket number %d.", i)
    fmt.Println(t)
}

Sprintf funktioniert fast identisch mit fmt.Printf, außer dass es die resultierende Zeichenfolge nicht an die Standardausgabe ausgibt, sondern als Zeichenfolge zurückgibt.

Eingeschränkte Verwendung von Sprintf

Wie bereits erwähnt, wird fmt.Sprintf normalerweise zum Erstellen von Zeichenfolgen mit eingebetteten Werten verwendet. Dafür gibt es mehrere Gründe, aber der wichtigste ist, dass fmt.Sprintf keine Typprüfung durchführt, sodass Sie wahrscheinlich keine Fehler finden werden, bevor Sie den Code tatsächlich ausführen.

Sprintf ist auch langsamer als die meisten Funktionen, die Sie normalerweise im Paket strconv verwenden, obwohl der Geschwindigkeitsunterschied, wenn ich ehrlich bin, so gering ist, dass es im Allgemeinen keine Überlegung wert ist.

4. Erstellen Sie zufällige Zeichenfolgen

Das ist nicht wirklich ein „schneller Trick“, aber ich finde, dass mir diese Frage oft gestellt wird.

Wie erstelle ich zufällige Zeichenfolgen in Go?

Klingt einfach. Viele Sprachen wie Ruby und Python bieten Hilfsprogramme, die die Generierung zufälliger Zeichenfolgen sehr einfach machen. Go muss also über ein solches Tool verfügen, oder? Die Antwort ist falsch.

Go stellt nur Tools zum Erstellen zufälliger Zeichenfolgen bereit und überlässt die Details dem Entwickler. Auch wenn es anfangs etwas schwierig sein mag, liegt der Vorteil darin, dass Sie die volle Kontrolle darüber haben, wie Sie die Zeichenfolge generieren. Dies bedeutet, dass Sie den Zeichensatz, die Art der Zufallsgenerierung und andere Details angeben können. Kurz gesagt, Sie haben mehr Kontrolle, allerdings auf Kosten des Schreibens von zusätzlichem Code.

Hier ist ein kurzes Beispiel mit dem Paket math/rand und einem Satz alphanumerischer Zeichen als Zeichensatz.

package main
import (
    "fmt"
    "math/rand"
    "time"
)
func main() {
    fmt.Println(RandString(10))
}
var source = rand.NewSource(time.Now().UnixNano())
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
func RandString(length int) string {
    b := make([]byte, length)
    for i := range b {
        b[i] = charset[source.Int63()%int64(len(charset))]
    }
    return string(b)
}

Go Playground gibt immer die gleiche Zeichenfolge aus

Wenn Sie diesen Code mehrmals auf Go Playground ausführen, stellen Sie möglicherweise fest, dass er immer die gleiche Zeichenfolge -aJFLa7XPH5 ausgibt.

Das liegt daran, dass das Go-Trainingsgelände immer die gleiche Zeit verwendet, also wenn wir die rand.NewSource-Methode verwenden. Der in der aktuellen Zeit übergebene Wert ist immer derselbe, daher ist die von uns generierte Zeichenfolge immer dieselbe.

Vielleicht gibt es für Ihre spezifischen Anforderungen bessere Lösungen als diese, aber dies ist ein guter Ausgangspunkt. Wenn Sie nach Möglichkeiten suchen, Ihren Code zu verbessern/ändern, könnten Sie die Verwendung des Pakets crypto/rand zum Generieren von Zufallsdaten in Betracht ziehen – das ist im Allgemeinen sicherer, erfordert aber letztendlich möglicherweise mehr Arbeit.

Egal, was Sie am Ende verwenden, dieses Beispiel soll Ihnen den Einstieg erleichtern. Es funktioniert gut genug für die meisten praktischen Anwendungsfälle, bei denen es nicht um sensible Daten wie Passwörter und Authentifizierungssysteme geht. Denken Sie nur daran, Ihren Zufallszahlengenerator zu starten! Dies kann im Paket math/rand über die Funktion rand.Seed oder durch die Erstellung eines Quellcodes erfolgen. Im obigen Beispiel habe ich mich für die Erstellung eines Quellcodes entschieden.

5. Strings-Paket, HasPrefix und benutzerdefinierter Code

Bei der Verarbeitung von Strings möchten Sie wissen, ob ein String mit einem bestimmten String beginnt oder mit einem bestimmten String endet. Dies ist eine sehr häufige Situation. Wenn Ihre API-Schlüssel beispielsweise alle mit sk_ beginnen, möchten Sie möglicherweise überprüfen, dass alle in der API-Anfrage bereitgestellten API-Schlüssel mit diesem Präfix beginnen, da die Datenbanksuche sonst viel Zeit verschwendet.

Für Funktionen, die nach sehr häufigen Anwendungsfällen klingen, ist es normalerweise am besten, direkt das Strings-Paket aufzurufen und sich ein paar Dinge anzusehen, die Ihnen helfen könnten. In diesem Fall möchten Sie die Funktionen HasPrefix(str, prefix) und strings.HasSuffix(str, prefix) verwenden. Sie können ihre Verwendung unten sehen.

package main
import (
    "fmt"
    "strings"
)
func main() {
    fmt.Println(strings.HasPrefix("something", "some"))
    fmt.Println(strings.HasSuffix("something", "thing"))
}

虽然 strings 包中有大量有用的公共函数，但值得注意的是，并不总是值得去寻找一个能满足您需要的包。如果你有其他语言经验正在学习 Go 语言，一个常见的错误是开发者花太多时间寻找能够提供所需功能的包，而他们自己可轻易地编码实现这功能。

使用标准库肯定有好处（如它们经过了彻底的测试并有很好的文档记录）。尽管有这些好处，但如果你发现自己花了超过几分钟的时间来寻找一个函数，那么自己编写它通常也是有益的。在这种情况下，根据需求自定义（编码)，将很快完成，你将完全了解正在发生的事情，不会被奇怪的边界情况（译者注如索引越界）措手不及。您也不必担心其他人维护代码。

6. 字符串可以被转换成 byte 切片 (反之亦然)

Go 语言可以将一个字符串转换成 byte 切片 ([]byte) ，也可以将 byte 切片转换成字符串。转换的过程跟其他任意类型转换的方式一样简单。这种转换方式通常用于为一个接收 byte 切片参数的函数传递一个字符串 以及 为一个接收字符串参数的函数传递 byte 切片的场景。

下面是一个转换的例子：

package main
import "fmt"
func main() {
    var s string = "this is a string"
    fmt.Println(s)
    var b []byte
    b = []byte(s)
    fmt.Println(b)
    for i := range b {
        fmt.Println(string(b[i]))
    }
    s = string(b)
    fmt.Println(s)
}

以上就是 Go 语言字符串使用过程中的一些小技巧，希望能帮到你。如果你需要更多 Go 相关的实践，可以查阅我发表的其他相关教程。

推荐教程：《Go教程》

Das obige ist der detaillierte Inhalt vonAllgemeine Tipps zur Verarbeitung von Go-Strings. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!