let valuesArray = ["ab","bc","cd"]

valuesArray.contains(str) // -> Bool

你可以创建一个这样的扩展：

extension Equatable {
    func oneOf(_ other: Self...) -> Bool {
        return other.contains(self)
    }
}

然后像这样使用它：

if stringValue.oneOf("ab", "bc", "cd") { ... }

感谢impl让我不用打字：https://gist.github.com/daehn/73b6a08b062c81d8c74467c131f78b55/

我不知道。你可以这样做：

let validStrings = Set(["ab", "bc", "cd"])
if validStrings.contains(str) {
    //do something      
}

使用Switch语句。

switch stringValue {
case "ab", "bc", "cd":
    print("Yay!")
default:
    break     
}

结构["some", "array"].contains("value")可以工作，但有点烦人：
1.它颠倒了您可能想要写入的从左到右的顺序。
1.数组中的元素没有使用Swift的类型推断来声明，这通常会迫使你包含不必要的信息来取悦编译器。
您可以使用Set(["value"]).isSubset(of: ["some", "array"])。
在使用枚举时，这种好处尤其明显：

enum SomeReallyReallyLongTypeName {
    case one, two
}

struct Thing {
    let value: SomeReallyReallyLongTypeName
}
    
let thing = Thing(value: .one)


if Set([thing.value]).isSubset(of: [.one, .two]){
    // :)
    // Left-to-right order
    // You get nice type inference
}

if [SomeReallyReallyLongTypeName.one, .two].contains(thing.value) {
    // :(
    // Annoying to have "SomeReallyReallyLongTypeName" in the code
}

if someArray.contains(object) {
  // contains
} else {
  // does not contains
}

上面的函数返回bool值，然后相应地编写逻辑。

只是为了好玩，如何在String上重载函数：

if a.isOneOf("ab", "bc", "cd") {
    print("yes")
}

extension String {
    @inlinable
    func isOneOf(_ first: String, _ second: String) -> Bool {
        self == first || self == second
    }
    
    @inlinable
    func isOneOf(_ first: String, _ second: String, _ third: String) -> Bool {
        self == first || isOneOf(second, third)
    }
    
    @inlinable
    func isOneOf(_ first: String, _ second: String, _ third: String, _ fourth: String) -> Bool {
        self == first || isOneOf(second, third, fourth)
    }
}

这给你带来了全面的性能优势，因为编译器将能够尽可能多地内联和尾调用，代价是必须在代码中编写尽可能多的重载，并且也不能传递数组-但其他答案也处理这个问题。

let a = 1
let b = 1
let c = 1
let d = 1
if a == b,a==c,a==d  {
    print("all of them are equal")
}
else {
    print("not equal")
}