Inférieure ou supérieure à Swift instruction switch

Voici une approche. En supposant que someVar est un Int ou d'autres Comparable, vous pouvez éventuellement affecter l'opérande à une nouvelle variable. Cela vous permet de portée quand vous le souhaitez à l'aide de la where mot-clé:

var someVar = 3

switch someVar {
case let x where x < 0:
    print("x is \(x)")
case let x where x == 0:
    print("x is \(x)")
case let x where x > 0:
    print("x is \(x)")
default:
    print("this is impossible")
}

Cela peut être simplifié un peu:

switch someVar {
case _ where someVar < 0:
    print("someVar is \(someVar)")
case 0:
    print("someVar is 0")
case _ where someVar > 0:
    print("someVar is \(someVar)")
default:
    print("this is impossible")
}

Vous pouvez également éviter les where mot-clé entièrement avec la gamme de correspondance:

switch someVar {
case Int.min..<0:
    print("someVar is \(someVar)")
case 0:
    print("someVar is 0")
default:
    print("someVar is \(someVar)")
}

La switch déclaration, sous le capot, utilise le ~= de l'opérateur. Donc:

let x = 2

switch x {
case 1: print(1)
case 2: print(2)
case 3..<5: print(3..<5)
default: break
}

Desugars à ceci:

if 1          ~= x { print(1) }
else if 2     ~= x { print(2) }
else if 3..<5 ~= x { print(3..<5) }
else {  }

Si vous regardez la norme de référence de la bibliothèque, il peut vous dire exactement ce que le ~= est surchargé de faire: inclus est gamme assortie, et assimiler pour equatable choses. (Non inclus est enum cas de correspondance, qui est une fonctionnalité du langage, plutôt qu'une fonction dans la prévention des mst lib)

Vous verrez que cela ne correspond pas à un droit booléenne sur la gauche. Pour ce genre de comparaisons, vous devez ajouter une instruction where.

À moins que... vous surchargez la ~= opérateur vous-même. (C'est en général pas recommandé) Une possibilité serait quelque chose comme ceci:

func ~= <T> (lhs: T -> Bool, rhs: T) -> Bool {
  return lhs(rhs)
}

Donc qui correspond à une fonction qui retourne un booléen sur la gauche à son paramètre sur la droite. Voici le genre de chose que vous pourriez utiliser pour:

func isEven(n: Int) -> Bool { return n % 2 == 0 }

switch 2 {
case isEven: print("Even!")
default:     print("Odd!")
}

Pour votre cas, vous pouvez avoir une déclaration qui ressemble à ceci:

switch someVar {
case isNegative: ...
case 0: ...
case isPositive: ...
}

Mais maintenant vous avez à définir de nouvelles isNegative et isPositive fonctions. À moins que vous la surcharge de certains autres opérateurs...

Vous pouvez surcharge normale des opérateurs infixes être au curry préfixe ou un suffixe opérateurs. Voici un exemple:

postfix operator < {}

postfix func < <T : Comparable>(lhs: T)(_ rhs: T) -> Bool {
  return lhs < rhs
}

Ce serait le travail comme ceci:

let isGreaterThanFive = 5<

isGreaterThanFive(6) //true
isGreaterThanFive(5) // false

Combinez cela avec la fonction la plus ancienne, et votre instruction switch peut ressembler à ceci:

switch someVar {
case 0< : print("Bigger than 0")
case 0  : print("0")
default : print("Less than 0")
}

Maintenant, vous ne devriez pas utiliser ce genre de chose dans la pratique: c'est un peu louche. Vous êtes (probablement) mieux coller avec la where déclaration. Cela dit, l'instruction switch modèle de

switch x {
case negative:
case 0:
case positive:
}

ou

switch x {
case lessThan(someNumber):
case someNumber:
case greaterThan(someNumber):
}

Semble tout de même assez pour qu'il soit utile d'examiner.

Depuis que quelqu'un a déjà posté case let x where x < 0: voici une alternative pour où someVar est un Int.

switch someVar{
case Int.min...0: //do something
case 0: //do something
default: //do something
}

Et voici une alternative pour où someVar est un Double:

case -(Double.infinity)...0: //do something
// etc

La <0 expression ne fonctionne pas (plus?) je me suis donc retrouvé avec ce:

Swift 3.0:

switch someVar {
    case 0:
        //it's zero
    case 0 ..< .greatestFiniteMagnitude:
        //it's greater than zero
    default:
        //it's less than zero
    }