Opérateurs Logiques

Opérateur ET Logique (&&)

L'opérateur ET logique (&&) évalue à true si toutes les expressions booléennes qu'il combine sont true. Si une des expressions est false, le résultat est false.

Syntaxe :

let result = expression1 && expression2

Exemple :

let a = 10
let b = 20
let result = (a > 5) && (b < 25)  // result est true

• (a > 5) est true
• (b < 25) est true
• Donc, result est true

Opérateur OU Logique (||)

L'opérateur OU logique (||) évalue à true si au moins une des expressions booléennes qu'il combine est true. Le résultat est false seulement si toutes les expressions sont false.

Syntaxe :

let result = expression1 || expression2

Exemple :

let a = 10
let b = 30
let result = (a > 5) || (b < 25)  // result est true

• (a > 5) est true
• (b < 25) est false
• Donc, result est true

Opérateur NON Logique (!)

L'opérateur NON logique (!) inverse la valeur d'une expression booléenne. Si l'expression est true, le résultat sera false, et vice versa.

Syntaxe :

let result = !expression

Exemple :

let isSunny = true
let isNotSunny = !isSunny  // isNotSunny est false

• isSunny est true
• Donc, isNotSunny est false

Opérateur de Conjonction Logique (&&) - Évaluation Paresseuse

En Swift, l'opérateur && utilise une évaluation paresseuse (ou évaluation à court-circuit). Cela signifie que si la première expression est false, la deuxième expression ne sera pas évaluée, car le résultat global est déjà déterminé comme étant false.

Exemple :

func checkA() -> Bool {
    print("Checking A")
    return false
}
func checkB() -> Bool {
    print("Checking B")
    return true
}
let result = checkA() && checkB()
// Affiche : "Checking A"
// `checkB` n'est pas appelé car `checkA` est déjà `false`

Opérateur de Disjonction Logique (||) - Évaluation Paresseuse

L'opérateur || utilise également une évaluation paresseuse. Si la première expression est true, la deuxième expression ne sera pas évaluée, car le résultat global est déjà déterminé comme étant true.

Exemple :

func checkX() -> Bool {
    print("Checking X")
    return true
}
func checkY() -> Bool {
    print("Checking Y")
    return false
}
let result = checkX() || checkY()
// Affiche : "Checking X"
// `checkY` n'est pas appelé car `checkX` est déjà `true`

Utilisation des Opérateurs Logiques dans des Conditions

Les opérateurs logiques sont souvent utilisés dans des structures de contrôle comme if, while, et for pour combiner plusieurs conditions.

Exemple avec if :

let age = 20
let hasTicket = true
if age >= 18 && hasTicket {
    print("Vous pouvez entrer.")
} else {
    print("Accès refusé.")
}

Points Clés à Retenir

• L'opérateur ET logique (&&) évalue à true seulement si toutes les expressions sont true.
• L'opérateur OU logique (||) évalue à true si au moins une des expressions est true.
• L'opérateur NON logique (!) inverse la valeur de l'expression booléenne.
• Les opérateurs logiques utilisent une évaluation paresseuse, ce qui signifie que l'évaluation des expressions est arrêtée dès que le résultat global est déterminé.
• Les opérateurs logiques sont essentiels pour créer des conditions complexes et pour contrôler le flux du programme.