Julia Language
Condizionali

Sintassi

• se cond; corpo; fine
• se cond; corpo; altro; corpo; fine
• se cond; corpo; elseif cond; corpo; altro; fine
• se cond; corpo; elseif cond; corpo; fine
• cond? iftrue: iffalse
• cond && iftrue
• cond || iffalse
• ifelse (cond, iftrue, iffalse)

Osservazioni

se ... altra espressione

Il condizionale più comune in Julia è l'espressione if ... else . Ad esempio, di seguito implementiamo l' algoritmo Euclideo per calcolare il massimo comun divisore , usando un condizionale per gestire il caso base:

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

La forma if ... else in Julia è in realtà un'espressione e ha un valore; il valore è l'espressione in posizione di coda (ovvero l'ultima espressione) sul ramo che viene preso. Considera il seguente esempio di input:

julia> mygcd(0, -10)
10

Qui, a è 0 e b è -10 . La condizione a == 0 è true , quindi viene preso il primo ramo. Il valore restituito è abs(b) che è 10 .

julia> mygcd(2, 3)
1

Qui, a è 2 e b è 3 . La condizione a == 0 è falsa, quindi viene preso il secondo ramo e calcoliamo mygcd(b % a, a) , che è mygcd(3 % 2, 2) . L'operatore % restituisce il resto quando 3 è diviso per 2 , in questo caso 1 . Quindi calcoliamo mygcd(1, 2) , e questa volta a è 1 b è 2 . Ancora una volta, a == 0 è falso, quindi viene preso il secondo ramo e calcoliamo mygcd(b % a, a) , che è mygcd(0, 1) . Questa volta, a == 0 , infine, viene restituito abs(b) , che fornisce il risultato 1 .

se ... altra affermazione

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

Qualsiasi espressione, come l'espressione if ... else , può essere posta in posizione statement. Questo ignora il suo valore ma esegue comunque l'espressione per i suoi effetti collaterali.

se la dichiarazione

Come qualsiasi altra espressione, il valore di ritorno di una espressione if ... else può essere ignorato (e quindi scartato). Ciò è generalmente utile solo quando il corpo dell'espressione ha effetti collaterali, come la scrittura su un file, la modifica di variabili o la stampa sullo schermo.

Inoltre, l' else ramo di un if ... else espressione è opzionale. Ad esempio, possiamo scrivere il seguente codice per l'output sullo schermo solo se viene soddisfatta una particolare condizione:

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

Nell'esempio sopra, usiamo le funzioni di data e ora per ottenere il secondo corrente; per esempio, se è attualmente alle 10:55:27, la second variabile avrà 27 . Se questo numero è pari, verrà stampata una riga sullo schermo. Altrimenti, non sarà fatto nulla.

Operatore condizionale ternario

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

L'operatore condizionale ternario è un'espressione meno verbale if ... else .

La sintassi nello specifico è:

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

In questo esempio, aggiungiamo x alla raccolta A solo se x non è già in A Altrimenti, lasciamo invariato A

Referenze operatore ternario:

• Documentazione di Julia
• Wikibooks

Operatori di cortocircuito: && e ||

Per la ramificazione

Gli operatori condizionali di cortocircuito && e || può essere usato come sostituto leggero per i seguenti costrutti:

• x && y è equivalente a x ? y : x
• x || y è equivalente a x ? x : y

Un uso per gli operatori di cortocircuito è un modo più conciso per testare una condizione ed eseguire una determinata azione a seconda di tale condizione. Ad esempio, il codice seguente utilizza l'operatore && per generare un errore se l'argomento x è negativo:

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

|| l'operatore può essere utilizzato anche per il controllo degli errori, tranne per il fatto che attiva l'errore a meno che una condizione non mantenga, invece che se la condizione contenga:

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

Un'altra utile applicazione è fornire un valore predefinito a un oggetto, solo se non è stato precedentemente definito:

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

Qui, controlla se il simbolo x è definito (cioè se c'è un valore assegnato all'oggetto x ). Se è così, allora non succede niente. Ma, in caso contrario, x verrà assegnato NEW_VALUE . Nota che questo esempio funzionerà solo in ambito Toplevel.

In condizioni

Gli operatori sono anche utili perché possono essere utilizzati per testare due condizioni, la seconda delle quali viene valutata solo in base al risultato della prima condizione. Dalla documentazione di Julia:

Nell'espressione a && b , la sottoespressione b viene valutato solo se a viene valutato come true

Nell'espressione a || b , la sottoespressione b viene valutata solo se a valuta è false

Quindi, mentre sia a & b che a && b daranno true se entrambi a e b sono true , il loro comportamento se a è false è diverso.

Ad esempio, supponiamo di voler verificare se un oggetto è un numero positivo, dove è possibile che non sia nemmeno un numero. Considera le differenze tra queste due implementazioni tentate:

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

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

CheckPositive1() genererà un errore se un tipo non numerico viene fornito come argomento. Questo perché valuta entrambe le espressioni, indipendentemente dal risultato del primo, e la seconda espressione produrrà un errore quando si tenta di valutarlo per un tipo non numerico.

CheckPositive2() , tuttavia, restituirà false (piuttosto che un errore) se viene fornito un tipo non numerico, poiché la seconda espressione viene valutata solo se la prima è true .

Più di un operatore di cortocircuito può essere messo insieme. Per esempio:

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

se dichiarazione con più rami

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

Qualsiasi numero di elseif rami può essere utilizzato con un if dichiarazione, possibilmente con o senza finale else ramo. Le condizioni successive saranno valutate solo se tutte le condizioni precedenti sono risultate false .

La funzione ifelse

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

Uso:

julia> shift(10)
9

julia> shift(11)
12

julia> shift(-1)
-2

La funzione ifelse valuterà entrambi i rami, anche quello che non è selezionato. Questo può essere utile quando i rami hanno effetti collaterali che devono essere valutati, o perché può essere più veloce se entrambi i rami stessi sono economici.