iOS-个人开源-app-趣账本,iOS开源项目.zip

# ReactiveCocoa [](https://github.com/Carthage/Carthage) ReactiveCocoa (RAC) is an Objective-C framework inspired by [Functional Reactive Programming][]. It provides APIs for **composing and transforming streams of values**. If you're already familiar with functional reactive programming or know the basic premise of ReactiveCocoa, check out the [Documentation][] folder for a framework overview and more in-depth information about how it all works in practice. ## New to ReactiveCocoa? ReactiveCocoa is documented like crazy, and there's a wealth of introductory material available to explain what RAC is and how you can use it. If you want to learn more, we recommend these resources, roughly in order: 1. [Introduction](#introduction) 1. [When to use ReactiveCocoa](#when-to-use-reactivecocoa) 1. [Framework Overview][] 1. [Basic Operators][] 1. [Header documentation](ReactiveCocoa) 1. Previously answered [Stack Overflow](https://github.com/ReactiveCocoa/ReactiveCocoa/wiki) questions and [GitHub issues](https://github.com/ReactiveCocoa/ReactiveCocoa/issues?labels=question&state=closed) 1. The rest of the [Documentation][] folder 1. [Functional Reactive Programming on iOS](https://leanpub.com/iosfrp/) (eBook) If you have any further questions, please feel free to [file an issue](https://github.com/ReactiveCocoa/ReactiveCocoa/issues/new). ## Introduction ReactiveCocoa is inspired by [functional reactive programming](http://blog.maybeapps.com/post/42894317939/input-and-output). Rather than using mutable variables which are replaced and modified in-place, RAC provides signals (represented by `RACSignal`) that capture present and future values. By chaining, combining, and reacting to signals, software can be written declaratively, without the need for code that continually observes and updates values. For example, a text field can be bound to the latest time, even as it changes, instead of using additional code that watches the clock and updates the text field every second. It works much like KVO, but with blocks instead of overriding `-observeValueForKeyPath:ofObject:change:context:`. Signals can also represent asynchronous operations, much like [futures and promises][]. This greatly simplifies asynchronous software, including networking code. One of the major advantages of RAC is that it provides a single, unified approach to dealing with asynchronous behaviors, including delegate methods, callback blocks, target-action mechanisms, notifications, and KVO. Here's a simple example: ```objc // When self.username changes, logs the new name to the console. // // RACObserve(self, username) creates a new RACSignal that sends the current // value of self.username, then the new value whenever it changes. // -subscribeNext: will execute the block whenever the signal sends a value. [RACObserve(self, username) subscribeNext:^(NSString *newName) { NSLog(@"%@", newName); }]; ``` But unlike KVO notifications, signals can be chained together and operated on: ```objc // Only logs names that starts with "j". // // -filter returns a new RACSignal that only sends a new value when its block // returns YES. [[RACObserve(self, username) filter:^(NSString *newName) { return [newName hasPrefix:@"j"]; }] subscribeNext:^(NSString *newName) { NSLog(@"%@", newName); }]; ``` Signals can also be used to derive state. Instead of observing properties and setting other properties in response to the new values, RAC makes it possible to express properties in terms of signals and operations: ```objc // Creates a one-way binding so that self.createEnabled will be // true whenever self.password and self.passwordConfirmation // are equal. // // RAC() is a macro that makes the binding look nicer. // // +combineLatest:reduce: takes an array of signals, executes the block with the // latest value from each signal whenever any of them changes, and returns a new // RACSignal that sends the return value of that block as values. RAC(self, createEnabled) = [RACSignal combineLatest:@[ RACObserve(self, password), RACObserve(self, passwordConfirmation) ] reduce:^(NSString *password, NSString *passwordConfirm) { return @([passwordConfirm isEqualToString:password]); }]; ``` Signals can be built on any stream of values over time, not just KVO. For example, they can also represent button presses: ```objc // Logs a message whenever the button is pressed. // // RACCommand creates signals to represent UI actions. Each signal can // represent a button press, for example, and have additional work associated // with it. // // -rac_command is an addition to NSButton. The button will send itself on that // command whenever it's pressed. self.button.rac_command = [[RACCommand alloc] initWithSignalBlock:^(id _) { NSLog(@"button was pressed!"); return [RACSignal empty]; }]; ``` Or asynchronous network operations: ```objc // Hooks up a "Log in" button to log in over the network. // // This block will be run whenever the login command is executed, starting // the login process. self.loginCommand = [[RACCommand alloc] initWithSignalBlock:^(id sender) { // The hypothetical -logIn method returns a signal that sends a value when // the network request finishes. return [client logIn]; }]; // -executionSignals returns a signal that includes the signals returned from // the above block, one for each time the command is executed. [self.loginCommand.executionSignals subscribeNext:^(RACSignal *loginSignal) { // Log a message whenever we log in successfully. [loginSignal subscribeCompleted:^{ NSLog(@"Logged in successfully!"); }]; }]; // Executes the login command when the button is pressed. self.loginButton.rac_command = self.loginCommand; ``` Signals can also represent timers, other UI events, or anything else that changes over time. Using signals for asynchronous operations makes it possible to build up more complex behavior by chaining and transforming those signals. Work can easily be triggered after a group of operations completes: ```objc // Performs 2 network operations and logs a message to the console when they are // both completed. // // +merge: takes an array of signals and returns a new RACSignal that passes // through the values of all of the signals and completes when all of the // signals complete. // // -subscribeCompleted: will execute the block when the signal completes. [[RACSignal merge:@[ [client fetchUserRepos], [client fetchOrgRepos] ]] subscribeCompleted:^{ NSLog(@"They're both done!"); }]; ``` Signals can be chained to sequentially execute asynchronous operations, instead of nesting callbacks with blocks. This is similar to how [futures and promises][] are usually used: ```objc // Logs in the user, then loads any cached messages, then fetches the remaining // messages from the server. After that's all done, logs a message to the // console. // // The hypothetical -logInUser methods returns a signal that completes after // logging in. // // -flattenMap: will execute its block whenever the signal sends a value, and // returns a new RACSignal that merges all of the signals returned from the block // into a single signal. [[[[client logInUser] flattenMap:^(User *user) { // Return a signal that loads cached messages for the user. return [client loadCachedMessagesForUser:user]; }] flattenMap:^(NSArray *messages) { // Return a signal that fetches any remaining messages. return [client fetchMessagesAfterMessage:messages.lastObject]; }] subscribeNext:^(NSArray *newMessages) { NSLog(@"New messages: %@", newMessages); } completed:^{ NSLog(@"Fetched all messages."); }]; ``` RAC even makes it easy to bind to the result of an asynchronous operation: ```objc // Creates a one-way binding so that self.imageView.image will be set as the user's // avatar as soon as it's downloaded. // // The hypothetical -fetchUserWithUsername: met