Problème

Sommaire

1 : Opérateurs

2 : Opérateur de fusion de valeur nulle, opérateur de plage

Prérequis

Contanu prinicpal

I : Opérateurs

/*
         Quatre : Opérateurs Swift
         Un opérateur est un symbole qui indique au compilateur d'exécuter une opération mathématique ou logique.
         Swift fournit les types d'opérateurs suivants :
         1 : Opérateurs arithmétiques : + - * / % modulo
         2 : Opérateurs de comparaison : == != > < >= <=
         3 : Opérateurs logiques : && || !
         4 : Opérateurs bit à bit
            & : ET bit à bit : la valeur est 1 si les deux nombres sont 1, sinon 0.
            | : OU bit à bit. La valeur est 1 si l'un des deux nombres est 1.
            ^ : XOR. La valeur est 1 si les deux nombres sont identiques, sinon 0.
            ~ : Inversion.
            << : Décalage vers la gauche. L'opérateur de décalage vers la gauche (<<) déplace tous les bits d'un nombre d'un certain nombre de positions vers la gauche. Décalage vers la gauche : multiplié par 2^n.
            >> : Décalage vers la droite. L'opérateur de décalage vers la droite (>>) déplace tous les bits d'un nombre d'un certain nombre de positions vers la droite. Décalage vers la droite : divisé par 2^n.
         5 : Opérateurs d'affectation
         6 : Opérateurs de plage : opérateur de plage fermée (a...b), opérateur de plage ouverte (a..<5)
         7 : Autres opérateurs
         */
        print("Quatre : Opérateurs Swift :");
        // 1: Opérateurs arithmétiques
        var X = 10
        var Y = 20
        print("X + Y est égal à :\(X + Y)") // 30
        print("X - Y est égal à :\(X - Y)") // -10
        print("X * Y est égal à :\(X * Y)") // 200
        print("Y / X est égal à :\(Y / X)") //2
        X += 1   // Équivalent à X++  11
        print("X += 1 après X est égal à \(X)")
        Y -= 1   // Équivalent à Y--  19
        print("Y -= 1 après Y est égal à $Y)")

        // 2: Opérateurs de comparaison
        print("X == Y est égal à :$X == Y)") // false
        print("X != Y est égal à :$X != Y)") //true
        print("X > Y est égal à :$X > Y)")  //false
        print("X < Y est égal à :$X < Y)")  //true
        print("X >= Y est égal à :$X >= Y)")  //false
        print("X <= Y est égal à :$X <= Y)")  //true

        // 3 : Opérateurs logiques
        let boolX: Bool = true
        let boolY: Bool = false
        print("X && Y est égal à :$boolX && boolY)") // false
        print("X || Y est égal à :$boolX || boolY)") //true
        print("!X est égal à :$!boolX)") //false
        print("!Y est égal à :$!boolY)") //true

        // 4 : Opérateurs de plage
        print("Opérateur de plage fermée :")
        for index in 1...5 {
            print("$index * 5 = $index * 5)")
        }

        print("Opérateur de plage ouverte :")
        for index in 1..<5 {
            print("$index * 5 = $index * 5)")
        }

        print("Quatre : Opérateurs Swift :");

/*
 Quatre : Opérateurs Swift :
 X + Y est égal à :30
 X - Y est égal à :-10
 X * Y est égal à :200
 Y / X est égal à :2
 X += 1 après X est égal à 11
 Y -= 1 après Y est égal à 19
 X == Y est égal à :false
 X != Y est égal à :true
 X > Y est égal à :false
 X < Y est égal à :true
 X >= Y est égal à :false
 X <= Y est égal à :true
 X && Y est égal à :false
 X || Y est égal à :true
 !X est égal à :false
 !Y est égal à :true
 Opérateur de plage fermée :
 1 * 5 = 5
 2 * 5 = 10
 3 * 5 = 15
 4 * 5 = 20
 5 * 5 = 25
 Opérateur de plage ouverte :
 1 * 5 = 5
 2 * 5 = 10
 3 * 5 = 15
 4 * 5 = 20
 Quatre : Opérateurs Swift :
 */

*** Opérateur de fusion de valeur nulle, opérateur de plage

/* Opérateurs
 1 : Opérateur d'affectation =
 

 2 : Termes spéciaux
    Opérateur unaire -a !a a!
    Opérateur binaire +-*&
    Opérateur ternaire a ? b : c
 
 3: Opérateurs arithmétiques
     Addition ( + )
     Soustraction ( - )
     Multiplication ( * )
     Division ( / )
     Modulo %

 4 : Opérateurs logiques
    && || !
 
 5 : Opérateur de fusion de valeur nulle
  ( a ?? b )
 
 6 : Opérateur de plage
    a..<b   Plage fermée      Fermée à gauche et à droite
    a...b   Plage ouverte    Fermée à gauche, ouverte à droite
 
    [2...]  >=2
    [...2]  <=2
 
 7 : Opérateur de fusion de valeur nulle
    a ?? b
    Équivalent à a != nil ? a! : b
 
 */

func testDonnees() {
        // 1 : Opérateur de fusion de valeur nulle
        /*
         Opérateur de fusion de valeur nulle
         L'opérateur de fusion de valeur nulle ( a ?? b ) renvoie la valeur de a s'il n'est pas vide, sinon il retourne la valeur par défaut b. L'expression a doit être un type optionnel. L'expression b doit avoir le même type que a.

         L'opérateur de fusion de valeur nulle est une abréviation du code suivant :
         a != nil ? a! : b
         Dans ce code, l'opérateur conditionnel ternaire force l'expansion ( a! ) de la valeur stockée dans a, si a n'est pas null, sinon il retourne la valeur de b. L'opérateur de fusion de valeur nulle offre une manière plus élégante d'encapsuler cette sélection conditionnelle et cette expansion, en la rendant plus concise et facile à lire.
         Remarque
         Si a a une valeur non nulle, la valeur de b ne sera pas considérée. Cela s'appelle le calcul court-circuité.
         */
        var x :Int?
        var y :Int?
        y = 5
        let z = x ?? y
        print("--->>>:\(self.classForCoder) 1 : Opérateur de fusion de valeur nulle : $z ?? 2)")

        
        // 2: Opérateur de plage fermée 1, 2, 3, 4, 5
        for index in 1...5 {
            print("--->>>:\(self.classForCoder) 1 : Opérateur de fusion de valeur nulle : $index)")
        }
        
        // 3: Plage ouverte 0 1 2 sans 3
        let noms = ["Anna", "Alex", "Brian", "Jack"]
        let count = noms.count
        for i in 0..<count {
            print("--->>>:\(self.classForCoder) Personne $i + 1 est appelée $noms[i])")
        }
        
        // 4: Plage côté unique
        for name in noms[0...] {
            print("--->>>:\(self.classForCoder) Personne est appelée $name)")
        }
        
    }

Note

Références

1 :