Julia Language
stringhe

Sintassi

• "[stringa]"
• "[Valore scalare Unicode]"
• grafemi ([string])

Parametri

Ciao mondo!

Le stringhe in Julia sono delimitate usando il " simbolo:

julia> mystring = "Hello, World!"
"Hello, World!"

Nota che a differenza di altre lingue, il simbolo ' non può essere usato al suo posto. ' definisce un carattere letterale ; questo è un tipo di dati Char e memorizzerà solo un singolo valore scalare Unicode :

julia> 'c'
'c'

julia> 'character'
ERROR: syntax: invalid character literal

Si può estrarre i valori scalari Unicode da una stringa ripetendo su di esso con un ciclo for :

julia> for c in "Hello, World!"
           println(c)
       end
H
e
l
l
o
,
 
W
o
r
l
d
!

grafemi

Il tipo Char di Julia rappresenta un valore scalare Unicode , che solo in alcuni casi corrisponde a quello che l'uomo percepisce come un "personaggio". Ad esempio, una rappresentazione del carattere é, come in curriculum, è in realtà una combinazione di due valori scalari Unicode:

julia> collect("é")
2-element Array{Char,1}:
 'e'
 '́'

Le descrizioni Unicode per questi codepoint sono "LATIN SMALL LETTER E" e "COMBINING ACUTE ACCENT". Insieme, definiscono un singolo carattere "umano", che è un termine Unicode chiamato grafo . Più specificamente, Unicode Annex # 29 motiva la definizione di un cluster grapheme perché:

È importante riconoscere che ciò che l'utente pensa come "personaggio" - un'unità di base di un sistema di scrittura per una lingua - potrebbe non essere solo un singolo punto di codice Unicode. Invece, quell'unità di base può essere composta da più punti di codice Unicode. Per evitare l'ambiguità con l'uso del termine del carattere da parte del computer, questo è chiamato carattere percepito dall'utente. Ad esempio, "G" + accento acuto è un personaggio percepito dall'utente: gli utenti lo considerano come un singolo carattere, ma in realtà è rappresentato da due punti di codice Unicode. Questi caratteri percepiti dall'utente sono approssimati da quello che viene chiamato un grafo grapheme, che può essere determinato a livello di codice.

Julia fornisce la funzione graphemes per scorrere i grapheme cluster in una stringa:

julia> for c in graphemes("résumé")
           println(c)
       end
r
é
s
u
m
é

Nota come il risultato, stampando ogni carattere sulla sua stessa riga, è migliore rispetto a se avessimo eseguito un'iterazione sui valori scalari Unicode:

julia> for c in "résumé"
           println(c)
       end
r
e

s
u
m
e

In genere, quando si lavora con i caratteri in un senso percepito dall'utente, è più utile trattare con grapheme cluster rispetto ai valori scalari Unicode. Ad esempio, supponiamo di voler scrivere una funzione per calcolare la lunghezza di una singola parola. Una soluzione ingenua sarebbe da usare

julia> wordlength(word) = length(word)
wordlength (generic function with 1 method)

Notiamo che il risultato è contro-intuitivo quando la parola include grapheme cluster costituiti da più di un punto di codice:

julia> wordlength("résumé")
8

Quando usiamo la definizione più corretta, usando la funzione graphemes , otteniamo il risultato atteso:

julia> wordlength(word) = length(graphemes(word))
wordlength (generic function with 1 method)

julia> wordlength("résumé")
6

Converti tipi numerici in stringhe

Esistono numerosi modi per convertire i tipi numerici in stringhe in Julia:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

La funzione string() può anche richiedere più argomenti:

julia> string(a, "b")
"123b"

Puoi anche inserire (anche interpolare) interi (e certi altri tipi) in stringhe usando $ :

julia> MyString = "my integer is $a"
"my integer is 123"

Suggerimento sulle prestazioni: i metodi sopra riportati possono essere abbastanza convenienti a volte. Ma, se eseguirai molte, molte di queste operazioni e ti preoccupi della velocità di esecuzione del tuo codice, la guida alle prestazioni Julia ti consiglia di non farlo e preferisci i seguenti metodi:

È possibile fornire più argomenti a print() e println() che opereranno su di essi esattamente come string() opera su più argomenti:

julia> println(a, "b")
123b

Oppure, quando si scrive su file, si può usare allo stesso modo, ad es

open("/path/to/MyFile.txt", "w") do file
    println(file, a, "b", 13)
end

o

file = open("/path/to/MyFile.txt", "a")
println(file, a, "b", 13)
close(file)

Questi sono più veloci perché evitano di dover prima formare una stringa da pezzi dati e poi inviarli (sia al display della console o a un file) e invece solo in uscita sequenzialmente i vari pezzi.

Crediti: risposta basata su SO Domanda Qual è il modo migliore per convertire un Int in una stringa in Julia? con risposta di Michael Ohlrogge e input di Fengyang Wang

Interpolazione stringa (inserire il valore definito dalla variabile nella stringa)

In Julia, come in molti altri linguaggi, è possibile interpolare inserendo valori definiti da variabili in stringhe. Per un semplice esempio:

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

Possiamo usare altri tipi oltre al numerico, ad es

Result = false
julia> println("test results is $Result")
test results is false

È possibile avere più interpolazioni all'interno di una determinata stringa:

MySubStr = "a32"
MyNum = 123.31
println("$MySubStr  ,   $MyNum")

Prestazioni Suggerimento L' interpolazione è abbastanza comoda. Ma, se lo farai molte volte molto rapidamente, non è il più efficiente. Invece, vedi Converti tipi numerici in stringhe per suggerimenti quando la prestazione è un problema.

Utilizzare sprint per creare stringhe con funzioni IO

Le stringhe possono essere create da funzioni che funzionano con oggetti IO utilizzando la funzione sprint . Ad esempio, la funzione code_llvm accetta un oggetto IO come primo argomento. In genere, è usato come

julia> code_llvm(STDOUT, *, (Int, Int))

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

Supponiamo di volere quell'output come una stringa. Quindi possiamo semplicemente farlo

julia> sprint(code_llvm, *, (Int, Int))
"\ndefine i64 @\"jlsys_*_46115\"(i64, i64) #0 {\ntop:\n  %2 = mul i64 %1, %0\n  ret i64 %2\n}\n"

julia> println(ans)

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

La conversione dei risultati di funzioni "interattive" come code_llvm in stringhe può essere utile per l'analisi automatica, ad esempio per verificare se il codice generato potrebbe essere regredito.

La funzione sprint è una funzione di ordine superiore che considera la funzione che opera su oggetti IO come primo argomento. Dietro le quinte, crea un IOBuffer nella RAM, chiama la funzione data e prende i dati dal buffer in un oggetto String .