先說下狀態機 :
意圖:允許一個對象在其狀態改變時，改變它的行為。看起來對象似乎修改了它的類。
適用性:
1、一個對象的行為取決于它的狀態，并且它必須在運行過程中可以根據它的狀態改變它的行為；
2、一個操作中含有龐大的多分支的條件語句，并且這些分支依賴于該對象的狀態；這個狀態通常使用一個或多個枚舉常量表示；通常，有多個操作包含這一相同的條件結構；State模式把每一個條件分支放入一個獨立的類中；這使得你可以根據對象自身的情況把對象的狀態作為一個對象，而且這一對象可以不依賴于其它對象而獨立變化；

• 示例如下

  
  
  
• 簡單來說 你的對象的行為取決于state 就可以算是狀態機 ，比如我們APP中實現的promise 也是一種狀態機，

 [QXPromise promise:^(ResolveHandler resolve, RejectHandler reject) {
        //                    bill_id=&user_id=
    [[MXNetTool defaultManager] getWithParams:@{@"bill_id":model.model.bill_id,@"user_id":[AppSetting appsetting].userid} url:Biztask_cancelbill success:^(NSURLSessionDataTask *task, id responseObject) {
              resolve(responseObject[responseObject]);   
        } failure:^(NSURLSessionDataTask *task, NSError *error) {
            reject(error);
        }];
        
    }].then(^id(id data){
        
        if ([data[@"data"] isEqualToString:CODE200]) {
            [self showMXHint:@"取消賬單成功" yOffset:0];
        }
        
        return nil;
    })
.catch(^id(NSError *e){
        [self showHint:e];
}).finally(^(){
        
    });

• 廢話少說 我們看下實現一個swift狀態機
  stateMachine
event
state
  將會實現這三個類。
  event 會綁定事件，有原始狀態至目標狀態。
  state綁定每個狀態進入或退出的事件。
  statemachine 會操作event。

event 代碼

open class Event<T:Hashable> : Equatable {
    open let name : String
    open let sourceValues:[T]
    open let destinationValue:T
    
    open var shouldFireEvent:((_ event:Event)->Bool)?
    
    open var willFireEvent:((_ event:Event)->Void)?
    
    open var didFireEvent:((_ event:Event)->Void)?
    
    required public init(name:String,sourceValues sources:[T],destinationValue destination:T){
        self.name = name
        self.sourceValues = sources
        self.destinationValue = destination
    }
    
    static open func == (lhs:Event<T>,rhs:Event<T>)->Bool{
        return lhs.name == rhs.name
    }
}

看到 event綁定了事件以及狀態。

state

open class State<T:Hashable> {
    
    public typealias enterStateHandle = ((_ enteringState:State<T>)->Void)
    open let value:T
    open var willEnterState:enterStateHandle?
    
    open var didEnterState:enterStateHandle?
    
    open var willExitState: enterStateHandle?
    
    open var didExitState: enterStateHandle?
    
    public init(_ value:T){
        self.value = value
    }
    
    
}

同樣 state也會綁定事件 以及值 該值為你的幾種狀態。一般可以為枚舉。

現在就差狀態機了

open class StateMachine<T:Hashable> {
    var initialState:State<T>
open private(set) var currentState:State<T>
    
    private lazy var availableStates:[State<T>] = []
    
    private lazy var events : [Event<T>] = []
    
    required public init(initialState:State<T>){
        self.initialState = initialState;
        self.currentState = initialState;
        availableStates.append(initialState)
    }

    open func activateState(_ stateValue:T) {
        if (isStateAvailable(stateValue)){
            let oldState = currentState
            let newState = stateWithValue(stateValue)!
            
            newState.willEnterState?(newState)
            oldState.willExitState?(oldState)
            
            currentState = newState
            
            oldState.didExitState?(oldState)
            newState.didEnterState?(newState)
        }

    @discardableResult
    open func fireEvent(_ event:Event<T>) -> Transition<T> {
        return _fireEventNamed(event.name)
    }
    
    @discardableResult
    open func fireEvent(_ eventName:String) ->Transition<T> {
        return _fireEventNamed(eventName)
    }
    }

private extension StateMachine {
    
    func _fireEventNamed(_ eventName:String)->Transition<T> {
        if let event = eventWithName(eventName) {
            let possibleTransition = possibleTransitionForEvent(event)
            
            switch possibleTransition {
            case .success(sourceState: let sourceState, destinationState: let destinationState):
                
                if let shouldBlock = event.shouldFireEvent {
                    if shouldBlock(event) {
                        event.willFireEvent?(event)
                        activateState(event.destinationValue)
                        event.didFireEvent?(event)
                        return Transition.success(sourceState: sourceState, destinationState: destinationState)
                    } else {
                        return Transition.error(.transitionDeclined)
                    }
                }
                else {
                    let sourceState = self.currentState
                    event.willFireEvent?(event)
                    activateState(event.destinationValue)
                    event.didFireEvent?(event)
                    return Transition.success(sourceState: sourceState, destinationState: destinationState)
                }
                
            default:
                return possibleTransition
            }
        } else {
            return Transition.error(.unknownEvent)
        }
    }
 }

 }

下面就不貼代碼了。
statemachine 綁定了事件以及 狀態。若需要改變狀態，只需要調用 fireEvenet即可 如若調用成功將會觸發state以及event綁定的事件。

以下為測試代碼

var machine: StateMachine<String>!
let state = State("Initial")
state.willExitState = { _ in
    print("fuck 1")
}

state.willEnterState = { _ in
    print("fuck 2")
}

state.didEnterState = { _ in
    print("fuck 3")
}

state.didExitState = { _ in
    print("fuck 4")
}
let passedState = State("Passed")

passedState.willExitState = { _ in
    print("fuck pass 1")
}

passedState.willEnterState = { _ in
    print("fuck pass 2")
}

passedState.didEnterState = { _ in
    print("fuck pass 3")
}

passedState.didExitState = { _ in
    print("fuck pass 4")
}
machine = StateMachine(initialState: state)
machine.addState(passedState)

let event = Event(name: "Pass", sourceValues: ["Initial"], destinationValue: "Passed")

 _ = try? machine.addEvent(event)

let transition = machine.fireEvent("Pass")

let event2 = Event(name: "Pass3", sourceValues: ["Passed"], destinationValue: "Initial")
 _ = try? machine.addEvent(event2)
let transition2 = machine.fireEvent("Pass3")

執行結果為

fuck pass 2
fuck 1
fuck 4
fuck pass 3
fuck 2
fuck pass 1
fuck pass 4
fuck 3

此狀態機還是比較好理解的。雖然我們用枚舉也能很方便的知道狀態變化。但是這種做法更加抽象。并且代碼也是漂亮的。