Rune

package main

import "fmt"

func main() {
    // Verschiedene Runes definieren
    var r1 rune = 'A'
    var r2 rune = 'ä'
    var r3 rune = 'Ω'
    var r4 rune = '中'
    var r5 rune = '🚀'

    fmt.Printf("ASCII: %c (Unicode: %U, Dezimal: %d)\n", r1, r1, r1)
    fmt.Printf("Umlaut: %c (Unicode: %U, Dezimal: %d)\n", r2, r2, r2)
    fmt.Printf("Griechisch: %c (Unicode: %U, Dezimal: %d)\n", r3, r3, r3)
    fmt.Printf("Chinesisch: %c (Unicode: %U, Dezimal: %d)\n", r4, r4, r4)
    fmt.Printf("Emoji: %c (Unicode: %U, Dezimal: %d)\n", r5, r5, r5)

}

package main

import (
    "fmt"
    "unicode"
)

func main() {
    text := "Hello, 世界! 🌍"

    for i, r := range text {
        // Eigenschaften sammeln
        properties := []string{}

        if unicode.IsLetter(r) {
            properties = append(properties, "Buchstabe")
        }
        if unicode.IsDigit(r) {
            properties = append(properties, "Ziffer")
        }
        if unicode.IsSpace(r) {
            properties = append(properties, "Leerzeichen")
        }
        if unicode.IsPunct(r) {
            properties = append(properties, "Satzzeichen")
        }
        if unicode.IsSymbol(r) {
            properties = append(properties, "Symbol")
        }
        if len(properties) == 0 {
            properties = append(properties, "Sonstige")
        }

        fmt.Printf("\nZeichen: %c\n", r)
        fmt.Printf("Unicode: U+%04X\n", r)
        fmt.Printf("Kategorie: %s\n", getUnicodeCategory(r))
        fmt.Printf("Eigenschaften: %v\n", properties)
        fmt.Printf("Position: %d\n", i)

        fmt.Println("--- --- ---")
    }
}

func getUnicodeCategory(r rune) string {
    switch {
    case unicode.IsLetter(r):
        return "Buchstabe"
    case unicode.IsDigit(r):
        return "Ziffer"
    case unicode.IsSpace(r):
        return "Leerraum"
    case unicode.IsPunct(r):
        return "Zeichen"
    case unicode.IsSymbol(r):
        return "Symbol"
    default:
        return "Sonstige"
    }
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // Verschiedene Zeichen mit unterschiedlicher Byte-Länge
    examples := []string{"A", "ä", "中", "🚀"}

    for _, char := range examples {
        r, size := utf8.DecodeRuneInString(char)

        fmt.Printf("\nZeichen: %s\n", char)
        fmt.Printf("Unicode: U+%04X (%d)\n", r, r)
        fmt.Printf("UTF-8 Bytes: %d\n", size)
        fmt.Printf("Binär UTF-8: \n")
        for _, b := range []byte(char) {
            fmt.Printf("\t%08b \n", b)
        }

        fmt.Printf("Hex UTF-8: ")
        for _, b := range []byte(char) {
            fmt.Printf("%02X ", b)
        }

        fmt.Printf("\n" + "--- --- ---\n")
    }
}

package main

import "fmt"

func main() {
    text := "Hëllø, 世界!"

    fmt.Printf("Text: %s\n", text)
    fmt.Printf("len(text): %d (Anzahl Bytes)\n", len(text))

    // Falsche Iteration - über Bytes
    for i := 0; i < len(text); i++ {
        fmt.Printf("text[%d] = %c (Byte: %d, 0x%02X)\n", i, text[i], text[i], text[i])
    }
}

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    text := "Hëllø, 世界!"

    fmt.Printf("Text: %s\n", text)
    fmt.Printf("len(text): %d Bytes\n", len(text))
    fmt.Printf("utf8.RuneCountInString(text): %d Runes\n", utf8.RuneCountInString(text))

    // Richtige Iteration - über Runes
    runeIndex := 0
    for byteIndex, r := range text {
        fmt.Printf("Rune %d (Byte-Position: %d): %c (U+%04X, %d)\n", runeIndex, byteIndex, r, r, r)
        runeIndex++
    }

    // Alternative: Manuelle Dekodierung
    byteIndex := 0
    runeIndex = 0
    for byteIndex < len(text) {
        r, size := utf8.DecodeRuneInString(text[byteIndex:])
        fmt.Printf("Rune %d: %c (Bytes: %d-%d, Größe: %d)\n", runeIndex, r, byteIndex, byteIndex+size-1, size)
        byteIndex += size
        runeIndex++
    }
}

package main

import "fmt"

func main() {
    // Direkte Zeichen-Literale
    var r1 rune = 'A'  // ASCII-Buchstabe
    var r2 rune = 'ä'  // Latin-1 Zeichen mit Umlaut
    var r3 rune = '中'  // Chinesisches Zeichen (CJK)
    var r4 rune = '🚀'  // Emoji (4-Byte UTF-8)
    var r5 rune = 'Ω'  // Grichisches Omega
    var r6 rune = '5'  // Ziffer als Zeichen
    var r7 rune = ' '  // Leerzeichen
    var r8 rune = '+'  // Sonderzeichen

    fmt.Printf("'A' (ASCII) ==> %c = %d (0x%X)\n", r1, r1, r1)
    fmt.Printf("'ä' (Latin-1) ==> %c = %d (0x%X)\n", r2, r2, r2)
    fmt.Printf("'中' (CJK) ==> %c = %d (0x%X)\n", r3, r3, r3)
    fmt.Printf("'🚀' (Emoji) ==> %c = %d (0x%X)\n", r4, r4, r4)
    fmt.Printf("'Ω' (Greek) ==> %c = %d (0x%X)\n", r5, r5, r5)
    fmt.Printf("'5' (Ziffer) ==> %c = %d (0x%X)\n", r6, r6, r6)
    fmt.Printf("' ' (Leerzeichen) ==> %c = %d (0x%X)\n", r7, r7, r7)
    fmt.Printf("'+' (Symbol) ==> %c = %d (0x%X)\n", r8, r8, r8)
}

package main

import "fmt"

func main() {
    // Standard Escape-Sequenzen
    var newline rune = '\n'  // Zeilenumbruch
    var tab rune = '\t'  // Tabulator
    var carriageReturn rune = '\r'  // Wagenrücklauf
    var backslash rune = '\\'  // Backslash selbst
    var singleQuote rune = '\''  // Einfaches Anführungszeichen
    var doubleQoute rune = '"'  // Doppeltes Anführungszeichen
    var bell rune = '\a'  // Klingelzeichen
    var backspace rune = '\b'   // Rückschritt
    var formfeed rune = '\f'  // Seitenvorschub
    var vtab rune = '\v'  // Vertikaler Tabulator

    fmt.Printf("Neue Zeile (\\n) ==> ASCII %d | Hex 0x%02X\n", newline, newline)
    fmt.Printf("Tabulator (\\t) ==> ASCII %d | Hex 0x%02X\n", tab, tab)
    fmt.Printf("Wagenrücklauf (\\r) ==> ASCII %d | Hex 0x%02X\n", carriageReturn, carriageReturn)
    fmt.Printf("Backslash (\\\\) ==> ASCII %d | Hex 0x%02X\n", backslash, backslash)
    fmt.Printf("Einfaches ' (\\') ==> ASCII %d | Hex 0x%02X\n", singleQuote, singleQuote)
    fmt.Printf("Doppeltes \" ('\"') ==> ASCII %d | Hex 0x%02X\n", doubleQoute, doubleQoute)
    fmt.Printf("Klingelzeichen (\\a) ==> ASCII %d | Hex 0x%02X\n", bell, bell)
    fmt.Printf("Rückschritt (\\b) ==> ASCII %d | Hex 0x%02X\n", backspace, backspace)
    fmt.Printf("Seitenvorschub (\\f) ==> ASCII %d | Hex 0x%02X\n", formfeed, formfeed)
    fmt.Printf("Vert. Tabulator (\\v) ==> ASCII %d | Hex 0x%02X\n", vtab, vtab)
}

package main

import "fmt"

func main() {
    // Oktal-Escapes (Basis 8)
    // Wichtig: Nur gültig für Werte 0-255 (0-\377 oktal)
    var r1 rune = '\141'  // 141 oktal = 97 dezimal = 'a'
    var r2 rune = '\101'  // 101 oktal = 65 dezimal = 'A'
    var r3 rune = '\040'  // 040 oktal = 32 dezimal = ' ' (Leerzeichen)
    var r4 rune = '\012'  // 012 oktal = 10 dezimal = '\n'
    var r5 rune = '\000'  // 000 oktal = 0 dezimal = NULL-Zeichen
    var r6 rune = '\377'  // 377 oktal = 255 dezimal = höchstes Byte-Zeichen

    // Verkürzte Oktal-Schreibweise (1-2 Ziffern)
    var r7 rune = '\007'  // 007 oktal = 7 dezimal = Bell
    var r8 rune = '\033'  // 033 oktal = 27 dezimal = ESC

    fmt.Printf("\\141 (oktal) = %d (dezimal) = '%c'\n", r1, r1)
    fmt.Printf("\\101 (oktal) = %d (dezimal) = '%c'\n", r2, r2)
    fmt.Printf("\\040 (oktal) = %d (dezimal) = '%c' (Leerzeichen)\n", r3, r3)
    fmt.Printf("\\012 (oktal) = %d (dezimal) = Zeilenumbruch\n", r4)
    fmt.Printf("\\000 (oktal) = %d (dezimal) = NULL-Zeichen\n", r5)
    fmt.Printf("\\377 (oktal) = %d (dezimal) = höchstes Byte\n", r6)
    fmt.Printf("\\007 (oktal) = %d (dezimal) = Bell\n", r7)
    fmt.Printf("\\033 (oktal) = %d (dezimal) = ESC\n", r8)
}

package main

import "fmt"

func main() {
    octals := []string{
        "007",
        "033",
        "040",
        "101",
        "141",
        "377",
    }

    for _, oct := range octals {
        fmt.Printf("\\%s oktal = ", oct)
        switch oct {
        case "007":
            fmt.Printf("%d dezimal\n", 7)
        case "033":
            fmt.Printf("%d dezimal (0*64 + 3*8 + 3 = %d)\n", 0*64+3*8+3, 0*64+3*8+3)
        case "040":
            fmt.Printf("%d dezimal (0*64 + 4*8 + 0 = %d)\n", 0*64+4*8+0, 0*64+4*8+0)
        case "101":
            fmt.Printf("%d dezimal (1*64 + 0*8 + 1 = %d)\n", 1*64+0*8+1, 1*64+0*8+1)
        case "141":
            fmt.Printf("%d dezimal (1*64 + 4*8 + 1 = %d)\n", 1*64+4*8+1, 1*64+4*8+1)
        case "377":
            fmt.Printf("%d dezimal (3*64 + 7*8 + 7 = %d)\n", 3*64+7*8+7, 3*64+7*8+7)
        }
    }
}