Wie bekomme ich die Anzahl der Zeichen in einem String?

Wie kann ich die Anzahl der Zeichen einer Zeichenkette in Gehen?

Zum Beispiel, wenn ich einen string "hello" sollte die Methode zurück 5. Ich sah, dass len(str) gibt die Anzahl der bytes und nicht die Anzahl der Zeichen so len("£") gibt 2 statt 1, da £ codiert mit zwei bytes in UTF-8.

InformationsquelleAutor der Frage Ammar | 2012-10-01

character go string string-length

114

Können Sie versuchen, RuneCountInString aus dem utf8-Paket.

gibt die Anzahl der Runen in p

dass, wie dargestellt in dieses Skript: die Länge der "Welt" werden könnte 6 (auf Chinesisch: "世界"), aber seine rune Zählung 2:
```
package main

import "fmt"
import "unicode/utf8"

func main() {
    fmt.Println("Hello, 世界", len("世界"), utf8.RuneCountInString("世界"))
}
```
Phrozen fügt in den Kommentaren:

Tatsächlich, die Sie tun können len() über Runen nur durch type-casting.

len([]rune("世界")) drucken 2. Es muß also mindesten in Go 1.3.

Und mit CL 108985 (Mai 2018, für die Go-1.11), len([]rune(string)) ist jetzt optimiert. (Behebt Problem 24923)

Der compiler erkennt len([]rune(string)) Muster automatisch und ersetzt es mit für r := range s nennen.

Fügt eine neue runtime-Funktion zum zählen Runen in einen string.
Ändert der compiler erkennt das Muster len([]rune(string))
und ersetzt es mit der neuen rune zählen runtime-Funktion.
```
RuneCount/lenruneslice/ASCII                  27.8ns ± 2%  14.5ns ± 3%  -47.70%  (p=0.000 n=10+10)
RuneCount/lenruneslice/Japanese                126ns ± 2%    60ns ± 2%  -52.03%  (p=0.000 n=10+10)
RuneCount/lenruneslice/MixedLength             104ns ± 2%    50ns ± 1%  -51.71%  (p=0.000 n=10+9)
```
Stefan Steiger Punkte auf den blog-post "Text Normalisierung Gehen"

Was ist ein Charakter?
Als erwähnt wurde, in der strings blog-postZeichen kann mehrere Runen.

Zum Beispiel, ein " e ' und '◌◌' (akute "\u0301") kombiniert werden können, um form 'é' ("e\u0301" in NFD). Zusammen bilden diese beiden Runen sind ein Zeichen.

Die definition eines Zeichens kann je nach der Anwendung.

Für Normalisierung wir definieren es als:
- eine Abfolge von Runen, die beginnt mit einem starter,
- eine rune, die nicht modifizieren oder kombinieren Sie rückwärts mit jeder anderen rune,
- gefolgt von evtl. leere Folge von nicht-Startern, ist, dass die Runen, die (in der Regel Akzente).
Die Normalisierung Algorithmus, der Prozesse, ein Zeichen zu einem Zeitpunkt.
Über das Paket und seine Iter - Typdie tatsächliche Anzahl der "Zeichen" wäre:
```
package main

import "fmt"
import "golang.org/x/text/unicode/norm"

func main() {
    var ia norm.Iter
    ia.InitString(norm.NFKD, "école")
    nc := 0
    for !ia.Done() {
        nc = nc + 1
        ia.Next()
    }
    fmt.Printf("Number of chars: %d\n", nc)
}
```
Hier, nutzt dieser die Unicode Normalization form NFKD "Compatibility Decomposition"

InformationsquelleAutor der Antwort VonC

Es ist ein Weg um die Anzahl der Runen, ohne alle Pakete, die durch die Umwandlung von string []rune als len([]rune(YOUR_STRING)):

package main

import "fmt"

func main() {
    russian := "Спутник и погром"
    english := "Sputnik & pogrom"

    fmt.Println("count of bytes:",
        len(russian),
        len(english))

    fmt.Println("count of runes:",
        len([]rune(russian)),
        len([]rune(english)))

}

Anzahl der bytes 30 16

Anzahl der Runen 16 16

InformationsquelleAutor der Antwort Denis Kreshikhin

5

Hängt viel von der eigenen definition, was ein "Charakter" ist. Wenn "rune entspricht einem Zeichen" OK für Ihre Aufgabe (in der Regel ist es nicht), dann ist die Antwort von VonC ist perfekt für Sie. Ansonsten sollte es werden wahrscheinlich bemerkt, dass es wenige Situationen, in denen die Anzahl der Runen in eine Unicode-Zeichenfolge ist ein interessanter Wert. Und selbst in diesen Situationen ist es besser, wenn möglich, zu schließen, die zählen beim "durchqueren" der string, wie die Runen, die verarbeitet werden, zu vermeiden Verdoppelung der UTF-8-decode Aufwand.

InformationsquelleAutor der Antwort zzzz

Wenn Sie brauchen, um grapheme Cluster berücksichtigt werden, verwenden Sie regexp-oder unicode-Modul. Zählen Sie die Anzahl der code-Punkte(Runen) oder bytes, die auch benötigt wird, für validaiton da die Länge grapheme cluster ist unbegrenzt. Wenn Sie ausschließen wollen, dass sehr lange Sequenzen, überprüfen Sie, ob die Sequenzen entsprechen stream-safe-text-format.

package main

import (
    "regexp"
    "unicode"
    "strings"
)

func main() {

    str := "\u0308" + "a\u0308" + "o\u0308" + "u\u0308"
    str2 := "a" + strings.Repeat("\u0308", 1000)

    println(4 == GraphemeCountInString(str))
    println(4 == GraphemeCountInString2(str))

    println(1 == GraphemeCountInString(str2))
    println(1 == GraphemeCountInString2(str2))

    println(true == IsStreamSafeString(str))
    println(false == IsStreamSafeString(str2))
}


func GraphemeCountInString(str string) int {
    re := regexp.MustCompile("\\PM\\pM*|.")
    return len(re.FindAllString(str, -1))
}

func GraphemeCountInString2(str string) int {

    length := 0
    checked := false
    index := 0

    for _, c := range str {

        if !unicode.Is(unicode.M, c) {
            length++

            if checked == false {
                checked = true
            }

        } else if checked == false {
            length++
        }

        index++
    }

    return length
}

func IsStreamSafeString(str string) bool {
    re := regexp.MustCompile("\\PM\\pM{30,}") 
    return !re.MatchString(str) 
}

InformationsquelleAutor der Antwort masakielastic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.