Julia Language
Conditionnels

Syntaxe

• si cond; corps; fin
• si cond; corps; autre; corps; fin
• si cond; corps; sinon, cond. corps; autre; fin
• si cond; corps; sinon, cond. corps; fin
• cond? Iftrue: iffalse
• cond && iftrue
• cond || iffalse
• ifelse (cond, iftrue, iffalse)

Remarques

if ... else expression

Le conditionnel le plus courant dans Julia est l'expression if ... else . Par exemple, nous implémentons ci-dessous l' algorithme euclidien pour calculer le plus grand commun diviseur , en utilisant un conditionnel pour gérer le cas de base:

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

La forme if ... else de Julia est en réalité une expression et a une valeur; la valeur est l'expression en position de queue (c'est-à-dire la dernière expression) sur la branche qui est prise. Considérez l'exemple d'entrée suivant:

julia> mygcd(0, -10)
10

Ici, a est 0 et b est -10 . La condition a == 0 est true , donc la première branche est prise. La valeur renvoyée est abs(b) qui est 10 .

julia> mygcd(2, 3)
1

Ici, a est 2 et b est 3 . La condition a == 0 est fausse, donc la deuxième branche est prise, et nous calculons mygcd(b % a, a) , qui est mygcd(3 % 2, 2) . L'opérateur % renvoie le reste lorsque 3 est divisé par 2 , dans ce cas 1 . On calcule donc mygcd(1, 2) , et cette fois a est 1 et b est 2 . Encore une fois, a == 0 est faux, donc la deuxième branche est prise et nous calculons mygcd(b % a, a) , qui est mygcd(0, 1) . Cette fois, a == 0 enfin et ainsi abs(b) est retourné, ce qui donne le résultat 1 .

if ... statement autre

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

Toute expression, telle que l'expression if ... else , peut être placée dans la position de l'instruction. Cela ignore sa valeur mais exécute toujours l'expression pour ses effets secondaires.

si déclaration

Comme toute autre expression, la valeur de retour d'une expression if ... else peut être ignorée (et donc supprimée). Cela n'est généralement utile que lorsque le corps de l'expression a des effets secondaires, tels que l'écriture dans un fichier, la modification de variables ou l'impression sur l'écran.

De plus, la branche else d'une expression if ... else est facultative. Par exemple, nous pouvons écrire le code suivant en sortie à l'écran uniquement si une condition particulière est remplie:

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

Dans l'exemple ci-dessus, nous utilisons les fonctions de date et heure pour obtenir la seconde courante; Par exemple, si elle est actuellement à 10:55:27, la second variable contiendra 27 . Si ce nombre est pair, une ligne sera imprimée à l'écran. Sinon, rien ne sera fait.

Opérateur conditionnel ternaire

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

L'opérateur conditionnel ternaire est une expression moins verbeuse if ... else .

La syntaxe est spécifiquement:

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

Dans cet exemple, nous ajoutons x à la collection A uniquement si x n'est pas déjà dans A Sinon, nous ne faisons que laisser A inchangé.

Opérateur ternaire Références:

• Julia Documentation
• Wikibooks

Les opérateurs de court-circuit: && et ||

Pour branchement

Les opérateurs conditionnels en court-circuit && et || peut être utilisé comme remplacement léger pour les constructions suivantes:

• x && y est équivalent à x ? y : x
• x || y est équivalent à x ? x : y

Une des utilisations des opérateurs de court-circuit consiste à tester de manière plus concise une condition et à effectuer une action spécifique en fonction de cette condition. Par exemple, le code suivant utilise l'opérateur && pour générer une erreur si l'argument x est négatif:

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

Le || L'opérateur peut également être utilisé pour vérifier les erreurs, sauf qu'il déclenche l'erreur à moins qu'une condition ne soit remplie, au lieu de si la condition est remplie:

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

Une autre application utile consiste à fournir une valeur par défaut à un objet, uniquement s'il n'est pas défini précédemment:

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

Ici, cela vérifie si le symbole x est défini (c'est-à-dire s'il y a une valeur affectée à l'objet x ). Si oui, alors rien ne se passe. Mais sinon, x sera assigné à NEW_VALUE . Notez que cet exemple ne fonctionnera que sur la portée de haut niveau.

Dans des conditions

Les opérateurs sont également utiles car ils peuvent être utilisés pour tester deux conditions dont la seconde n'est évaluée qu'en fonction du résultat de la première condition. De la documentation Julia:

Dans l'expression a && b , la sous-expression b n'est évaluée que si a évaluée à true

Dans l'expression a || b , la sous-expression b n'est évaluée que si a évalué comme false

Ainsi, alors que a & b et a && b donneront la valeur true si a et b sont tous deux true , leur comportement si a est false est différent.

Par exemple, supposons que nous souhaitons vérifier si un objet est un nombre positif, où il est possible que ce ne soit même pas un nombre. Considérons les différences entre ces deux implémentations tentées:

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

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

CheckPositive1() produira une erreur si un type non numérique lui est fourni en tant qu'argument. En effet, il évalue les deux expressions, quel que soit le résultat du premier, et la seconde expression génère une erreur lorsque l'on essaie de l'évaluer pour un type non numérique.

CheckPositive2() , cependant, donnera un résultat false (plutôt qu'une erreur) si un type non numérique lui est fourni, car la seconde expression n'est évaluée que si la première est true .

Plus d'un opérateur de court-circuit peut être branché ensemble. Par exemple:

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

si déclaration avec plusieurs 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

Un nombre quelconque de elseif branches peut être utilisé avec une if déclaration, peut - être avec ou sans une finale d' else branche. Les conditions ultérieures ne seront évaluées que si toutes les conditions antérieures se sont révélées false .

La fonction ifelse

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

Usage:

julia> shift(10)
9

julia> shift(11)
12

julia> shift(-1)
-2

La fonction ifelse évalue les deux branches, même celle qui n’est pas sélectionnée. Cela peut être utile lorsque les branches ont des effets secondaires à évaluer ou parce que les deux branches elles-mêmes sont moins chères.