Déterminer si une Gamme contient une valeur

J'essaie de trouver un moyen pour déterminer si une valeur est comprise dans une Range en Swift.

Fondamentalement, ce que je suis en train de faire, c'est adapter l'une de l'instruction switch exemples de faire quelque chose comme ceci:

let point = (1, -1)
switch point {
case let (x, y) where (0..5).contains(x):
    println("(\(x), \(y)) has an x val between 0 and 5.")
default:
    println("This point has an x val outside 0 and 5.")
}

Aussi loin que je peux dire, il n'y a pas construit de la manière de faire ce que mon imaginaire .contains méthode ci-dessus ne.

J'ai donc essayé de prolonger la Range classe. J'ai terminé la course à pied sur des problèmes avec les génériques si. Je ne peux pas étendre Range<Int> j'ai donc essayer de l'étendre Range lui-même.

Le plus proche que j'ai eu était de cela, mais il ne fonctionne pas depuis >= et <= ne sont pas définies pour ForwardIndex

extension Range {
    func contains(val:ForwardIndex) -> Bool {
        return val >= self.startIndex && val <= self.endIndex
    }
}

Comment pourrais-je aller sur l'ajout d'un .contains méthode pour Range? Ou est-il une meilleure façon de déterminer si une valeur se situe dans une fourchette?

Edit2: Cela semble fonctionner pour étendre Range

extension Range {
    func contains(val:T) -> Bool {
        for x in self {
            if(x == val) {
                return true
            }
        }

        return false
    }
}

var a = 0..5
a.contains(3) //true
a.contains(6) //false
a.contains(-5) // false

Je suis très intéressé par la ~= opérateur mentionné ci-dessous si, à la recherche dans le maintenant.

InformationsquelleAutor Brad Dwyer | 2014-06-03
  1. 39

    Vous pouvez le faire avec le ~= opérateur:

    let point = (1, -1)
switch point {
case let (x, y) where (0..5) ~= x:
   println("(\(x), \(y)) has an x val between 0 and 5.")
default:
   println("This point has an x val outside 0 and 5.")
}

    Vous pouvez aussi le faire directement dans un switch:

    let point = (1, -1)
let (x, y) = point
switch x {
case 0..5:
    println("yes")
default:
    println("no")
}

    ~= est la mise en correspondance du modèle de l'opérateur utilisé par cas consolidés. Voir les détails dans les docs.

    • Intéressant; la moindre idée de ce que l'opérateur est appelé?
    • Eh bien, en ruby, il est === et il est appelé le "cas opérateur d'égalité", qui est une sorte de spécialisés de l'égalité avec les comportements qui rendent les cas énoncés plus propre. Donc, c'est peut-être appelée la même chose ici, mais je ne sais pas pour sûr. Sauf si je suis absent, et il n'est pas mentionné du tout dans la Swift opérateur de documentation.
    • C'est Apple, avec son livre comme le "Motif" de l'opérateur.
    • Je vois que vous êtes en droit. La recherche n'a pas le transformer. Il est certainement plus que des plages, et je suis sûr à 99% que c'est la façon case est défini. Considérez ceci (désolé pour l'un de ligne): class Foo {}; switch 3 {case Foo.self: println("foo"); default: println("default")} qui donne l'erreur "impossible de trouver une surcharge pour '~=' qui accepte les arguments fournis" sur Foo.self et est fixe si j'définir @infix func ~=(left: AnyClass, right: Int) -> Bool.
    • Merci @0x7fffffff - n'étaient pas arrivés aussi loin que cela dans le livre. A pu obtenir que cela fonctionne et aussi trouvé comment ajouter une extension à Range de manière à ce que le == travail d'opérateur de type T ainsi. Ajouté ça à mon post original.
    • Pour ce que ça vaut, c'est documentée (re: le cas des énoncés) ici: developer.apple.com/library/prerelease/ios/documentation/Swift/...

    InformationsquelleAutor gwcoffey
  2. 26

    Avec Swift 5, en fonction de vos besoins, vous pouvez choisir l'une des options suivantes pour déterminer si une Range (ou un ClosedRange) contient une valeur.

    1. contains(_:) méthode

    Range, ClosedRange, CountableRange et CountableClosedRange ont un contains(_:) méthode. Range contient(_:) méthode a la déclaration suivante:

    func contains(_ element: Bound) -> Bool

    Renvoie une valeur Booléenne indiquant si l'élément est contenue à l'intérieur de la gamme.

    Utilisation:

    let value: Int = 0
let range = -200 ..< 300
print(range.contains(value)) // prints true

    2. ~=(_:_:) opérateur

    Range, ClosedRange, CountableRange et CountableClosedRange ont un ~=(_:_:) de l'opérateur. Range ~=(_:_:) opérateur a la déclaration suivante:

    static func ~= (pattern: Range<Bound>, value: Bound) -> Bool

    Renvoie une valeur Booléenne indiquant si une valeur est comprise dans une gamme.

    Utilisation:

    let value = 0
let range = -200 ..< 300
print(range ~= value) // prints true

    3. Instruction Switch

    Un moyen simple de tester si un Range, un ClosedRange, un CountableRange ou un CountableClosedRange contient une valeur est d'utiliser une instruction switch:

    let value = 0
switch value {
case -200 ..< 300:
    print("OK") //prints "OK"
default:
    break
}

    4. Motif de correspondance avec if case

    Comme une alternative à la précédente instruction switch, vous pouvez utiliser if case:

    let value = 0
if case -200 ..< 300 = value {
    print("OK") //prints "OK"
}

    Par conséquent, afin de résoudre votre problème, vous pouvez utiliser l'une des options suivantes:

    let point = (1, -1)
switch point {
case let (x, y) where (0 ..< 5).contains(x):
    print("(\(x), \(y)) has an x val between 0 and 5.")
default:
    print("This point has an x val outside 0 and 5.")
}
    let point = (1, -1)
if case let (x, y) = point, 0 ..< 5 ~= x {
    print("(\(x), \(y)) has an x val between 0 and 5.")
}
    InformationsquelleAutor Imanou Petit
  3. 3

    Au lieu de vous embêter avec la Gamme, vous pouvez ajouter une simple fonction d'assistance comme ce

    let point = (1, -1)
switch point {
case let (x, y) where contains((0..5),x):
    println("(\(x), \(y)) has an x val between 0 and 5.")
default:
    println("This point has an x val outside 0 and 5.")
}

func contains(range :Range<Int>, x: Int)->Bool{
    for num in range{
        if(num==x){
            return true
        }
    }
    return false
}

    Vous pourriez probablement faire quelque chose de similaire avec une fermeture.

    • Pas besoin de définir la fonction: contains() est (maintenant?) une partie de la bibliothèque standard (ref)!
    • Parce que vous ne pouvez jamais avoir assez de fonctions globales.
    InformationsquelleAutor Connor
  4. 2

    Si vous voulez écrire contains extension de Range, utilisez distanceTo de ForwardIndex pour déterminer si la valeur donnée relève de gamme.

    Également utiliser le type spécifique Element à la place de protocole général FowardIndex comme paramètre de type.

    Les deux distanceTo et Element font partie de Range définition.

    extension Range {

    func contains(element: Element) -> Bool {
        return startIndex.distanceTo(element) >= 0 && element.distanceTo(endIndex) > 0
    }

}

    Plus Range a déjà un contains méthode de extension SequenceType where Generator.Element : Equatable. De sorte que vous pouvez simplement l'utiliser sans avoir à écrire une vous-même.

    InformationsquelleAutor Medo Paw
  5. 1

    J'étais en train de regarder la même chose et n': 

    let r = 7...9

operator infix ~ {}
func ~ (range:Range<Int>, item:Int) -> Bool{
  return item >= range.startIndex  && item <= range.endIndex - 1
}

r ~ 9

    puis j'ai vu que ~= fait la même chose!

    InformationsquelleAutor thisispete