Swift中如何约束Int变量不为0及设置最小值（如不小于10）

1. 约束Int变量的值不为0 #

可以通过以下几种方式实现：

方式一：属性setter内校验 #

直接在变量的set/willSet方法中判断新值，拒绝0的赋值：

var nonZeroInt: Int = 1 {
    willSet {
        guard newValue != 0 else {
            print("无法赋值为0")
            return
        }
    }
}

// 测试
nonZeroInt = 5  // 正常赋值
nonZeroInt = 0  // 打印提示，值保持为5

如果需要严格禁止0，也可以用断言在Debug环境下报错：

var strictNonZeroInt: Int = 1 {
    set {
        precondition(newValue != 0, "变量值不能为0")
        self._strictNonZeroInt = newValue
    }
}

方式二：自定义属性包装器（复用场景） #

如果多个变量需要该约束，用属性包装器更高效：

@propertyWrapper
struct NonZeroInt {
    private var value: Int
    
    init(wrappedValue: Int) {
        precondition(wrappedValue != 0, "初始值不能为0")
        self.value = wrappedValue
    }
    
    var wrappedValue: Int {
        get { value }
        set {
            precondition(newValue != 0, "赋值不能为0")
            value = newValue
        }
    }
}

// 使用
@NonZeroInt var number: Int = 10
number = 20  // 正常赋值
number = 0   // 运行时触发断言错误

2. 给Int变量设置最小值约束（如不小于10） #

Swift原生Int不支持直接在声明时绑定范围约束，但可以通过以下方式实现：

方式一：setter校验（简单场景） #

直接在setter里修正或拒绝不符合要求的值：

// 拒绝赋值，保持原有值
var min10Int: Int = 10 {
    willSet {
        if newValue < 10 {
            print("值不能小于10，将保持原有值")
        } else {
            self.min10Int = newValue
        }
    }
}

// 自动修正为最小值
var min10IntFixed: Int = 10 {
    set {
        self.min10IntFixed = max(newValue, 10)
    }
}

方式二：属性包装器（可复用场景） #

定义支持范围约束的属性包装器，灵活配置最小/最大值：

@propertyWrapper
struct BoundedInt {
    private var value: Int
    let minValue: Int
    let maxValue: Int?  // 可选最大值，不需要可设为nil
    
    init(wrappedValue: Int, min: Int, max: Int? = nil) {
        precondition(wrappedValue >= min, "初始值不能小于\(min)")
        if let maxVal = max {
            precondition(wrappedValue <= maxVal, "初始值不能大于\(maxVal)")
        }
        self.minValue = min
        self.maxValue = max
        self.value = wrappedValue
    }
    
    var wrappedValue: Int {
        get { value }
        set {
            var adjustedValue = newValue
            adjustedValue = max(adjustedValue, minValue)
            if let maxVal = maxValue {
                adjustedValue = min(adjustedValue, maxVal)
            }
            self.value = adjustedValue
        }
    }
}

// 使用示例：仅约束最小值10
@BoundedInt(min: 10) var score: Int = 15
score = 5   // 自动修正为10
score = 20  // 正常赋值

// 同时约束10-100的范围
@BoundedInt(min: 10, max: 100) var percentage: Int = 50
percentage = 150  // 自动修正为100

方式三：自定义类型（强类型安全） #

如果需要更严格的类型校验，可以封装自定义结构体：

struct Min10Int {
    let value: Int
    
    init(_ value: Int) throws {
        guard value >= 10 else {
            throw NSError(domain: "Min10IntError", code: 0, userInfo: [NSLocalizedDescriptionKey: "值不能小于10"])
        }
        self.value = value
    }
}

// 使用
do {
    let validNum = try Min10Int(15)
    print(validNum.value)  // 15
    let invalidNum = try Min10Int(5)  // 抛出错误
} catch {
    print(error.localizedDescription)
}

内容的提问来源于stack exchange，提问作者isenwald2022