tranche de chaîne de golang

En golang, le type string est un type immuable, c'est-à-dire que sa valeur ne peut pas être modifiée directement. Mais dans certains scénarios, nous devons parfois convertir le type de chaîne en une séquence de caractères modifiable (slice). Cet article présentera deux méthodes pour réaliser cette conversion.

Méthode 1 : utiliser le package strings

Le package strings est un package de traitement de chaînes dans la bibliothèque standard golang, qui fournit une méthode pour convertir des chaînes en tranches. L'implémentation spécifique est la suivante :

import "strings"

func StringToSlice(s string) []rune {
    return []rune(s)
}

Le type rune est utilisé dans cette méthode. Le type rune représente des caractères Unicode et peut inclure des caractères en chinois, japonais, coréen et d'autres langues. En convertissant le type chaîne en type rune, vous pouvez obtenir une séquence de caractères modifiable (slice).

Voici un exemple simple montrant l'utilisation de cette méthode :

package main

import (
    "fmt"
    "strings"
)

func StringToSlice(s string) []rune {
    return []rune(s)
}

func main() {
    s := "hello world"
    sl := StringToSlice(s)
    sl[0] = 'H'
    fmt.Println(sl)
    fmt.Println(strings.ToUpper(string(sl)))
}

Sortie du programme :

[72 101 108 108 111 32 119 111 114 108 100]
HELLO WORLD

En passant la tranche renvoyée par la fonction StringToSlice à la fonction strings.ToUpper, nous pouvons convertir la chaîne en lettres majuscules.

Méthode 2 : Utiliser la tranche d'octets

En plus d'utiliser le package de chaînes, nous pouvons également convertir le type de chaîne en tranche d'octets, puis convertir la tranche d'octets en tranche de type rune. L'implémentation spécifique est la suivante :

func StringToSlice(s string) []rune {
    bs := []byte(s)
    rs := make([]rune, len(bs))
    for i, b := range bs {
        rs[i] = rune(b)
    }
    return rs
}

Dans cette méthode, nous utilisons une tranche de type octet. Le type d'octet représente un entier non signé de 8 bits. En convertissant le type chaîne en tranche de type octet, nous pouvons obtenir une séquence stockée en octets. Nous parcourons la tranche de type octet, convertissons chaque élément en type rune et renvoyons enfin une tranche de type rune.

Ce qui suit est un exemple d'utilisation de cette méthode :

package main

import (
    "fmt"
)

func StringToSlice(s string) []rune {
    bs := []byte(s)
    rs := make([]rune, len(bs))
    for i, b := range bs {
        rs[i] = rune(b)
    }
    return rs
}

func main() {
    s := "hello world"
    sl := StringToSlice(s)
    sl[0] = 'H'
    fmt.Println(sl)
}

Sortie du programme :

[72 101 108 108 111 32 119 111 114 108 100]

Similaire à la méthode 1, nous pouvons également convertir la tranche en chaîne et utiliser la fonction d'opération de chaîne fournie par le package strings pour implémenter la chaîne Conversion de cas et autres opérations.

Conclusion

En général, nous recommandons d'utiliser l'API fournie par le package strings pour traiter les chaînes et les séquences de caractères, car elle offre non seulement de meilleures performances, mais offre également plus de garanties de sécurité de type. Mais dans certains cas particuliers, le byte slice offre une méthode de traitement plus flexible qui peut s'adapter à différents besoins.

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!