Instructions de commutation dans les liaisons de valeur de support Swift.
Cela vous permet d'attribuer une valeur qui correspond à une certaine condition (évalué par la where clause) à une variable temporaire (x & y ici):

for i in 1...100 {
    switch (i){
    case let x where x%3 == 0:
        println("Fizz")
    case let y where y%5 == 0:
        println("Buzz")
    default:
        println("\(i)")
    }
}

Vous pouvez également utiliser la valeur temporaire affectée dans le corps du cas.

Mise à Jour:
Matt Gibson points dans les commentaires, que vous pouvez omettre l'affectation à une temp var si vous n'allez pas l'utiliser dans le corps du boîtier.
Donc une version plus concise de la le code ci-dessus serait:

for i in 1...100 {
    switch (i){
    case _ where i%3 == 0:
        println("Fizz")
    case _ where i%5 == 0:
        println("Buzz")
    default:
        println("\(i)")
    }
}

Note latérale: vos 2 échantillons de code sont légèrement différents (le premier utilise la plage 0-100 en entrée, tandis que le second fonctionne sur 1-100). Mon exemple est basé sur votre premier extrait de code.

C'est une réponse plus générale pour les personnes qui viennent ici simplement pour savoir comment utiliser l'instruction switch dans Swift.

Générales d'utilisation de

switch someValue {
case valueOne:
    // executable code
case valueTwo:
    // executable code
default:
    // executable code
}

Exemple

let someValue = "horse"

switch someValue {
case "horse":
    print("eats grass")
case "wolf":
    print("eats meat")
default:
    print("no match")
}

Notes:

• Aucune instruction break n'est nécessaire. C'est le comportement par défaut. Les cas Swift switch ne "tombent pas à travers". Si vous voulez qu'ils tombent dans le code dans le cas suivant, vous devez explicitement utiliser le mot-clé fallthrough.
• chaque cas doit inclure l'exécutable code. Si vous voulez ignorer une requête, vous pouvez ajouter une seule instruction break.
• les cas doivent être exhaustifs. Autrement dit, ils doivent couvrir toutes les valeurs possibles. S'il n'est pas possible d'inclure suffisamment d'instructions case, une instruction default peut être incluse en dernier pour attraper d'autres valeurs.

L'instruction Swift switch est très flexible. Les sections suivantes incluent d'autres façons de l'utiliser.

Correspondant à plusieurs valeurs

Vous pouvez faire correspondre plusieurs valeurs cas unique si vous utilisez séparer les valeurs avec des virgules. C'est ce qu'on appelle un cas composé .

let someValue = "e"

switch someValue {
case "a", "b", "c":
    // executable code
case "d", "e":
    // executable code
default:
    // executable code
}

Vous pouvez également faire correspondre des intervalles entiers .

let someValue = 4

switch someValue {
case 0..<10:
    // executable code
case 10...100:
    // executable code
default:
    // executable code
}

, Vous pouvez même utiliser tuples. Cet exemple est adapté de la documentation .

let aPoint = (1, 1)

switch aPoint {
case (0, 0):
    // only catches an exact match for first and second
case (_, 0):
    // any first, exact second
case (-2...2, -2...2):
    // range for first and second
default:
    // catches anything else
}

Liaisons De Valeur

Parfois, vous pouvez créer une constante ou une variable temporaire à partir de la valeur switch. Vous pouvez le faire juste après l'instruction case. Partout où une valeur la liaison est utilisée, elle correspond à n'importe quelle valeur. Ceci est similaire à l'utilisation de _ dans l'exemple de tuple ci-dessus. Les deux exemples suivants sont modifiés à partir de la documentation .

let anotherPoint = (2, 0)

switch anotherPoint {
case (let x, 0):
    // can use x here
case (0, let y):
    // can use y here
case let (x, y):
    // can use x or y here, matches anything so no "default" case is necessary
}

Vous pouvez affiner la correspondance en utilisant where mot-clé.

let yetAnotherPoint = (1, -1)

switch yetAnotherPoint {
case let (x, y) where x == y:
    // executable code
case let (x, y) where x == -y:
    // executable code
case let (x, y):
    // executable code
}

Étude complémentaire

• cette réponse était censée être une référence rapide. Veuillez lire la documentation complète pour en savoir plus. Il n'est pas difficile à comprendre.

Voici comment cela peut être fait

var i = 0

switch i  {

case i where i % 5 == 0 && i % 3 == 0: print(" Fizz Buzz")
case i where i % 3 == 0 : print("Fizz")
case i where i % 5 == 0 : print("Buzz")
default: print(i)

}

Le comportement standard de switch peut entraîner des bogues similaires à "Go To Fail" .

Fondamentalement, le code ne fait pas toujours exactement ce qu'il semble que le code fera lors de la lecture, ce qui conduit les auditeurs de code à ignorer les bogues critiques.

Pour contrer cela, Apple a décidé que les instructions switch ne devraient pas fonctionner de la même manière dans Swift que la norme de l'industrie. En particulier:

• Il y a une rupture automatique à la fin de chaque cas. C'est impossible pour plus d'une instruction de cas à exécuter.
• s'il est théoriquement possible que l'une des instructions case soit manquée, alors le code ne compilera pas du tout. Dans swift, l'une des instructions case s'exécutera toujours, quelle que soit la valeur fournie. Si vous fournissez un enum, chaque valeur enum doit être gérée. Si une nouvelle valeur est ajoutée à une énumération existante, le code ne sera pas compilé tant que de nouvelles instructions de casse ne seront pas ajoutées. Si vous fournissez un entier de 32 bits, vous devez gérer toutes les valeurs possibles d'un 32 bits int.

Utilisez ce code. Votre logique est faux. Votre instruction Switch ne trouve pas le cas accepter 1 et 2

class TEST1{
func print() -> Void{
    var i = 0
    for i in 1...100{
        if Int(i%3) == 0 {
            println("Fizz")
        }
        else if Int(i%5) == 0{
            println("Buzz")
        }
        else {
            println("\(i)")
        }   
    }
}
}
var x = TEST1()
x.print()