Was ist eine Rune?

Was ist ein runein Go?

Ich habe gegoogelt, aber Golang sagt nur in einer Zeile: runeist ein Alias ​​fürint32 .

Aber wie kommt es, dass Ganzzahlen überall verwendet werden, wie wenn Fälle ausgetauscht werden?

Das Folgende ist ein Funktionsaustauschfall. Was ist das alles <=und -?

Und warum gibt switches keine Argumente?

&&sollte bedeuten und aber was ist das r <= 'z'?

func SwapRune(r rune) rune {
    switch {
    case 'a' <= r && r <= 'z':
        return r - 'a' + 'A'
    case 'A' <= r && r <= 'Z':
        return r - 'A' + 'a'
    default:
        return r
    }
}

Die meisten von ihnen stammen von http://play.golang.org/p/H6wjLZj6lW

func SwapCase(str string) string {
    return strings.Map(SwapRune, str)
}

Ich verstehe, dass dies eine Zuordnung ist rune, stringdamit die ausgetauschte Zeichenfolge zurückgegeben werden kann. Aber ich verstehe nicht, wie genau runeoder bytefunktioniert hier.

Runenliterale sind nur 32-Bit-Ganzzahlwerte ( sie sind jedoch untypisierte Konstanten, sodass sich ihr Typ ändern kann ). Sie repräsentieren Unicode-Codepunkte. Zum Beispiel ist das Runenliteral 'a'tatsächlich die Zahl 97.

Daher ist Ihr Programm ziemlich gleichbedeutend mit:

package main

import "fmt"

func SwapRune(r rune) rune {
    switch {
    case 97 <= r && r <= 122:
        return r - 32
    case 65 <= r && r <= 90:
        return r + 32
    default:
        return r
    }
}

func main() {
    fmt.Println(SwapRune('a'))
}

Es sollte offensichtlich sein, wenn Sie sich die Unicode-Zuordnung ansehen, die mit ASCII in diesem Bereich identisch ist . Darüber hinaus ist 32 tatsächlich der Versatz zwischen dem Groß- und Kleinbuchstaben des Zeichens. Also durch Zugabe 32zu 'A', man bekommt , 'a'und umgekehrt.

Aus den Versionshinweisen von Go lang: http://golang.org/doc/go1#rune

Rune ist ein Typ. Es belegt 32 Bit und soll einen Unicode- CodePoint darstellen . Als Analogie hat der in 'ASCII' codierte englische Zeichensatz 128 Codepunkte. Somit kann in ein Byte (8bit) gepasst werden. Ausgehend von dieser (fehlerhaften) Annahme behandelte C Zeichen als "Bytes" charund "Zeichenfolgen" als "Folge von Zeichen" char*.

Aber rate mal was. Es gibt viele andere Symbole, die von Menschen erfunden wurden, außer den 'abcde ..'-Symbolen. Und es gibt so viele, dass wir 32 Bit benötigen, um sie zu codieren.

In Golang stringist a dann eine Folge von bytes. Da jedoch mehrere Bytes einen Runencodepunkt darstellen können, kann ein Zeichenfolgenwert auch Runen enthalten. Es kann also in a konvertiert []runewerden oder umgekehrt.

Das Unicode-Paket http://golang.org/pkg/unicode/ kann einen Vorgeschmack auf den Reichtum der Herausforderung geben.

Ich habe versucht, meine Sprache einfach zu halten, damit ein Laie versteht rune.

Eine Rune ist ein Charakter. Das ist es.

Es ist ein einzelnes Zeichen. Es ist ein Zeichen aus jedem Alphabet aus jeder Sprache von überall auf der Welt.

Um einen String zu bekommen, verwenden wir

double-quotes ""

ODER

back-ticks ``

Eine Zeichenfolge unterscheidet sich von einer Rune. In Runen verwenden wir

single-quotes ''

Jetzt ist eine Rune auch ein Alias ​​für int32... Äh was?

Der Grund, warum Rune ein Alias int32ist, liegt darin, dass wir dies bei Codierungsschemata wie den folgenden sehen

Jedes Zeichen ist einer Nummer zugeordnet, und daher ist es die Nummer, die wir speichern. Zum Beispiel ist eine Zuordnung zu 97 und wenn wir diese Nummer speichern, ist es nur die Nummer und so ist Rune ein Alias ​​für int32. Ist aber nicht irgendeine Zahl. Es ist eine Zahl mit 32 'Nullen und Einsen' oder '4' Bytes. (Hinweis: UTF-8 ist ein 4-Byte-Codierungsschema.)

Wie verhalten sich Runen zu Saiten?

Eine Zeichenfolge ist eine Sammlung von Runen. Im folgenden Code:

    package main

    import (
        "fmt"
    )

    func main() {
        fmt.Println([]byte("Hello"))
    }

Wir versuchen, einen String in einen Bytestrom umzuwandeln. Die Ausgabe ist:

[72 101 108 108 111]

Wir können sehen, dass jedes der Bytes, aus denen diese Zeichenfolge besteht, eine Rune ist.

Ich habe nicht genug Ruf, um einen Kommentar zur Antwort von fabrizioM zu schreiben , daher muss ich ihn stattdessen hier posten.

Fabrizios Antwort ist weitgehend richtig, und er hat sicherlich die Essenz des Problems erfasst - obwohl eine Unterscheidung getroffen werden muss.

Eine Zeichenfolge ist NICHT unbedingt eine Folge von Runen. Es ist ein Wrapper über einem 'Slice of Bytes', wobei ein Slice ein Wrapper über ein Go-Array ist. Welchen Unterschied macht das?

EIN Runentyp ist notwendigerweise ein 32-Bit-Wert, was bedeutet, dass eine Folge von Werten von Runentypen notwendigerweise eine bestimmte Anzahl von Bits x * 32 haben würde. Strings sind eine Folge von Bytes und haben stattdessen eine Länge von x * 8 Bits. Wenn alle Zeichenfolgen tatsächlich in Unicode wären, hätte dieser Unterschied keine Auswirkungen. Da Zeichenfolgen jedoch Slices von Bytes sind, kann Go ASCII oder eine beliebige andere Bytecodierung verwenden.

String-Literale müssen jedoch in die in UTF-8 codierte Quelle geschrieben werden.

Informationsquelle: http://blog.golang.org/strings

( Ich hatte das Gefühl, dass die obigen Antworten die Unterschiede und Beziehungen zwischen stringund immer noch nicht []runesehr deutlich darstellten, daher würde ich versuchen, eine weitere Antwort mit Beispiel hinzuzufügen.)

Wie @Strangeworkdie Antwort sagte, stringund []runesind ganz anders.

Unterschiede - string& []rune:

• string valueist ein schreibgeschütztes Byte-Slice. Und ein Zeichenfolgenliteral ist in utf-8 codiert. Jedes Zeichen in stringtatsächlich nimmt 1 ~ 3 Bytes, während jeder runedauert 4 Bytes
• Denn stringsowohl len()als auch der Index basieren auf Bytes.
• Denn []runesowohl len()als auch der Index basieren auf Rune (oder Int32).

Beziehungen - string& []rune:

• Wenn Sie von stringnach konvertieren , []runewird jedes utf-8-Zeichen in dieser Zeichenfolge zu a rune.
• In ähnlicher Weise wird bei der umgekehrten Konvertierung bei der Konvertierung von []runenach stringjedes runeein utf-8-Zeichen in der string.

Tipps:

• Sie können zwischen stringund konvertieren []rune, aber sie unterscheiden sich in Typ und Gesamtgröße.

(Ich würde ein Beispiel hinzufügen, um dies deutlicher zu zeigen.)

Code

string_rune_compare.go:

// string & rune compare,
package main

import "fmt"

// string & rune compare,
func stringAndRuneCompare() {
    // string,
    s := "hello你好"

    fmt.Printf("%s, type: %T, len: %d\n", s, s, len(s))
    fmt.Printf("s[%d]: %v, type: %T\n", 0, s[0], s[0])
    li := len(s) - 1 // last index,
    fmt.Printf("s[%d]: %v, type: %T\n\n", li, s[li], s[li])

    // []rune
    rs := []rune(s)
    fmt.Printf("%v, type: %T, len: %d\n", rs, rs, len(rs))
}

func main() {
    stringAndRuneCompare()
}

Ausführen:

Führen Sie string_rune_compare.go aus

Ausgabe:

hello你好, type: string, len: 11
s[0]: 104, type: uint8
s[10]: 189, type: uint8

[104 101 108 108 111 20320 22909], type: []int32, len: 7

Erläuterung:

• Die Zeichenfolge hello你好hat die Länge 11, da die ersten 5 Zeichen jeweils nur 1 Byte benötigen, während die letzten 2 chinesischen Zeichen jeweils 3 Byte benötigen.

  • So, total bytes = 5 * 1 + 2 * 3 = 11
  • Da len()on string auf Bytes basiert, wird somit die erste Zeile gedrucktlen: 11
  • Da der Index für eine Zeichenfolge ebenfalls auf Bytes basiert, geben die folgenden 2 Zeilen Werte vom Typ aus uint8(da bytees sich um einen Alias-Typ von uint8, in go handelt).

• Bei der Konvertierung stringnach []runewurden 7 utf8-Zeichen gefunden, also 7 Runen.

  • Da len()on []runeauf Rune basiert, wird somit die letzte Zeile gedruckt len: 7.
  • Wenn Sie []runeüber Index arbeiten, greift es auf Basis der Rune zu.
    Da jede Rune von einem utf8-Zeichen in der ursprünglichen Zeichenfolge stammt, können Sie auch sagen, dass beide len()und []runedie Indexoperation auf utf8-Zeichen basieren.

Alle anderen haben den Teil im Zusammenhang mit Runen behandelt, deshalb werde ich nicht darüber sprechen.

Es gibt jedoch auch eine Frage, die sich darauf bezieht switch, keine Argumente zu haben. Dies liegt einfach daran, dass in Golang switchohne Ausdruck eine alternative Möglichkeit ist, die if / else-Logik auszudrücken. Schreiben Sie zum Beispiel Folgendes:

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

ist dasselbe wie dies zu schreiben:

t := time.Now()
if t.Hour() < 12 {
    fmt.Println("It's before noon")
} else {
    fmt.Println("It's after noon")
}

Sie können mehr lesen hier .

Eine Rune ist ein int32-Wert und daher ein Go-Typ, der zur Darstellung eines Unicode-Codepunkts verwendet wird. Ein Unicode-Codepunkt oder eine Codeposition ist ein numerischer Wert, der normalerweise zur Darstellung einzelner Unicode-Zeichen verwendet wird.