Calculator.gif
这是一个计算器，是RxSwift官方的示例demo，可在 这里下载
整个项目只有3个文件
image.png
我们先看CalculatorViewController.swift这个文件，核心代码如下
override func viewDidLoad() {
typealias FeedbackLoop = (ObservableSchedulerContext<CalculatorState>) -> Observable<CalculatorCommand>
let uiFeedback: FeedbackLoop = bind(self) { this, state in
let subscriptions = [
state.map { $0.screen }.bind(to: this.resultLabel.rx.text),
state.map { $0.sign }.bind(to: this.lastSignLabel.rx.text)
]
let events: [Observable<CalculatorCommand>] = [
this.allClearButton.rx.tap.map { _ in .clear },
this.changeSignButton.rx.tap.map { _ in .changeSign },
this.percentButton.rx.tap.map { _ in .percent },
this.divideButton.rx.tap.map { _ in .operation(.division) },
this.multiplyButton.rx.tap.map { _ in .operation(.multiplication) },
this.minusButton.rx.tap.map { _ in .operation(.subtraction) },
this.plusButton.rx.tap.map { _ in .operation(.addition) },
this.equalButton.rx.tap.map { _ in .equal },
this.dotButton.rx.tap.map { _ in .addDot },
this.zeroButton.rx.tap.map { _ in .addNumber("0") },
this.oneButton.rx.tap.map { _ in .addNumber("1") },
this.twoButton.rx.tap.map { _ in .addNumber("2") },
this.threeButton.rx.tap.map { _ in .addNumber("3") },
this.fourButton.rx.tap.map { _ in .addNumber("4") },
this.fiveButton.rx.tap.map { _ in .addNumber("5") },
this.sixButton.rx.tap.map { _ in .addNumber("6") },
this.sevenButton.rx.tap.map { _ in .addNumber("7") },
this.eightButton.rx.tap.map { _ in .addNumber("8") },
this.nineButton.rx.tap.map { _ in .addNumber("9") }
]
return Bindings(subscriptions: subscriptions, events: events)
}
Observable.system(
initialState: CalculatorState.initial,
reduce: CalculatorState.reduce,
scheduler: MainScheduler.instance,
scheduledFeedback: uiFeedback
)
.subscribe()
.disposed(by: disposeBag)
}
func formatResult(_ result: String) -> String {
if result.hasSuffix(".0") {
return String(result[result.startIndex ..< result.index(result.endIndex, offsetBy: -2)])
} else {
return result
}
}
该项目使用了RxFeedback框架，有时间我再写一篇分析RxFeedback源码的文章。 关于RxFeedback的简介 看这里
bind(self) { this, state in ...
这里闭包里的this即是bind函数传入的 self
上面的代码段 let events: [Observable<CalculatorCommand>] = [ ... ]
表示将按钮的点击事件转换为相应的命令。
let subscriptions = [
state.map { $0.screen }.bind(to: this.resultLabel.rx.text),
state.map { $0.sign }.bind(to: this.lastSignLabel.rx.text)
]
上面的代码表示将state映射到计算符和屏显。
image.png
这个计算器主要有三种状态：
enum CalculatorState {
case oneOperand(screen: String)
case oneOperandAndOperator(operand: Double, operator: Operator)
case twoOperandsAndOperator(operand: Double, operator: Operator, screen: String)
}
oneOperand 一个操作数，例如: 输入 1 时的状态
oneOperandAndOperator 一个操作数和一个运算符，例如: 输入 1 + 时的状态
twoOperandsAndOperator 两个操作数和一个运算符，例如: 输入 1 + 2 时的状态
计算器提供了七种命令
enum CalculatorCommand {
case clear
case changeSign
case percent
case operation(Operator)
case equal
case addNumber(Character)
case addDot
}
extension CalculatorState {
static func reduce(state: CalculatorState, _ x: CalculatorCommand) -> CalculatorState {
switch x {
case .clear:
return CalculatorState.initial
case .addNumber(let c):
return state.mapScreen { return $0 == "0" ? String(c) : $0 + String(c)
case .addDot:
return state.mapScreen { $0.range(of: ".") == nil ? $0 + "." : $0 }
case .changeSign:
return state.mapScreen { "\(-(Double($0) ?? 0.0))" }
case .percent:
return state.mapScreen { "\((Double($0) ?? 0.0) / 100.0)" }
case .operation(let o):
switch state {
case let .oneOperand(screen):
return .oneOperandAndOperator(operand: screen.doubleValue, operator: o)
case let .oneOperandAndOperator(operand, _):
return .oneOperandAndOperator(operand: operand, operator: o)
case let .twoOperandsAndOperator(operand, oldOperator, screen):
return .twoOperandsAndOperator(operand: oldOperator.perform(operand, screen.doubleValue), operator: o, screen: "0")
}
case .equal:
switch state {
case let .twoOperandsAndOperator(operand, operat, screen):
let result = operat.perform(operand, screen.doubleValue)
return .oneOperand(screen: String(result))
default:
return state
}
}
}
}
一些其他辅助代码：
extension CalculatorState {
static let initial = CalculatorState.oneOperand(screen: "0")
func mapScreen(transform: (String) -> String) -> CalculatorState {
switch self {
case let .oneOperand(screen):
return .oneOperand(screen: transform(screen))
case let .oneOperandAndOperator(operand, operat):
return .twoOperandsAndOperator(operand: operand, operator: operat, screen: transform("0"))
case let .twoOperandsAndOperator(operand, operat, screen):
return .twoOperandsAndOperator(operand: operand, operator: operat, screen: transform(screen))
}
}
var screen: String {
switch self {
case let .oneOperand(screen):
return screen
case .oneOperandAndOperator:
return "0"
case let .twoOperandsAndOperator(_, _, screen):
return screen
}
}
var sign: String {
switch self {
case .oneOperand:
return ""
case let .oneOperandAndOperator(_, o):
return o.sign
case let .twoOperandsAndOperator(_, o, _):
return o.sign
}
}
}
extension Operator {
var sign: String {
switch self {
case .addition: return "+"
case .subtraction: return "-"
case .multiplication: return "×"
case .division: return "/"
}
}
var perform: (Double, Double) -> Double {
switch self {
case .addition: return (+)
case .subtraction: return (-)
case .multiplication: return (*)
case .division: return (/)
}
}
/*
这段代码解释一下，这种写法我也是第一次见。对于addition，它返回了一个接受两个Double值并返回它们之和的闭包，即(+)。
对于subtraction，它返回了一个接受两个Double值并返回它们之差的闭包，即(-)。
对于multiplication，它返回了一个接受两个Double值并返回它们乘积的闭包，即(*)。
对于division，它返回了一个接受两个Double值并返回它们商的闭包，即(/)。
*/
}
private extension String {
var doubleValue: Double {
guard let double = Double(self) else {
return Double.infinity
}
return double
}
}
