Swift 结构体什么时候使用 mutating 函数

做者：Natasha，原文连接，原文日期：2016/01/13
译者：bestswifter；校对：saitjr；定稿：千叶知风

Swift 最棒的特色之一就是它内置了对总体结构的不可变性的支持，这使得咱们的代码更加整洁、安全（关于这个话题，若是还没看过这篇文章，那么强烈推荐给你）。

不过，真的须要用到可变性时，你应该怎么作呢？

函数式作法

举个例子，我有一个井字棋棋盘，如今须要改变棋盘上某个位置的状态：

struct Position {
    let coordinate: Coordinate
    let state: State
    
    enum State: Int {
        case X, O, Empty
    }
}

struct Board {
    
    let positions: [Position]

    // 须要添加一个函数来更新这个位置的状态
    // 状态从 Empty 改成 X 或者 0
}

若是彻底采用函数式编程的作法，你只须要简单的返回一个新的棋盘便可：

struct Board {
    
    let positionsMatrix: [[Position]]
    
    init() {
       // 初始化一个空棋盘的逻辑
    }

    // 函数式编程的作法
    func boardWithNewPosition(position: Position) -> Board {
        var positions = positionsMatrix
        let row = position.coordinate.row.rawValue
        let column = position.coordinate.column.rawValue
        positions[row][column] = position
        return Board(positionsMatrix: positions)
    }
}

我更倾向于使用这种函数式的作法，由于它不会有任何反作用。变量能够继续保持不可变状态，固然，这样也很是易于测试！

class BoardTests: XCTestCase {

    func testBoardWithNewPosition() {
        let board = Board()
        let coordinate = Coordinate(row: .Middle, column: .Middle)
        
        let initialPosition = board[coordinate]
        XCTAssertEqual(initialPosition.state, Position.State.Empty)
        
        let newPosition = Position(coordinate: coordinate, state: .X)
        let newBoard = board.boardWithNewPosition(newPosition)
        XCTAssertEqual(newBoard[coordinate], newPosition)
    }
}

不过这种作法并不是在全部场景下都是最佳选择。

使用 Mutating 关键字

假设我须要统计每一个用户赢了多少局井字棋，那么我建立了一个 Counter：

struct Counter {
    let count: Int
    
    init(count: Int = 0) {
        self.count = count
    }
    
    // 须要实现一个增长计数的方法
}

我依然能够选择函数式的作法：

struct Counter {
    let count: Int
    
    init(count: Int = 0) {
        self.count = count
    }
    
    // 函数式作法
    func counterByIncrementing() -> Counter {
        let newCount = count + 1
        return Counter(count: newCount)
    }
}

不过，若是你真的尝试了使用这个函数来增长计数，代码会是这样：

var counter = Counter()
counter = counter.counterByIncrementing()

这种写法不够直观，可读性也不高。因此在这种场景下，我更倾向于使用 mutating 关键字：

struct Counter {
    // 这个变量如今得声明成 var
    var count: Int
    
    init(count: Int = 0) {
        self.count = count
    }
    
    // 使用 mutating 关键字的作法
    mutating func increment() {
        count += 1
    }
}

我不喜欢这个函数带来的反作用，可是相对于可读性的提高而言，这样作是值得的：

var counter = Counter()
counter.increment()

更进一步来讲，经过使用私有 setter 方法能够确保 count 变量不会被外部修改（由于它如今被声明为变量了）。这样，使用变异方法和变量所带来的负面影响能够被降到最低。

总结

在选择使用 mutating 关键字和函数式编程时，我倾向于后者，但前提是不会以牺牲可读性为代价。

写测试是一种很好的检查接口的方法，它能够判断你的函数式编程是否真的有意义。若是你以为代码比较奇怪并且不够直观，那么就换成 mutating 方法吧。只要记得使用变量的私有 setter 方法就好了。

本文由 SwiftGG 翻译组翻译，已经得到做者翻译受权，最新文章请访问 http://swift.gg。��法是否知足预期。若是你以为接口写起来很怪异、不直观，那就去换一种方式去实现吧！最后别忘了用私有 setter 设置你的内部变量哦！
本文由 SwiftGG 翻译组翻译，已经得到做者翻译受权，最新文章请访问 http://swift.gg。