Golang la conversion de la rune de la chaîne

J'ai le code suivant, il est censé jeter un rune dans un string et de l'imprimer. Cependant, j'obtiens des caractères non définis lors de l'impression. Je n'arrive pas à trouver où est le bug est:

package main

import (
    "fmt"
    "strconv"
    "strings"
    "text/scanner"
)

func main() {
    var b scanner.Scanner
    const a = `a`
    b.Init(strings.NewReader(a))
    c := b.Scan()
    fmt.Println(strconv.QuoteRune(c))
}

Une raison de vous forcer à utiliser le scanner? Je veux dire que vous essayer de comprendre comment "text/scanner" ou que vous simplement voulez convertir rune à la chaîne?

OriginalL'auteur user3551708 | 2016-08-31

14

C'est parce que vous avez utilisé Scanner.Scan() de lire un rune mais il fait quelque chose d'autre. Scanner.Scan() peut être utilisé pour lire jetons ou runes de des jetons spéciaux contrôlés par le Scanner.Mode masque de bits, et il retourne spécial des constantes de la forme de la text/scanner, ce n'est pas la lecture de la rune elle-même.

De lire un seul rune utilisation Scanner.Next() à la place:
```
c := b.Next()
fmt.Println(c, string(c), strconv.QuoteRune(c))
```
De sortie:
```
97 a 'a'
```
Si vous voulez convertir un seul rune à string, l'utilisation d'un type simple conversion. rune est un alias pour int32, et de la conversion d'un nombre entier de string:

De la conversion d'un entier signé ou non signé valeur à un type de chaîne génère une chaîne de caractères contenant l'UTF-8 est une représentation de l'entier.

Donc:
```
r := rune('a')
fmt.Println(r, string(r))
```
Sorties:
```
97 a
```
Aussi faire une boucle sur les runes d'un string valeur, vous pouvez simplement utiliser la for ... range construire:
```
for i, r := range "abc" {
    fmt.Printf("%d - %c (%v)\n", i, r, r)
}
```
De sortie:
```
0 - a (97)
1 - b (98)
2 - c (99)
```
Ou vous pouvez simplement convertir un string de la valeur à []rune:
```
fmt.Println([]rune("abc")) //Output: [97 98 99]
```
Il est également utf8.DecodeRuneInString().

Essayer les exemples sur la Aller De L'Aire De Jeux.

Remarque:

Votre code d'origine (à l'aide de Scanner.Scan()) fonctionne comme ceci:
1. Vous avez appelé Scanner.Init() qui définit le Mode (b.Mode) à scanner.GoTokens.
2. Appel Scanner.Scan() sur l'entrée (à partir de "a") renvoie scanner.Ident parce que "a" est valide Aller de l'identificateur:
```
c := b.Scan()
if c == scanner.Ident {
    fmt.Println("Identifier:", b.TokenText())
}

//Output: "Identifier: a"
```
OriginalL'auteur icza
1

Je sais que je suis un peu en retard à la fête, mais voici un []rune pour fonction de chaîne:
```
func runesToString(runes []rune) (outString string) {
    //don't need index so _
    for _, v := range runes {
        outString += string(v)
    }
    return
}
```
oui, il est nommé en retour, mais je pense que c'est ok, dans ce cas, car elle réduit le nombre de lignes et la fonction est seulement à court

[]rune à string de conversion est pris en charge nativement par le spec, c'est complètement inutile et lent. Au lieu d'utiliser un simple conversion: outString := string(runes)
Merci @icza 🙂

OriginalL'auteur MarkJL

Vous devez vous connecter pour publier un commentaire.