Julia Language
strängar

Syntax

• "[sträng]"
• '[Unicode-skalvärde]'
• grafem ([sträng])

parametrar

Hej världen!

Strängar i Julia avgränsas med " symbolen:

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

Observera att till skillnad från vissa andra språk, den ' symbolen kan inte användas i stället. ' Definierar en karaktär bokstavlig; detta är en Char datatyp och lagrar endast ett enda Unicode-skalvärde :

julia> 'c'
'c'

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

Man kan extrahera unicode-skalvärden från en sträng genom att iterera över den med en for loop :

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

grafem

Julias Char typ representerar ett skalvärde från Unicode , som bara i vissa fall motsvarar vad människor uppfattar som en "karaktär". Till exempel är en representation av karaktären é, som i cv, faktiskt en kombination av två Unicode-skalvärden:

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

Unicode-beskrivningarna för dessa kodpunkter är "LATIN SMALL LETTER E" och "COMBINING ACUTE ACCENT". Tillsammans definierar de en enda "mänsklig" karaktär, som är Unicode-termer kallas ett diagram . Mer specifikt motiverar Unicode bilaga # 29 definitionen av ett grafeme-kluster eftersom:

Det är viktigt att inse att användaren tänker som en "karaktär" - en basenhet i ett skrivsystem för ett språk - inte bara är en enda Unicode-kodpunkt. Istället kan den basenheten bestå av flera Unicode-kodpunkter. För att undvika tvetydighet med datorns användning av termen karaktär kallas detta ett användaruppfattat tecken. Till exempel är "G" + akut-accent ett användaruppfattat tecken: användare tänker på det som ett enda tecken, men representeras faktiskt av två Unicode-kodpunkter. Dessa användaruppfattade tecken är ungefärliga av det som kallas ett grafeme-kluster, som kan bestämmas programmatiskt.

Julia tillhandahåller graphemes att iterera över grafemkluster i en sträng:

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

Lägg märke till hur resultatet, att skriva ut varje tecken på sin egen rad, är bättre än om vi hade itererat över skalvärdena Unicode:

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

s
u
m
e

Typiskt, när man arbetar med tecken i en användaruppfattad mening, är det mer användbart att hantera grafeme-kluster än med Unicode-skalvärden. Anta till exempel att vi vill skriva en funktion för att beräkna längden på ett enda ord. En naiv lösning skulle vara att använda

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

Vi noterar att resultatet är motintuitivt när ordet innehåller grafeme-kluster som består av mer än ett kodpunkt:

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

När vi använder den mer korrekta definitionen med graphemes får vi det förväntade resultatet:

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

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

Konvertera numeriska typer till strängar

Det finns många sätt att konvertera numeriska typer till strängar i Julia:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

string() -funktionen kan också ta fler argument:

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

Du kan också infoga (aka interpolera) heltal (och vissa andra typer) i strängar med $ :

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

Prestandatips: Ovanstående metoder kan vara ganska praktiska ibland. Men om du kommer att utföra många, många sådana operationer och du är bekymrad över körhastigheten för din kod, rekommenderar Julia- prestationsguiden detta, och istället för följande metoder:

Du kan tillhandahålla flera argument för att print() och println() som fungerar på dem exakt som string() fungerar på flera argument:

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

Eller när du skriver till fil kan du på liknande sätt använda t.ex.

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

eller

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

Dessa är snabbare eftersom de undviker att först behöva bilda en sträng från givna bitar och sedan mata ut den (antingen till konsolskärmen eller en fil) och istället bara skriva ut de olika delarna i följd.

Krediter: Svar baserat på SO-fråga Vad är det bästa sättet att konvertera en Int till en sträng i Julia? med svar av Michael Ohlrogge och Input från Fengyang Wang

Stränginterpolering (infoga värde definierat av variabel i sträng)

I Julia, som på många andra språk, är det möjligt att interpolera genom att infoga värden definierade av variabler i strängar. För ett enkelt exempel:

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

Vi kan använda andra typer än numeriska, t.ex.

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

Du kan ha flera interpolationer i en given sträng:

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

Prestanda Tip Interpolation är ganska bekvämt. Men om du kommer att göra det många gånger mycket snabbt är det inte det mest effektiva. Se i stället Konvertera numeriska typer till strängar för förslag när prestanda är ett problem.

Använda sprint för att skapa strängar med IO-funktioner

Strängar kan göras från funktioner som fungerar med IO objekt med hjälp av sprint . Exempelvis accepterar code_llvm funktionen ett IO objekt som det första argumentet. Vanligtvis används det som

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

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

Anta att vi vill ha den utgången som en sträng istället. Då kan vi helt enkelt göra det

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
}

Att konvertera resultaten från "interaktiva" funktioner som code_llvm till strängar kan vara användbart för automatiserad analys, till exempel att testa om genererad kod kan ha regresserat.

sprint är en högre ordningsfunktion som tar funktionen som fungerar på IO objekt som sitt första argument. Bakom kulisserna skapar det en IOBuffer i RAM, kallar den givna funktionen och tar data från bufferten till ett String objekt.