Question

假设你有代码

if stringValue == "ab" || stringValue == "bc" || stringValue == "cd" {
    // do something
}

有没有办法缩短这种情况或美化它（最好不使用switch语句）？我知道这段代码不起作用：

if stringValue == ("ab" || "bc" || "cd") {
    // do something
}

我在其他语言上看到了一些复杂的解决方案，但它们似乎特定于语言，不适用于Swift。任何解决方案都将不胜感激。

Answer 1

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

valuesArray.contains(str) // -> Bool

Answer 2

不是我知道，你可以做这样的事情，

CommandBarButtons,

Answer 3

您可以创建如下的扩展程序：

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

并像这样使用它：

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

对于保存我输入的impl的信用：https://gist.github.com/daehn/73b6a08b062c81d8c74467c131f78b55/

Answer 4

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

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

Answer 5

如果您想测试String是否包含多个值，您可以设置extension，如：

extension String: {
 func containsStrings(other: [String]) -> Bool {
     for string in other {
         if self.containsString(string) {
             return true
         }
     }
     return false
 }
}

使用它：

let stringValue = "apple"

if stringValue.containsStrings(["ab", "bc", "le"]) {
 //Do something
}

Answer 6

使用switch语句。

$('#logoCarousel').carousel({
  interval: 10000
})

$('.carousel .carousel-item').each(function(){
    var next = $(this).next();
    if (!next.length) {
    next = $(this).siblings(':first');
    }
    next.children(':first-child').clone().appendTo($(this));

    for (var i=0;i<3;i++) {
        next=next.next();
        if (!next.length) {
            next = $(this).siblings(':first');
        }

        next.children(':first-child').clone().appendTo($(this));
      }
});

Answer 7

结构["some", "array"].contains("value")可以使用，但是有点烦人：

它会反转您可能要编写的从左到右的顺序。
数组中的项目不是使用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
}

Answer 8

只是为了好玩，在 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)
    }
}

这为您提供了全面的性能优势，因为编译器将能够随心所欲地进行内联和尾调用，但代价是必须在代码中编写尽可能多的重载，而且也不能传递数组 - 但其他答案也处理这个问题。

Answer 9

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")
}

如何将一个值与多个值进行比较 - Swift

9 个答案: