Conseils courants sur le traitement des chaînes Go

1. Chaînes multilignes

str := `This is a
multiline
string.`

Remarque - toute indentation que vous mettez dans la chaîne sera conservée dans le résultat final.

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

2. Concaténation de chaînes efficace

Go vous permet de concaténer des chaînes via "+", mais cette méthode sera très lente dans les scénarios où un grand nombre de concaténations de chaînes sont traitées. Utiliser bytes.Buffer pour concaténer des chaînes est un moyen plus efficace, il concatènera tout en une chaîne à la fois.

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-"
}

Si vous préparez toutes les ficelles à l'avance, vous pouvez également y parvenir grâce aux ficelles.Rejoignez-nous.

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. Convertir un entier (ou n'importe quel type de données) en chaîne

Dans la plupart des langues, vous pouvez facilement convertir n'importe quel type de données en chaîne pour l'épissage, ou utiliser l'insertion de chaîne (par exemple "ID= #{id}" en rubis). Malheureusement, si vous essayez d'effectuer une opération aussi évidente dans Go, comme forcer la conversion d'un entier en chaîne, vous n'obtiendrez pas les résultats escomptés.

i := 123
s := string(i)

Que voulez-vous que le résultat de s soit ? Si vous étiez comme la plupart des gens et que vous aviez deviné « 123 », vous ne pourriez pas vous tromper davantage. Au lieu de cela, vous obtiendrez quelque chose comme « E ». Ce n’est pas du tout ce que nous souhaitons !

Au lieu de cela, vous devez utiliser un package comme [strconv] (https://golang.org/pkg/strconv/) ou une fonction comme fmt.Sprintf. Par exemple, voici un exemple d'utilisation de strconv.Itoa pour convertir un entier en chaîne.

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

Vous pouvez également utiliser la fonction fmt.Sprintf pour convertir presque n'importe quel type de données en chaîne, mais cela doit généralement être réservé aux cas où la chaîne que vous créez contient des données intégrées, pas lorsque vous prévoyez d'utiliser lors de la conversion d'un seul entier en chaîne.

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

Sprintf fonctionne presque de la même manière que fmt.Printf, sauf qu'au lieu d'afficher la chaîne résultante sur la sortie standard, il la renvoie sous forme de chaîne.

Utilisation restreinte de Sprintf

Comme mentionné précédemment, fmt.Sprintf est généralement utilisé pour créer des chaînes avec des valeurs intégrées. Il y a plusieurs raisons à cela, mais la plus importante est que fmt.Sprintf n'effectue aucune vérification de type, il est donc peu probable que vous trouviez des erreurs avant d'exécuter réellement le code.

Sprintf est également plus lent que la plupart des fonctions que vous utiliseriez normalement dans le package strconv, bien que si je suis honnête, la différence de vitesse est si petite qu'elle ne vaut généralement pas la peine d'être prise en compte.

4. Créer des chaînes aléatoires

Ce n'est pas vraiment une « astuce rapide », mais je trouve que c'est une question qu'on me pose souvent.

Comment créer des chaînes aléatoires dans Go ?

Cela semble simple. De nombreux langages, comme Ruby et Python, fournissent des aides qui facilitent grandement la génération de chaînes aléatoires. Go doit donc disposer d'un tel outil, n'est-ce pas ? La réponse est fausse.

Go choisit de fournir uniquement des outils permettant de créer des chaînes aléatoires, laissant les détails au développeur. Même si cela peut être un peu difficile au début, l'avantage est que vous avez un contrôle total sur la façon dont vous générez la chaîne. Cela signifie que vous pouvez spécifier le jeu de caractères, comment amorcer la génération aléatoire et tout autre détail. En bref, vous avez plus de contrôle, mais au prix d’écrire du code supplémentaire.

Voici un exemple rapide utilisant le package math/rand et un jeu de caractères alphanumériques comme jeu de caractères.

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 génère toujours la même chaîne

Si vous exécutez ce code plusieurs fois sur Go Playground, vous remarquerez peut-être qu'il génère toujours la même chaîne -aJFLa7XPH5.

C'est parce que le terrain d'entraînement Go utilise toujours le même temps, donc lorsque nous utilisons la méthode rand.NewSource. La valeur transmise à l'heure actuelle est toujours la même, donc la chaîne que nous générons est toujours la même.

Il existe peut-être de meilleures solutions que celle-ci pour vos besoins spécifiques, mais c'est un bon point de départ. Si vous cherchez des moyens d'améliorer/modifier votre code, vous pouvez envisager d'utiliser le package crypto/rand pour générer des données aléatoires - c'est généralement plus sûr, mais peut en fin de compte nécessiter plus de travail.

Peu importe ce que vous utilisez, cet exemple devrait vous aider à démarrer. Cela fonctionne assez bien pour la plupart des cas d'utilisation pratiques qui n'impliquent pas de données sensibles telles que des mots de passe et des systèmes d'authentification. N'oubliez pas d'amorcer votre générateur de nombres aléatoires ! Cela peut être fait dans le package math/rand via la fonction rand.Seed, ou en créant un code source. Dans l'exemple ci-dessus, j'ai choisi de créer un code source.

5. Package de chaînes, HasPrefix et code personnalisé

Lors du traitement des chaînes, vous souhaitez savoir si une chaîne commence par une chaîne spécifique ou se termine par une chaîne spécifique. C'est une situation très courante. Par exemple, si vos clés API commencent toutes par sk_, vous souhaiterez peut-être vérifier que toutes les clés API fournies dans la requête API commencent par ce préfixe, sinon les recherches dans la base de données vous feront perdre beaucoup de temps.

Pour les fonctions qui semblent être des cas d'utilisation très courants, le mieux est généralement de visiter directement le package de chaînes et de vérifier quelques éléments qui pourraient vous aider. Dans ce cas, vous souhaiterez utiliser les fonctions HasPrefix(str, prefix) et strings.HasSuffix(str, prefix). Vous pouvez voir leur utilisation ci-dessous.

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教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!