Julia Language
strings

Syntaxis

• "[draad]"
• '[Unicode scalaire waarde]'
• grafemen ([tekenreeks])

parameters

Hallo Wereld!

Tekenreeksen in Julia worden gescheiden met het symbool " :

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

Merk op dat in tegenstelling tot sommige andere talen het symbool ' niet kan worden gebruikt. ' definieert een letterlijk karakter ; dit is een Char gegevenstype en slaat slechts één Unicode-scalaire waarde op :

julia> 'c'
'c'

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

Men kan de unicode scalaire waarden uit een string extraheren door er met een for lus overheen for :

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

grafemen

Julia's Char type vertegenwoordigt een Unicode-scalaire waarde , die alleen in sommige gevallen overeenkomt met wat mensen als een "karakter" beschouwen. Een representatie van het karakter é, zoals in CV, is bijvoorbeeld eigenlijk een combinatie van twee Unicode-scalaire waarden:

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

De Unicode-beschrijvingen voor deze codepunten zijn "LATIJNS KLEINE BRIEF E" en "ACUTE ACCENT COMBINEREN". Samen definiëren ze een enkel "menselijk" karakter, wat Unicode-termen wordt genoemd een grapheme . Meer specifiek motiveert Unicode Annex # 29 de definitie van een grapheme cluster omdat:

Het is belangrijk om te erkennen dat wat de gebruiker als een 'teken' beschouwt - een basiseenheid van een schrijfsysteem voor een taal - mogelijk niet slechts één Unicode-codepunt is. In plaats daarvan kan die basiseenheid bestaan uit meerdere Unicode-codepunten. Om dubbelzinnigheid bij het computergebruik van de term karakter te voorkomen, wordt dit een door de gebruiker waargenomen karakter genoemd. Bijvoorbeeld, "G" + acuut-accent is een door de gebruiker waargenomen karakter: gebruikers beschouwen het als een enkel karakter, maar worden toch voorgesteld door twee Unicode-codepunten. Deze door de gebruiker waargenomen tekens worden benaderd door een zogenaamd grapheme-cluster, dat programmatisch kan worden bepaald.

Julia biedt de graphemes functioneren te herhalen over de grapheme clusters in een string:

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

Merk op hoe het resultaat, het afdrukken van elk teken op zijn eigen regel, beter is dan als we de scalaire waarden van Unicode hadden herhaald:

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

s
u
m
e

Wanneer u met tekens werkt die door de gebruiker worden waargenomen, is het meestal handiger om met grafeme-clusters om te gaan dan met scalaire waarden van Unicode. Stel bijvoorbeeld dat we een functie willen schrijven om de lengte van een enkel woord te berekenen. Een naïeve oplossing zou zijn om te gebruiken

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

We merken op dat het resultaat contra-intuïtief is wanneer het woord grapheme-clusters bevat die uit meer dan één codepunt bestaan:

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

Wanneer we de meer correcte definitie gebruiken, met behulp van de functie graphemes , krijgen we het verwachte resultaat:

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

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

Numerieke typen converteren naar tekenreeksen

Er zijn talloze manieren om numerieke typen om te zetten in tekenreeksen in Julia:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

De functie string() kan ook meer argumenten aannemen:

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

U kunt ook gehele getallen (of interpoleren) gehele getallen (en bepaalde andere typen) in strings invoegen met $ :

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

Prestatietip: de bovenstaande methoden kunnen soms erg handig zijn. Maar als u veel, veel van dergelijke bewerkingen gaat uitvoeren en u zich zorgen maakt over de snelheid van uitvoering van uw code, beveelt de Julia- prestatiegids dit af, en in plaats daarvan voor de onderstaande methoden:

U kunt meerdere argumenten println() voor print() en println() die precies zo werken als string() op meerdere argumenten werkt:

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

Of, wanneer u naar een bestand schrijft, kunt u op dezelfde manier bijv

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

of

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

Deze zijn sneller omdat ze vermijden dat ze eerst een string moeten vormen uit bepaalde stukken en deze vervolgens moeten uitvoeren (naar het consolescherm of een bestand) en in plaats daarvan gewoon opeenvolgend de verschillende stukken uitvoeren.

Credits: Antwoord op basis van SO Vraag Wat is de beste manier om een Int naar een String in Julia te converteren? met antwoord van Michael Ohlrogge en inbreng van Fengyang Wang

Stringinterpolatie (waarde door variabele in string ingevoegd)

In Julia is het, net als in veel andere talen, mogelijk om te interpoleren door waarden die door variabelen zijn gedefinieerd in strings in te voegen. Voor een eenvoudig voorbeeld:

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

We kunnen andere typen dan numerieke gebruiken, bijv

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

U kunt meerdere interpolaties binnen een gegeven string hebben:

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

Prestatietip Interpolatie is heel handig. Maar als je het vele malen heel snel gaat doen, is het niet de meest efficiënte. Zie in plaats daarvan Numerieke typen converteren naar tekenreeksen voor suggesties wanneer prestaties een probleem vormen.

Sprint gebruiken om tekenreeksen te maken met IO-functies

Strings kunnen worden gemaakt van functies die werken met IO objecten met behulp van de sprint . De functie code_llvm accepteert bijvoorbeeld een IO object als het eerste argument. Meestal wordt het gebruikt als

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

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

Stel dat we die uitvoer in plaats daarvan als een string willen. Dan kunnen we het gewoon doen

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
}

Het omzetten van de resultaten van "interactieve" functies zoals code_llvm in tekenreeksen kan nuttig zijn voor geautomatiseerde analyse, zoals het testen of gegenereerde code mogelijk is teruggevallen.

De sprint is een functie van hogere orde die de functie die op IO objecten werkt als eerste argument neemt. Achter de schermen maakt het een IOBuffer in RAM, roept de gegeven functie aan en neemt de gegevens van de buffer op in een String object.