Caratteri in

Informazioni su Caratteri

Questo è un argomento enorme! Si potrebbe scrivere un intero libro al riguardo, e diverse persone l'hanno fatto (cerca «unicode book» su Amazon per vedere qualche esempio).

Una storia molto breve

Gestire i caratteri nei computer era molto più semplice nei decenni passati, quando i programmatori davano per scontato che l'inglese fosse l'unica lingua importante. Quindi: 26 lettere, maiuscole e minuscole, 10 cifre, alcuni segni di punteggiatura, più un codice (0x07) per far suonare un campanello, e il tutto stava in 7 bit: il set di caratteri ASCII.

Naturalmente le persone hanno iniziato a chiedersi: e per à, ä e Ł? Poi altre persone hanno iniziato a chiedersi per ऄ, ஹ e ญ, e i giovani volevano le emoji 😱. Che fare?

Per farla breve, molte persone intelligenti e pazienti hanno dovuto far parte di commissioni per anni, definendo i dettagli del set di caratteri Unicode e di codifiche come UTF-8, e tantissimo software ha avuto bisogno di una riscrittura molto complicata. Inoltre, sono stati introdotti moltissimi nuovi bug.

Per evitare che tutto si rompa, il design di Unicode/UTF-8 garantisce che i primi 127 codici siano identici all'ASCII (anche il campanello).

I caratteri in Julia

I linguaggi progettati dopo il 2005 circa hanno il grande vantaggio che esisteva già uno standard Unicode ragionevolmente stabile.

Julia (pubblicato per la prima volta nel 2012) ha potuto dare per scontato che tutto sarebbe stato Unicode: caratteri, stringhe, nomi di variabili e funzioni, operatori matematici...

Per citare il manuale, «Julia rende semplice ed efficiente la gestione del testo ASCII puro, e gestire Unicode è il più semplice ed efficiente possibile». Nota il “più possibile”: è una parte importante dell'affermazione.

I valori letterali di tipo carattere si scrivono tra apici singoli e sono distinti dalle stringhe, che si scrivono tra doppi apici.

Questo è ovvio per chi viene dal mondo C/C++, ma può confondere chi programma in Python o JavaScript.

julia> a = 'a'  # Roman alphabet
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> typeof(a)
Char

julia> jha = 'झ'  # Devanagari alphabet
'झ': Unicode U+091D (category Lo: Letter, other)

julia> typeof(jha)
Char


julia> '❤'  # heart emoji
'❤': Unicode U+2764 (category So: Symbol, other)

Dagli esempi vediamo che il tipo è Char, e Julia fornisce ulteriori informazioni sulla categoria del carattere.

Guardando più da vicino, sembra che questi caratteri si possano rappresentare con 4 cifre esadecimali. Il set di caratteri completo richiede fino a 6 cifre esadecimali.

Questi numeri sono chiamati «code point» e attualmente vanno da U+0000 a U+10FFFF. Vengono visualizzati nel REPL, ma all'interno del codice usa codepoints() per ottenerli.

Convertire tra Char e Int è semplice:

julia> Int('a')
97

julia> Char(97)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

Il compilatore consente alcune forme di aritmetica intera sui Char:

julia> 'b' - 'a'  # interval, in alphabetic order
1

julia> 'b' + 'a'
ERROR: MethodError: no method matching +(::Char, ::Char)

julia> 'a' + 5
'f': ASCII/Unicode U+0066 (category Ll: Letter, lowercase)

julia> 'f' + ('A' - 'a')  # same as `uppercase('f')`
'F': ASCII/Unicode U+0046 (category Lu: Letter, uppercase)

Funzioni per i caratteri

Un sottoinsieme delle funzioni che gestiscono stringhe può funzionare anche su input Char.

• Per gli alfabeti appropriati, cambia maiuscole e minuscole con uppercase() e lowercase().
• Verifica maiuscole e minuscole con isuppercase() e islowercase().
• Verifica il tipo di carattere con:
  • isletter(), copre molti alfabeti
  • isdigit(), verifica rigorosamente 0:9
  • isnumeric(), più ampia di isdigit: restituisce true per ¾ e per varie scritture non europee
  • isxdigit(), cifre esadecimali
  • isascii(), carattere pre-Unicode
  • ispunct(), punteggiatura
  • isspace(), qualsiasi carattere di spazio bianco
  • isprint(), caratteri stampabili (l'opposto è iscntrl())

islowercase('A')  # false
uppercase('γ')  # 'Γ': Unicode U+0393 (category Lu: Letter, uppercase)
ispunct('@')  # true
isdigit('A')  # false
isxdigit('A')  # true

Per verificare se un carattere è presente in una stringa, abbiamo in. Nota che questo è diverso dalle sottostringhe:

# char search
julia> 'a' ∈ "xabcahliazlnkiw"
true

# substring search
julia> "a" ∈ "xabcahliazlnkiw"
use occursin(needle, haystack) for string containment

Inoltre, le espressioni regolari (argomento di un altro concetto) consentono ricerche e manipolazioni potenti.

Conversioni tra vettori di Char e stringhe

Per passare da una stringa a un vettore di Char, possiamo usare collect().

Per passare da un vettore di Char a una stringa, c'è il costruttore String().

julia> s = "abcde"
"abcde"

julia> cv = collect(s)
5-element Vector{Char}:
 'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
 'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)

julia> String(cv)
"abcde"

Funziona con qualsiasi carattere, non solo con l'ASCII.

julia> collect("❤,😱")
3-element Vector{Char}:
 '❤': Unicode U+2764 (category So: Symbol, other)
 ',': ASCII/Unicode U+002C (category Po: Punctuation, other)
 '😱': Unicode U+1F631 (category So: Symbol, other)

Nota che il costruttore String() opera su un Vector. Per fare il cast di un singolo Char a una stringa di 1 carattere, la funzione è string(), con la s minuscola.

julia> string('a')
"a"

Memorizzazione

Tutto ciò che abbiamo visto finora nel documento sembra relativamente semplice: quindi non c'è poi molto di cui preoccuparsi?

Purtroppo, è troppo ottimistico!

Una complicazione deriva dalla necessità di «fino a» 6 cifre esadecimali per code point. Questo significa che caratteri diversi richiedono quantità diverse di spazio in memoria quando sono codificati in UTF-8.

Un byte può memorizzare solo numeri (senza segno) fino a 255, due cifre esadecimali, quindi UTF-8 usa un numero variabile di byte (da 1 a 4) per memorizzare un Char. Questi sono chiamati «code unit», e la funzione ncodeunits() restituisce il numero necessario per un dato carattere.

julia> codepoint(jha)  # jha 'झ' is defined in an earlier example
0x0000091d

julia> ncodeunits(jha)
3

julia> ncodeunits('a')  # ASCII character
1

julia> ncodeunits('😱')  # emoji
4

Inoltre, non tutto ciò che può essere mostrato sullo schermo ha un proprio code point univoco. Alcuni caratteri visivamente distinti sono considerati derivati da altri, quindi Unicode li tratta come un carattere padre più un modificatore.