Julia Language
Voorwaardelijke

Syntaxis

• als cond; lichaam; einde
• als cond; lichaam; anders; lichaam; einde
• als cond; lichaam; anders cond; lichaam; anders; einde
• als cond; lichaam; anders cond; lichaam; einde
• cond? iftrue: iffalse
• cond && iftrue
• cond || iffalse
• ifelse (cond, iftrue, iffalse)

Opmerkingen

als ... anders expressie

De meest voorkomende voorwaardelijke in Julia is de uitdrukking if ... else . Hieronder implementeren we bijvoorbeeld het Euclidische algoritme voor het berekenen van de grootste gemene deler , met behulp van een voorwaardelijk om het basisgeval te behandelen:

mygcd(a, b) = if a == 0
    abs(b)
else
    mygcd(b % a, a)
end

De if ... else vorm in Julia is eigenlijk een uitdrukking en heeft een waarde; de waarde is de uitdrukking in staartpositie (dat wil zeggen de laatste uitdrukking) op de vertakte tak. Overweeg de volgende voorbeeldinvoer:

julia> mygcd(0, -10)
10

Hier is a 0 en b is -10 . De voorwaarde a == 0 is true , dus de eerste tak wordt genomen. De geretourneerde waarde is abs(b) wat 10 .

julia> mygcd(2, 3)
1

Hier is a 2 en b 3 . De voorwaarde a == 0 is onwaar, dus de tweede tak wordt genomen en we berekenen mygcd(b % a, a) , wat mygcd(3 % 2, 2) . De operator % retourneert de rest wanneer 3 wordt gedeeld door 2 , in dit geval 1 . Dus berekenen we mygcd(1, 2) , en deze keer is a 1 en b is 2 . Nogmaals, a == 0 is onwaar, dus de tweede tak wordt genomen, en we berekenen mygcd(b % a, a) , wat mygcd(0, 1) . Deze keer is eindelijk a == 0 en dus wordt abs(b) geretourneerd, wat het resultaat 1 .

als ... anders statement

name = readline()
if startswith(name, "A")
    println("Your name begins with A.")
else
    println("Your name does not begin with A.")
end

Elke expressie, zoals de if ... else expressie, kan in statement-positie worden geplaatst. Dit negeert de waarde ervan, maar voert toch de uitdrukking voor zijn bijwerkingen uit.

als verklaring

Net als elke andere expressie kan de retourwaarde van een if ... else expressie worden genegeerd (en dus worden genegeerd). Dit is over het algemeen alleen nuttig wanneer de hoofdtekst van de uitdrukking bijwerkingen heeft, zoals schrijven naar een bestand, variabelen muteren of afdrukken naar het scherm.

Verder is de else tak van een if ... else expressie optioneel. We kunnen bijvoorbeeld de volgende code schrijven om naar het scherm uit te voeren als aan een bepaalde voorwaarde is voldaan:

second = Dates.second(now())
if iseven(second)
    println("The current second, $second, is even.")
end

In het bovenstaande voorbeeld gebruiken we tijd- en datumfuncties om de huidige seconde te krijgen; bijvoorbeeld, als het momenteel 10:55:27 is, heeft de variabele second 27 . Als dit nummer even is, wordt er een lijn naar het scherm afgedrukt. Anders wordt er niets gedaan.

Ternary voorwaardelijke operator

pushunique!(A, x) = x in A ? A : push!(A, x)

De ternaire voorwaardelijke operator is een minder woordachtige uitdrukking if ... else expressie.

De syntaxis is specifiek:

[condition] ? [execute if true] : [execute if false]

In dit voorbeeld voegen we x alleen toe aan de verzameling A als x nog niet in A . Anders laten we A gewoon ongewijzigd.

Ternary operator Referenties:

• Julia Documentatie
• Wikibooks

Kortsluitingsexploitanten: && en ||

Voor vertakking

De kortsluitende voorwaardelijke operatoren && en || kan worden gebruikt als lichtgewicht vervangingen voor de volgende constructies:

• x && y is gelijk aan x ? y : x
• x || y is gelijk aan x ? x : y

Eén gebruik voor kortsluitingsexploitanten is als een meer beknopte manier om een voorwaarde te testen en een bepaalde actie uit te voeren, afhankelijk van die voorwaarde. De volgende code gebruikt bijvoorbeeld de operator && om een fout te genereren als het argument x negatief is:

function mysqrt(x)
    x < 0 && throw(DomainError("x is negative"))
    x ^ 0.5
end

De || operator kan ook worden gebruikt voor foutcontrole, behalve dat de fout wordt geactiveerd tenzij een voorwaarde geldt, in plaats van als de voorwaarde geldt:

function halve(x::Integer)
    iseven(x) || throw(DomainError("cannot halve an odd number"))
    x ÷ 2
end

Een andere nuttige toepassing hiervan is om een standaardwaarde aan een object te geven, alleen als het niet eerder is gedefinieerd:

isdefined(:x) || (x = NEW_VALUE)

Hier wordt gecontroleerd of het symbool x is gedefinieerd (dwz of er een waarde is toegewezen aan het object x ). Zo ja, dan gebeurt er niets. Maar als dat niet het geval is, krijgt x NEW_VALUE toegewezen. Merk op dat dit voorbeeld alleen werkt op topniveau.

In omstandigheden

De operatoren zijn ook nuttig omdat ze kunnen worden gebruikt om twee voorwaarden te testen, waarvan de tweede alleen wordt geëvalueerd afhankelijk van het resultaat van de eerste voorwaarde. Uit de Julia- documentatie :

In de uitdrukking a && b wordt de subexpressie b alleen geëvalueerd als a naar true evalueert

In de uitdrukking a || b , de subexpressie b wordt alleen geëvalueerd als a evalueert als false

Terwijl zowel a & b en a && b oplevert true als zowel a en b zijn true hun gedrag als a is false verschilt.

Stel bijvoorbeeld dat we willen controleren of een object een positief getal is, waarbij het mogelijk is dat het niet eens een getal is. Overweeg de verschillen tussen deze twee gepoogde implementaties:

CheckPositive1(x) = (typeof(x)<:Number) & (x > 0) ? true : false
CheckPositive2(x) = (typeof(x)<:Number) && (x > 0) ? true : false

CheckPositive1("a")
CheckPositive2("a")

CheckPositive1() levert een fout op als een niet-numeriek type als argument wordt CheckPositive1() . Dit komt omdat het beide expressies evalueert, ongeacht het resultaat van de eerste, en de tweede expressie een fout oplevert wanneer men probeert deze te evalueren voor een niet-numeriek type.

CheckPositive2() geeft echter false (in plaats van een fout) als er een niet-numeriek type aan wordt geleverd, omdat de tweede expressie alleen wordt geëvalueerd als de eerste true .

Meer dan één kortsluitingsoperator kan aan elkaar worden geregen. bv:

1 > 0 && 2 > 0 && 3 > 5

if statement met meerdere branches

d = Dates.dayofweek(now())
if d == 7
    println("It is Sunday!")
elseif d == 6
    println("It is Saturday!")
elseif d == 5
    println("Almost the weekend!")
else
    println("Not the weekend yet...")
end

Elk aantal elseif takken kan worden gebruikt met een if instructie, mogelijk met of zonder een laatste else tak. Latere voorwaarden worden alleen geëvalueerd als alle eerdere voorwaarden false zijn bevonden.

De ifelse-functie

shift(x) = ifelse(x > 10, x + 1, x - 1)

Gebruik:

julia> shift(10)
9

julia> shift(11)
12

julia> shift(-1)
-2

De ifelse functie zal beide takken evalueren, zelfs degene die niet is geselecteerd. Dit kan handig zijn wanneer de takken bijwerkingen hebben die moeten worden geëvalueerd, of omdat het sneller kan zijn als beide takken zelf goedkoop zijn.