动态评估用户添加的 If 语句

首先，您需要一种在运算符之间切换的方法。一个非常简单的是完美的。只需添加您要使用的所有运算符即可。enum

enum Operator : String {

    case biggerThan = ">"
    case smallerThan = "<"
    case equal = "=="

    init?(string:String) {
        switch string {
        case ">" :
            self = .biggerThan
        case "<" :
            self = .smallerThan
        case "==" :
            self = .equal
        default :
            return nil
        }
    }
}

每次用户单击按钮并插入条件时，都会创建相应的值。Condition

struct Condition {
    var value: Int
    var operation: Operator
}

此函数返回一个 取决于 、 和 选择的 。BoolxinputValueoperator

func checkCondition(x: Int, condition: Condition) -> Bool {
    switch condition.operation {
    case .biggerThan :
        return condition.value > x
    case .smallerThan :
        return condition.value < x
    case .equal :
        return condition.value == x
    }
}

这做同样的事情，但适用于一大堆条件。在这里，您可以实现更多逻辑。例如，如果 all 都需要为 true，则添加 ： 。if !result { return false }

func checkAllConditions(x:Int, conditions: [Condition]) {
    for condition in conditions {
        let result = checkCondition(x, condition: condition)
        print(result)
    }
}

现在，您需要做的就是在用户创建条件时将条件存储在数组中

func userCondition(operation:String, input:String) -> Condition? {

    guard let op = Operator(string: operation) else {
        return nil
    }
    guard let doubleValue = Double(input) else {
        return nil
    }

    return Condition(value: Int(doubleValue), operation: op)
}

let conditionA = userCondition("<", input: "10")! // use if let instead of !
let conditionB = userCondition(">", input: "10")! // use if let instead of !
let conditionC = userCondition("==", input: "23")! // use if let instead of !

var x : Int = 23

checkAllConditions(x, conditions: [conditionA,conditionB,conditionC])

struct MyConditions {
    let myEps: Double = 0.001
    var x: Double
    var lessThan = [Double]()
    var equalTo = [Double]()
    var greaterThan = [Double]()

    init(x: Double) {
        self.x = x
    }

    mutating func addConstraint(operand: Double, op: String) {
        if op == "<" {
            lessThan.append(operand)
        }
        else if op == "==" {
            equalTo.append(operand)
        }
        else if op == ">" {
            greaterThan.append(operand)
        }
    }

    func checkConstraints() -> Bool {
        for op in lessThan {
            if !(x < op) {
                return false
            }
        }
        for op in equalTo {
            if !(x - myEps < op && x + myEps > op) {
                return false
            }
        }
        for op in greaterThan {
            if !(x > op) {
                return false
            }
        }
        return true
    }
}

测试：

func feasibleHelloWorld(x: MyConditions) {
    if x.checkConstraints() {
        print("Hello world!")
    }
}

var x = MyConditions(x: 8)
x.addConstraint(100, op: "<")
x.checkConstraints() // true
feasibleHelloWorld(x) // Hello world!

x.addConstraint(8, op: "==")
x.checkConstraints() // true
feasibleHelloWorld(x) // Hello world!

x.addConstraint(7, op: "<")
x.checkConstraints() // false
feasibleHelloWorld(x) // ... nothing

除非你想构建一门完整的语言，否则你必须清楚你将在这里允许哪些确切的操作。

例如，和 和 的运算，基本上所有的比较运算（ 和 以及）都可以通过以下方式实现：<>==<=>=

/* your X variable, might be var if you desire to change */
let x = 12

/* the array of conditions the user entered */
var conditions : [(((Int, Int) -> Bool), Int)] = []

/* some user input - read as e.g. "x > 2"*/
conditions.append((<, 100))
conditions.append((>, 2))
conditions.append((==, 12))

/* you evaluate all conditions in the following way */
let eval = conditions.map { $0(x, $1) }
let allTrue = !eval.contains(false)
/* allTrue would be true in this case because 12 < 100 && 12 > 2 && 12 == 12 */

你的“困难”工作是现在将用户输入解释为一些.但这并不难，您只需要将文本输入映射到实际运算符即可。condition"<"<

您可以调整上面的代码来照顾，而不是在您需要时轻松摔倒。但是你必须意识到浮点的不准确性和检查相等性时出现的问题（感谢@dfri指出了这一点）。DoubleInt

更困难的部分是关于将条件与上述代码的功能以及您当前在问题中描述的内容相结合。orand

仅仅因为我喜欢闭包：以下是整个输入读取和解析：

func getOperator(str: String) -> ((Int, Int) -> Bool)? {
    switch str {
    case "<":
        return (<)
    case ">":
        return (>)
    case "==":
        return (==)
    case "<=":
        return (<=)
    case ">=":
        return (>=)
    default:
        return nil
    }
}

func parseUserInput(str:String) -> (((Int, Int) -> Bool), Int) {
    var input = str as NSString
    input = input.stringByReplacingOccurrencesOfString(" ", withString: "")
    //let variable = input.substringToIndex(1) // in case you want more than one variable, but that will have to change the entire setup a bit
    // this has to be this "ugly" to incorporate both 1 char and 2 char long operators
    let operato = input.substringFromIndex(1).stringByTrimmingCharactersInSet(NSCharacterSet.alphanumericCharacterSet())
    let number = input.substringFromIndex(operato.lengthOfBytesUsingEncoding(NSASCIIStringEncoding) + 1)

    if let number = Int(number), op = getOperator(operato) {
        return (op, number)
    }

    return ((<, 999999)) // need some error handling here
}

conditions.append(parseUserInput("x > 123"))

您甚至可以使用普通的旧字典映射 from to 等，而不是使用函数解析运算符。">"(>)