RxSwift支持的操作符

优质

小牛编辑

123浏览

2023-12-01

有时候，同一个操作符会有多个别名，不同平台或实现有时也会让同一个操作符有不同的名字。有的是历史原因，或者撞上了语言的关键字。

当缺乏社区强烈共识前，RxSwift操作符通常包含多个别名。

操作符默认是无状态的。

创建 Observables

变换操作

过滤操作

结合操作

错误处理

辅助操作

条件和布尔操作

算数和聚合操作

连接操作

创建新的操作符同样也很简单。

RxCocoa extensions

iOS / OSX


extension NSObject {
    public var rx_deallocated: Observable<Void> {}
#if !DISABLE_SWIZZLING
    public var rx_deallocating: Observable<Void> {}
#endif
}

extension NSObject {
    public func rx_observe<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial,
        retainSelf: Bool = true
    )  -> Observable<Element?> {}
#if !DISABLE_SWIZZLING
    public func rx_observeWeakly<Element>(
        type: E.Type,
        _ keyPath: String,
        options: NSKeyValueObservingOptions = .New | .Initial
    ) -> Observable<Element?> {}
#endif
}

extension NSURLSession {
    public func rx_response(request: NSURLRequest) -> Observable<(NSData, NSURLResponse)> {}
    public func rx_data(request: NSURLRequest) -> Observable<NSData> {}
    public func rx_JSON(request: NSURLRequest) -> Observable<AnyObject> {}
    public func rx_JSON(URL: NSURL) -> Observable<AnyObject> {}
}

extension NSNotificationCenter {
    public func rx_notification(name: String, object: AnyObject?) -> Observable<NSNotification> {}
}

class DelegateProxy {
    public func observe(selector: Selector) -> Observable<[AnyObject]> {}
}

extension CLLocationManager {
    public var rx_delegate: DelegateProxy {}
    public var rx_didUpdateLocations: Observable<[CLLocation]> {}
    public var rx_didFailWithError: Observable<NSError> {}
    public var rx_didFinishDeferredUpdatesWithError: Observable<NSError> {}
    public var rx_didPauseLocationUpdates: Observable<Void> {}
    public var rx_didResumeLocationUpdates: Observable<Void> {}
    public var rx_didUpdateHeading: Observable<CLHeading> {}
    public var rx_didEnterRegion: Observable<CLRegion> {}
    public var rx_didExitRegion: Observable<CLRegion> {}
    public var rx_didDetermineStateForRegion: Observable<(state: CLRegionState, region: CLRegion)> {}
    public var rx_monitoringDidFailForRegionWithError: Observable<(region: CLRegion?, error: NSError)> {}
    public var rx_didStartMonitoringForRegion: Observable<CLRegion> {}
    public var rx_didRangeBeaconsInRegion: Observable<(beacons: [CLBeacon], region: CLBeaconRegion)> {}
    public var rx_rangingBeaconsDidFailForRegionWithError: Observable<(region: CLBeaconRegion, error: NSError)> {}
    public var rx_didVisit: Observable<CLVisit> {}
    public var rx_didChangeAuthorizationStatus: Observable<CLAuthorizationStatus> {}
}

iOS


extension UIControl {
    public func rx_controlEvent(controlEvents: UIControlEvents) -> ControlEvent<Void> {}
    public var rx_enabled: ObserverOf<Bool> {}
}

extension UIButton {
    public var rx_tap: ControlEvent<Void> {}
}

extension UITextField {
    public var rx_text: ControlProperty<String> {}
}

extension UITextView {
    override func rx_createDelegateProxy() -> RxScrollViewDelegateProxy {}
    public var rx_text: ControlProperty<String> {}
}

extension UISearchBar {
    public var rx_delegate: DelegateProxy {}
    public var rx_searchText: ControlProperty<String> {}
}

extension UILabel {
    public var rx_text: ObserverOf<String> {}
}

extension UIDatePicker {
    public var rx_date: ControlProperty<NSDate> {}
}

extension UIImageView {
    public var rx_image: ObserverOf<UIImage!> {}
    public func rx_imageAnimated(transitionType: String?) -> AnyObserver<UIImage?>
}

extension UIScrollView {
    public var rx_delegate: DelegateProxy {}
    public func rx_setDelegate(delegate: UIScrollViewDelegate) {}
    public var rx_contentOffset: ControlProperty<CGPoint> {}
}

extension UIBarButtonItem {
    public var rx_tap: ControlEvent<Void> {}
}

extension UISlider {
    public var rx_value: ControlProperty<Float> {}
}

extension UITableView {
    public var rx_dataSource: DelegateProxy {}
    public func rx_setDataSource(dataSource: UITableViewDataSource) -> Disposable {}
    public func rx_itemsWithCellFactory(source: O)(cellFactory: (UITableView, Int, S.Generator.Element) -> UITableViewCell) -> Disposable {}
    public func rx_itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Generator.Element, Cell) -> Void) -> Disposable {}
    public func rx_itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}
    public var rx_itemSelected: ControlEvent<NSIndexPath> {}
    public var rx_itemDeselected: ControlEvent<NSIndexPath> {}
    public var rx_itemInserted: ControlEvent<NSIndexPath> {}
    public var rx_itemDeleted: ControlEvent<NSIndexPath> {}
    public var rx_itemMoved: ControlEvent<ItemMovedEvent> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_modelDeselected<T>(modelType: T.Type) -> ControlEvent<T> {}
}

extension UICollectionView {
    public var rx_dataSource: DelegateProxy {}
    public func rx_setDataSource(dataSource: UICollectionViewDataSource) -> Disposable {}
    public func rx_itemsWithCellFactory(source: O)(cellFactory: (UICollectionView, Int, S.Generator.Element) -> UICollectionViewCell) -> Disposable {}
    public func rx_itemsWithCellIdentifier(cellIdentifier: String, cellType: Cell.Type = Cell.self)(source: O)(configureCell: (Int, S.Generator.Element, Cell) -> Void) -> Disposable {}
    public func rx_itemsWithDataSource(dataSource: DataSource)(source: O) -> Disposable {}
    public var rx_itemSelected: ControlEvent<NSIndexPath> {}
    public var rx_itemDeselected: ControlEvent<NSIndexPath> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}
    // This method only works in case one of the `rx_itemsWith*` methods was used, or data source implements `SectionedViewDataSourceType`
    public func rx_modelSelected<T>(modelType: T.Type) -> ControlEvent<T> {}
}

extension UIGestureRecognizer {
    public var rx_event: ControlEvent<UIGestureRecognizer> {}
}

extension UIImagePickerController {
    public var rx_didFinishPickingMediaWithInfo: Observable<[String : AnyObject]> {}
    public var rx_didCancel: Observable<()> {}
}

extension UISegmentedControl {
    public var rx_value: ControlProperty<Int> {}
}

extension UISwitch {
    public var rx_value: ControlProperty<Bool> {}
}

extension UIActivityIndicatorView {
    public var rx_animating: AnyObserver<Bool> {}
}

extension UINavigationItem {
    public var rx_title: AnyObserver<String?> {}
}

OSX

extension NSControl {
    public var rx_controlEvent: ControlEvent<()> {}
    public var rx_enabled: AnyObserver<Bool> {}
}


extension NSSlider {
    public var rx_value: ControlProperty<Double> {}
}

extension NSButton {
    public var rx_tap: ControlEvent<Void> {}
    public var rx_state: ControlProperty<Int> {}
}

extension NSImageView {
    public var rx_image: ObserverOf<NSImage?> {}
    public func rx_imageAnimated(transitionType: String?) -> AnyObserver<NSImage?>
}

extension NSTextField {
    public var rx_delegate: DelegateProxy {}
    public var rx_text: ControlProperty<String> {}
}

extension UITabBarItem {
    public var rx_badgeValue: AnyObserver<String?> {}
}