comment comparer la valeur de swift facultatif

var someString: String? = "a"    
someString = "b" 
// or someString = nil

Condition: someString n'est pas nul, et "un"

Exemple:

if someString != nil && someString != "a" {

}

Est-il possible à la condition d'un seul?

Eh bien, puisque vous avez maintenant complètement changé votre question... je n'ai aucune idée de ce que vous êtes en train de demander. Le code que vous aurez à travailler, mais il ne correspond pas au texte. (!= s/b == d'après le texte)
someString = "b" ou someString = nil
Il n'est toujours pas clair du tout ce que vous demandez. "Est-il possible à la condition d'un seul?" n'a aucun sens. Aucun de vos exemples correspondre à la "Condition" que vous donnez dans votre question. L'expression la plus simple qui répond effectivement à la "Condition" figurant dans votre question, est donné dans ma réponse ci-dessous.
Je suis désolé. Ma question semble stupide.
Pas tellement ridicule qu'incertaine. Si vous êtes désireux de vérifier que someString n'est pas nul et n'EST PAS "un", alors c'est quelque chose comme Antonios réponse someString != nil && someString! != "a" Si vous voulez quelque chose n'est pas nul et EST "un", alors qu'il est plus simple puisque vous pouvez la réduire à ma réponse.

OriginalL'auteur jjaeko | 2014-08-25

  1. 3

    Je suppose que vous voulez dire que vous souhaitez tester pour someString != nil et someString != "a" dans une seule expression logique (et non pas deux, et).

    Non, je ne pense pas que c'est possible en utilisant le haut dans les opérateurs, mais c'est faisable mise en œuvre d'une Chaîne d'extension comme ceci:

    extension String {
    func isDifferentThan(value: String?) -> Bool {
        return value != nil && self != value?
    }
}

    et vous pouvez l'utiliser comme suit:

    someString = nil
"a".isDifferentThan(someString) //Return false

someString = "b"
"a".isDifferentThan(someString) //Return true

someString = "a"
"a".isDifferentThan(someString) // Return false

    Additif: Une solution plus élégante est de définir votre propre opérateur logique. J'ai utilisé !~= mais n'hésitez pas à utiliser votre propre.

    infix operator !~= { associativity left }
func !~= (a: String?, b: String?) -> Bool {
    if a == nil || b == nil {
        return false
    }

    return a != b
}

    Testé comme suit:

    someString = nil
someString !~= "a" //Returns false

someString = "b"
someString !~= "a" //Returns true

someString = "a"
someString !~= "a" //Returns false

someString = nil
someString !~= nil // Returns false

    Vous pouvez affiner lorsque vous traitez avec nil valeurs (comme ajouter une case pour les deux, d'avoir nil et le retour true, dans le cas où vous souhaitez que la condition "des deux côtés, sont nuls" à true)

    Je vous remercie. La réponse que je voulais.
    A ajouté une autre solution - mieux, à mon avis

    OriginalL'auteur Antonio

  2. 7

    La façon correcte dans Swift 3 est d'utiliser un multi-clause de condition:

    if let bString = someString, bString != "a" {
    print("bString: '\(bString)' is not nil and is different from 'a'")
}

    https://github.com/apple/swift-evolution/blob/master/proposals/0099-conditionclauses.md

    Que vraiment possible maintenant? Enfin!!!

    OriginalL'auteur lkraider

  3. 4

    Avoir un essai avec une clause where:

    if let forcedString = someString where forcedString != "a" {
    print("Yea")
} else {
    print("Err")
}

    OriginalL'auteur ZLN

  4. 2

    Vous pouvez réduire le tout à l'aide de l'option de déballage de l'opérateur:

    if someString? == "a" {
    Mais c'est à ces deux conditions. Est-il possible à la condition d'un seul?
    C'est ce que j'aurais cru, mais ne compile pas (au moins!) error: '?' must be followed by a call, member lookup, or subscript
    ce ne sera pas compiler

    OriginalL'auteur David Berry

  5. 2

    swift 1.2 pour var a:int?; var b:int? a la matrice

    nil == nil; //true
nil > nil;  //false
nil > 2;    //false
2 > nil;    //true
2 > 1;      // true

    OriginalL'auteur john07

  6. 1

    Un truc: 

    func existsAnd<T: Equatable>(x:T?, _ it:T ) -> Bool {
    return x.flatMap { $0 == it } ?? false
}

var str : String? = "hello"
existsAnd(str, "hello")
str = nil
existsAnd(str, "hello")

    OriginalL'auteur John LaBarge

  7. 0

    un peu en retard à la fête, mais que diriez-vous simplement ceci (en supposant que vous ne voulez comparer des chaînes de caractères):

    if someName.compare(displayName) == .OrderedSame{
  //true
}
    par la façon dont vous devez déballer les options avant de l'utiliser c'est le point de droit? Si vous n'avez pas de valeur il n'y a rien à comparer.

    OriginalL'auteur Marcio Arantes

  8. 0

    Cette extension en Option permettra de comparer les Options et ses enveloppé valeur. 

    extension Optional: Comparable where Wrapped: Comparable {
//Optional <=> Optional

public static func < (lhs: Optional<Wrapped>, rhs: Optional<Wrapped>) -> Bool {
switch lhs {
case .some(let v): return v < rhs
case .none: return false
}
}
public static func <= (lhs: Optional<Wrapped>, rhs: Optional<Wrapped>) -> Bool {
switch lhs {
case .some(let v): return v <= rhs
case .none: return false
}
}
public static func >= (lhs: Optional<Wrapped>, rhs: Optional<Wrapped>) -> Bool {
switch lhs {
case .some(let v): return v >= rhs
case .none: return false
}
}
public static func > (lhs: Optional<Wrapped>, rhs: Optional<Wrapped>) -> Bool {
switch lhs {
case .some(let v): return v > rhs
case .none: return false
}
}
//Optional <=> Wrapped

public static func < (lhs: Optional<Wrapped>, rhs: Wrapped) -> Bool {
switch lhs {
case .some(let v): return v < rhs
case .none: return false
}
}
public static func <= (lhs: Optional<Wrapped>, rhs: Wrapped) -> Bool {
switch lhs {
case .some(let v): return v <= rhs
case .none: return false
}
}
public static func >= (lhs: Optional<Wrapped>, rhs: Wrapped) -> Bool {
switch lhs {
case .some(let v): return v >= rhs
case .none: return false
}
}
public static func > (lhs: Optional<Wrapped>, rhs: Wrapped) -> Bool {
switch lhs {
case .some(let v): return v > rhs
case .none: return false
}
}
//Wrapped <=> Optional

public static func < (lhs: Wrapped, rhs: Optional<Wrapped>) -> Bool {
switch rhs {
case .some(let v): return lhs < v
case .none: return false
}
}
public static func <= (lhs: Wrapped, rhs: Optional<Wrapped>) -> Bool {
switch rhs {
case .some(let v): return lhs <= v
case .none: return false
}
}
public static func >= (lhs: Wrapped, rhs: Optional<Wrapped>) -> Bool {
switch rhs {
case .some(let v): return lhs >= v
case .none: return false
}
}
public static func > (lhs: Wrapped, rhs: Optional<Wrapped>) -> Bool {
switch rhs {
case .some(let v): return lhs > v
case .none: return false
}
}
}

    OriginalL'auteur Arbitur