diff --git a/Part 1 - Getting Started/1. Why Rx.md b/Part 1 - Getting Started/1. Why Rx.md
index 339ee02..172298b 100644
--- a/Part 1 - Getting Started/1. Why Rx.md
+++ b/Part 1 - Getting Started/1. Why Rx.md
@@ -1,49 +1,49 @@
-# PART 1 - Getting started
+# Часть 1 - Введение
-## Why Rx
+## Почему Rx?
-> Users expect real time data. They want their tweets now. Their order confirmed now. They need prices accurate as of now. Their online games need to be responsive. As a developer, you demand fire-and-forget messaging. You don't want to be blocked waiting for a result. You want to have the result pushed to you when it is ready. Even better, when working with result sets, you want to receive individual results as they are ready. You do not want to wait for the entire set to be processed before you see the first row. The world has moved to push; users are waiting for us to catch up. Developers have tools to push data, this is easy. Developers need tools to react to push data
+> Пользователи ожидают данных в реальном времени. Они хотят твиты сейчас. Подтверждение заказа сейчас. Им необходимы цены по состоянию на сейчас. Как разработчик, вы нуждаетесь в самонаводящихся сообщениях. Вы не хотите быть блокированным в ожидании результата. Вы хотите, чтобы результат пришел к вам по готовности. Даже более того, вы хотите работать с результатом по частям: вы не хотите ждать пока загрузится всё перед тем как отобразить первую строку. Мир перешел в режим уведомлений. У разработчиков есть инструменты, чтобы уведомлять, это легко. Им нужны инструменты чтобы реагировать на уведомления.
-Welcome to Rx. This book is based on [Rx.NET](http://msdn.microsoft.com/en-us/devlabs/gg577609)'s www.introtorx.com and it introduces beginners to [RxJava](https://github.com/ReactiveX/RxJava), the Netflix implementation of the original Microsoft library. Rx is a powerful tool that enables the solution of problems in an elegant declarative style, familiar to functional programmers. Rx has several benefits:
+Добро пожаловать в Rx. Rx – это мощный инструмент, который позволяет решать проблемы в элегантном декларативном стиле, присущем функциональному программированию. Rx обладает следующими преимуществами:
-* Unitive
- * Queries in Rx are done in the same style as other libraries inspired by functional programming, such as Java streams. In Rx, one can use functional style transformations on event streams.
-* Extensible
- * RxJava can be extended with custom operators. Although Java does not allow for this to happen in an elegant way, RxJava offers all the extensibility one can find Rx implementations in other languages.
-* Declarative
- * Functional transformations are read in a declarative way.
-* Composable
- * Rx operators can be combined to produce more complicated operations.
-* Transformative
- * Rx operators can transform one type of data to another, reducing, mapping or expanding streams as needed.
+* Интуитивность
+ * Действия в Rx описываются в таком же стиле, как и в других библиотеках вдохновленных функциональным программированием, например, Java Streams. Rx дает возможность использовать функциональные трансформации над потоками событий.
+* Расширяемость
+ * RxJava может быть расширена пользовательскими операторами. И хотя Java не позволяет сделать это элегантным образом, RxJava предлагает всю расширяемость доступную в реализациях Rx на любом другом языке.
+* Декларативность
+ * Функциональные трансформации объявлены декларативно.
+* Компонуемость
+ * Операторы в Rx легко компонуются, чтобы проводить сложные операции.
+* Преобразуемость
+ * Операторы в Rx могут трансформировать типы данных, фильтруя, обрабатывая и расширяя потоки данных при необходимости.
-## When is Rx appropriate?
+## Когда следует использовать Rx?
-Rx is fit for composing and consuming sequences of events. We present some of the use cases for Rx, according to www.introtorx.com
+Rx применяется для составления и обработки последовательностей событий.
-### Should use Rx
+### Следует использовать Rx
-* UI events like mouse move, button click
-* Domain events like property changed, collection updated, "Order Filled", "Registration accepted" etc.
-* Infrastructure events like from file watcher, system and WMI events
-* Integration events like a broadcast from a message bus or a push event from WebSockets API or other low latency middleware like Nirvana
-* Integration with a CEP engine like StreamInsight or StreamBase.
+* UI события, такие как mouse move, button click
+* События вроде изменения свойства, обновления коллекции, «Заказ оформлен», «Регистрация закончена» и т.д.
+* Инфраструктурные события (сообщения от системы, WMI или файловых менеджеров)
+* Интеграция с событиями от шины сообщений (message bus), сообщениями из WebSocket API
+* Интеграция с [CEP-системами](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D0%B1%D1%8B%D1%82%D0%B8%D0%B9) (StreamInsight, StreamBas)
-### Could use Rx
+### Возможно использование Rx
-* Result of `Future` or equivalent pattern
+* Результат Future или похожего паттерна
-Those patterns are already well adopted and you may find that introducing Rx on top of that does not add to the development process.
+Подобные паттерны и так хорошо выполняют свои функции и может оказаться, что использование Rx поверх них не принесет особой выгоды в разработке.
-### Won't use Rx
+### Не следует использовать Rx
-* Translating iterables to observables, just for the sake of working on them through an Rx library.
+* Для превращения Iterable в Observable только для того, чтобы работать с ними через библиотеку Rx.
-##### Continue reading
+##### Продолжить чтение
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| | [Key types](/Part 1 - Getting Started/2. Key types.md) |
+| | [Ключевые типы](/Part 1 - Getting Started/2. Key types.md) |
diff --git a/Part 1 - Getting Started/2. Key types.md b/Part 1 - Getting Started/2. Key types.md
index 12ac033..d93424b 100644
--- a/Part 1 - Getting Started/2. Key types.md
+++ b/Part 1 - Getting Started/2. Key types.md
@@ -1,107 +1,95 @@
-# Key types
-
-Rx is based around two fundamental types, while several others expand the functionality around the core types. Those two core types are the `Observable` and the `Observer`, which will be introduced in this chapter. We will also introduce `Subject`s, which ease the learning curve.
-
-Rx builds upon the [Observer](http://en.wikipedia.org/wiki/Observer_pattern) pattern. It is not unique in doing so. Event handling already exists in Java (e.g. JavaFX's EventHandler). Those are simpler approaches, which suffer in comparison to Rx:
-
-* Events through event handlers are hard to compose.
-* They cannot be queried over time
-* They can lead to memory leaks
-* These is no standard way of signaling completion.
-* Require manual handling of concurrency and multithreading.
-
-## Observable
-
-[Observable](http://reactivex.io/RxJava/javadoc/rx/Observable) is the first core element that we will see. This class contains a lot of the implementation of Rx, including all of the core operators. We will be examining it step by step throughout this book. For now, we must understand the `Subscribe` method. Here is one key overload of the method:
-
-```java
-public final Subscription subscribe(Subscriber subscriber)
-```
-
-This is the method that you use to receive the values emitted by the observable. As the values come to be pushed (through policies that we will discuss throughout this book), they are pushed to the subscriber, which is then responsible for the behaviour intended by the consumer. The `Subscriber` here is an implementation of the `Observer` interface.
-
-An observable pushes 3 kinds of events
-* Values
-* Completion, which indicates that no more values will be pushed.
-* Errors, if something caused the sequence to fail. These events also imply termination.
-
-
-## Observer
-
-We already saw one abstract implementation of the [Observer](http://reactivex.io/RxJava/javadoc/rx/Observer.html), `Subscriber`. `Subscriber` implements some extra functionality and should be used as the basis for our implementations of `Observer`. For now, it is simpler to first understand the interface.
-
-```java
+Ключевые типы
+Rx базируется на двух фундаментальных типах, в то время, как некоторые другие расширяют их функциональность. Этими базовыми типами являются Observable и Observer, которые мы и рассмотрим в этом разделе. Мы также рассмотрим Subject’ы – они помогут в понимании основных концепций Rx.
+
+Rx построена на паттерне Observer. В этом нет ничего нового, обработчики событий уже существуют в Java (например, JavaFX EventHandler[1]), однако они проигрывают в сравнении с Rx по следующим причинам:
+
+ - Обработку событий в них сложно компоновать
+ - Их вызов нельзя отложить
+ - Могут привести к утечке памяти
+ - Не существует простого способа сообщить об окончании потока событий
+ - Требуют ручного управления многопоточностью.
+
+Observable
+Observable – первый базовый тип, который мы рассмотрим. Этот класс содержит в себе основную часть реализации Rx, включая все базовые операторы. Мы рассмотрим их позже, а пока нам следует понять принцип работы метода subscribe. Вот ключевая перегрузка [2]:
+
+```JAVA
+public final Subscription subscribe(Observer observer)
+```
+Метод subscribe используется для получения данных выдаваемых [3] observable. Эти данные передаются наблюдателю, который предполагает их обработку в зависимости от требований потребителя. Наблюдатель в этом случае является реализацией интерфейса Observer.
+
+Observable сообщает три вида событий:
+
+ - Данные
+ - Сигнал о завершении последовательности [4] (что означает, что новых данных больше не будет)
+ - Ошибку, если последовательность завершилась по причине исключительной ситуации (это событие так же предполагает завершение последовательности)
+
+Observer
+В Rx предусмотрена абстрактная реализация Observer, Subscriber. Subscriber реализует дополнительную функциональность и, как правило, именно его следует использовать для реализации Observer. Однако, для начала, рассмотрим только интерфейс:
+
+```JAVA
interface Observer {
void onCompleted();
void onError(java.lang.Throwable e);
void onNext(T t);
}
```
+Эти три метода являются поведением, которое описывает реакцию наблюдателя на сообщение от observable. onNext у наблюдателя будет вызван 0 или более раз, опционально сопровождаясь onCompleted или onError. После них вызовов больше не будет.
-Those three methods are the behaviour that is executed every time the observable pushes a value. The observer will have its `onNext` called zero or more times, optionally followed by an `onCompleted` or an `onError`. No calls happen after a call to `onError` or `onCompleted`.
-
-When developing Rx code, you'll see a lot of `Observable`, but not so much of `Observer`. While it is important to understand the `Observer`, there are shorthands that remove the need to instantiate it yourself.
-
-
-## Implementing Observable and Observer
-
-You could manually implement `Observer` or extend `Observable`. In reality that will usually be unnecessary, since Rx already provides all the building blocks you need. It is also dangerous, as interaction between parts of Rx includes conventions and internal plumming that are not obvious to a beginner. It is both simpler and safer to use the many tools that Rx gives you for generating the functionality that you need.
-
-To subscribe to an observable, it is not necessary to provide instances of `Observer` at all. There are overloads to `subscribe` that simply take the functions to be executed for `onNext`, `onError` and `onSubscribe`, hiding away the instantiation of the corresponding `Observer`. It is not even necessary to provide each of those functions. You can provide a subset of them, i.e. just `onNext` or just `onNext` and `onError`.
+Разрабатывая код с помощью Rx, вы увидите много Observable, но намного меньше Observer. И хотя и необходимо понимать концепцию Observer, существуют способы, не требующие непосредственного создания его экземпляра.
-The introduction of lambda functions in Java 1.8 makes these overloads very convenient for the short examples that exist in this book.
+Реализация Observable и Observer
+Вы можете вручную реализовать Observer и Observable. В реальности в этом, как правило, нет необходимости: Rx предоставляет готовые решения, чтобы упростить разработку. Это также может быть не совсем безопасно, поскольку взаимодействие между частями библиотеки Rx включает в себя принципы и внутреннюю инфраструктуру, которые могут быть неочевидны новичку. В любом случае, будет проще для начала использовать множество инструментов, уже предоставленных библиотекой для создания необходимого нам функционала.
-## Subject
+Чтобы подписаться на observable, совсем нет необходимости в реализации Observer. Существуют другие перегрузки метода subscribe, которые принимают в качестве аргументов соответствующие функции для onNext, onError и onSubscribe, инкапсулирующие создание экземпляра Observer. Предоставлять их всех тоже не обязательно, вы можете описать только часть из них, например, только onNext или только onNext и onError.
-Subjects are an extension of the `Observable` that also implements the `Observer` interface. The idea may sound odd at first, but they make things a lot simpler in some cases. They can have events pushed to them (like observers), which they then push further to their own subscribers (like observables). This makes them ideal entry points into Rx code: when you have values coming in from outside of Rx, you can push them into a `Subject`, turning them into an observable. You can think of them as entry points to an Rx pipeline.
+Лямбда-выражения в Java 1.8 делают эти перегрузки очень подходящими для использования в коротких примерах этой серии статей.
-`Subject` has two parameter types: the input type and the output type. This was designed so for the sake of abstraction and not because the common uses for subjects involve transforming values. There are transformation operators to do that, which we will see later.
+Subject
+Subject’ы являются расширением Observable, одновременно реализуя интерфейс Observer. Идея может показаться странной, но в определенных случаях они делают некоторые вещи намного проще. Они могут принимать сообщения о событиях (как observer) и сообщать о них своим подписчикам (как observable). Это делает их идеальной отправной точкой для знакомства с Rx кодом: когда у вас есть данные, поступающие извне, вы можете передать их в Subject, превращая их таким образом в observable.
-There are a few different implementations of `Subject`. We will now examine the most important ones and their differences.
+Существует несколько реализаций Subject. Сейчас мы рассмотрим самые важные из них.
-### PublishSubject
+PublishSubject
+PublishSubject – самая простая реализация Subject. Когда данные передаются в PublishSubject, он выдает их всем подписчикам, которые подписаны на него в данный момент.
-`PublishSubject` is the most straight-forward kind of subject. When a value is pushed into a `PublishSubject`, the subject pushes it to every subscriber that is subscribed to it at that moment.
-
-```java
+```JAVA
public static void main(String[] args) {
- PublishSubject subject = PublishSubject.create();
- subject.onNext(1);
- subject.subscribe(System.out::println);
- subject.onNext(2);
- subject.onNext(3);
- subject.onNext(4);
+ PublishSubject subject = PublishSubject.create();
+ subject.onNext(1);
+ subject.subscribe(System.out::println);
+ subject.onNext(2);
+ subject.onNext(3);
+ subject.onNext(4);
}
```
-[Output](/tests/java/itrx/chapter1/PublishSubjectExample.java)
-```
+Вывод:
+```JAVA
2
3
4
```
+Как мы видим, 1 не была напечатана из-за того, что мы не были подписаны в момент, когда она была передана. После того как мы подписались, мы начали получать все значения, поступающие в subject.
-As we can see in the example, `1` isn't printed because we weren't subscribed when it was pushed. After we subscribed, we began receiving the values that were pushed to the subject.
-
-This is the first time we see `subscribe` being used, so it is worth paying attention to how it was used. In this case, we used the overload which expects one [Function](http://reactivex.io/RxJava/javadoc/rx/functions/Function.html) for the case of onNext. That function takes an argument of type `Integer` and returns nothing. Functions without a return type are also called actions. We can provide that function in different ways:
-* we can supply an instance of `Action1`,
-* implicitly create one using a [lambda expression](http://en.wikipedia.org/wiki/Anonymous_function#Java) or
-* pass a reference to an existing method that fits the signature.
-In this case, `System.out::println` has an overload that accepts `Object`, so we passed a reference to it. `subscribe` will call `println` with the arriving values as the argument.
+Здесь мы впервые используем метод subscribe, так что стоит уделить этому внимание. В данном случае мы используем перегруженную версию, которая принимает один объект класса Function, отвечающий за onNext. Эта функция принимает значение типа Integer и ничего не возвращает. Функции, которые ничего не возвращают, также называются actions. Мы можем передать эту функцию следующими способами:
+
+ - Предоставить объект класса Action1<Integer>
+ - Неявно создать таковой, используя лямбда-выражение
+ - Передать ссылку на существующий метод с соответствующей сигнатурой. В данном случае, System.out::println имеет перегруженную версию, которая принимает Object, поэтому мы передаем ссылку на него. Таким образом, подписка позволяет нам печатать в основной поток вывода все поступающие в Subject числа.
+
-### ReplaySubject
+ReplaySubject
+ReplaySubject имеет специальную возможность кэшировать все поступившие в него данные. Когда у него появляется новый подписчик, последовательность выдается ему, начиная с начала. Все последующие поступившие данные будут выдаваться подписчикам как обычно.
-`ReplaySubject` has the special feature of caching all the values pushed to it. When a new subscription is made, the event sequence is replayed from the start for the new subscriber. After catching up, every subscriber receives new events as they come.
-
-```java
-ReplaySubject s = ReplaySubject.create();
+```JAVA
+ReplaySubject s = ReplaySubject.create();
s.subscribe(v -> System.out.println("Early:" + v));
s.onNext(0);
s.onNext(1);
-s.subscribe(v -> System.out.println("Late: " + v));
+s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(2);
```
-[Output](/tests/java/itrx/chapter1/ReplaySubjectExample.java)
-```
+Вывод
+```JAVA
Early:0
Early:1
Late: 0
@@ -109,103 +97,81 @@ Late: 1
Early:2
Late: 2
```
+Все значения были получены, несмотря на то, что один из подписчиков подписался позже другого. Обратите внимание, что до того как получить новое значение, подписчик получает все пропущенные. Таким образом, порядок последовательности для подписчика не нарушен.
-All the values are received by the subscribers, even though one was late. Also notice that the late subscriber had everything replayed to it before proceeding to the next value.
+Кэшировать всё подряд не всегда лучшая идея, так как последовательности могут быть длинными или даже бесконечными. Фабричный метод ReplaySubject.createWithSize ограничивает размер буфера, а ReplaySubject.createWithTime время, которое объекты будут оставаться в кэше.
-Caching everything isn't always a good idea, as an observable sequence can run for a long time. There are ways to limit the size of the internal buffer. `ReplaySubject.createWithSize` limits the size of the buffer, while `ReplaySubject.createWithTime` limits how long an object can stay cached.
-
-```java
-ReplaySubject s = ReplaySubject.createWithSize(2);
+```JAVA
+ReplaySubject s = ReplaySubject.createWithSize(2);
s.onNext(0);
s.onNext(1);
s.onNext(2);
-s.subscribe(v -> System.out.println("Late: " + v));
+s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
-[Output](/tests/java/itrx/chapter1/ReplaySubjectExample.java)
-```
+Вывод
+```JAVA
Late: 1
Late: 2
Late: 3
```
+Наш подписчик на этот раз пропустил первое значение, которое выпало из буфера размером 2. Таким же образом со временем из буфера выпадают объекты у
+Subject созданного при помощи createWithTime.
-Our late subscriber now missed the first value, which fell off the buffer of size 2. Similarily, old values fall off the buffer as time passes, when the subject is created with `createWithTime`
-
-```java
-ReplaySubject s = ReplaySubject.createWithTime(150, TimeUnit.MILLISECONDS,
- Schedulers.immediate());
+```JAVA
+ReplaySubject s = ReplaySubject.createWithTime(150, TimeUnit.MILLISECONDS, Schedulers.immediate());
s.onNext(0);
Thread.sleep(100);
s.onNext(1);
Thread.sleep(100);
s.onNext(2);
-s.subscribe(v -> System.out.println("Late: " + v));
+s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
-[Output](/tests/java/itrx/chapter1/ReplaySubjectExample.java)
-```
+Вывод
+```JAVA
Late: 1
Late: 2
Late: 3
```
+Создание ReplaySubject с ограничением по времени требует объект планировщика (Scheduler), который является представлением времени в Rx. Мы обязательно вернемся к планировщикам в разделе про многопоточность.
-Creating a `ReplaySubject` with time requires a `Scheduler`, which is Rx's way of keeping time. Feel free to ignore this for now, as we will properly introduce schedulers in the chapter about concurrency.
-
-`ReplaySubject.createWithTimeAndSize` limits both, which ever comes first.
-
-### BehaviorSubject
+ReplaySubject.createWithTimeAndSize ограничивает буфер по обоим параметрам.
-`BehaviorSubject` only remembers the last value. It is similar to a `ReplaySubject` with a buffer of size 1. An initial value can be provided on creation, therefore guaranteeing that a value always will be available immediately on subscription.
+BehaviorSubject
+BehaviorSubject хранит только последнее значение. Это то же самое, что и ReplaySubject, но с буфером размером 1. Во время создания ему может быть присвоено начальное значение, таким образом гарантируя, что данные всегда будут доступны новым подписчикам.
-```java
+```JAVA
BehaviorSubject s = BehaviorSubject.create();
s.onNext(0);
s.onNext(1);
s.onNext(2);
-s.subscribe(v -> System.out.println("Late: " + v));
+s.subscribe(v -> System.out.println("Late: " + v));
s.onNext(3);
```
-[Output](/tests/java/itrx/chapter1/BehaviorSubjectExample.java)
-```
+Вывод
+```JAVA
Late: 2
Late: 3
```
+Начальное значение предоставляется для того, чтобы быть доступным еще до поступления данных.
-The following example just completes, since that is the last event.
-
-```java
-BehaviorSubject s = BehaviorSubject.create();
-s.onNext(0);
-s.onNext(1);
-s.onNext(2);
-s.onCompleted();
-s.subscribe(
- v -> System.out.println("Late: " + v),
- e -> System.out.println("Error"),
- () -> System.out.println("Completed")
-);
-```
-
-An initial value is provided to be available if anyone subscribes before the first value is pushed.
-
-```java
+```JAVA
BehaviorSubject s = BehaviorSubject.create(0);
s.subscribe(v -> System.out.println(v));
s.onNext(1);
```
-[Output](/tests/java/itrx/chapter1/BehaviorSubjectExample.java)
-```
+Вывод
+```JAVA
0
1
```
+Так как роль BehaviorSubject – всегда иметь доступные данные, считается неправильным создавать его без начального значения так же, как и завершать его.
-Since the defining role of a `BehaviorSubject` is to always have a value readily available, it is unusual to create one without an initial value. It is also unusual to terminate one.
-
-### AsyncSubject
+AsyncSubject
+AsyncSubject также хранит последнее значение. Разница в том, что он не выдает данных до тех пор, пока не завершится последовательность. Его используют, когда нужно выдать единое значение и тут же завершиться.
-`AsyncSubject` also caches the last value. The difference now is that it doesn't emit anything until the sequence completes. Its use is to emit a single value and immediately complete.
-
-```java
+```JAVA
AsyncSubject s = AsyncSubject.create();
s.subscribe(v -> System.out.println(v));
s.onNext(0);
@@ -213,18 +179,16 @@ s.onNext(1);
s.onNext(2);
s.onCompleted();
```
-[Output](/tests/java/itrx/chapter1/AsyncSubjectExample.java)
-```
+Вывод
+```JAVA
2
```
+Обратите внимание, что если бы мы не вызвали s.onCompleted(), этот код ничего бы не напечатал.
-Note that, if we didn't do `s.onCompleted();`, this example would have printed nothing.
-
-## Implicit contracts
+Неявная инфраструктура
+Как мы уже упоминали, существуют принципы, которые могут быть неочевидны в коде. Один из важнейших заключается в том, что ни одно событие не будет выдано после того, как последовательность завершена (onError или onCompleted). Реализация subject’ уважает эти принципы:
-As we already mentioned, there are contracts in Rx that are not obvious in the code. An important one is that no events are emitted after a termination event (`onError` or `onCompleted`). The implemented subjects respect that, and the `subscribe` method also prevents some violations of the contract.
-
-```java
+```JAVA
Subject s = ReplaySubject.create();
s.subscribe(v -> System.out.println(v));
s.onNext(0);
@@ -232,15 +196,20 @@ s.onCompleted();
s.onNext(1);
s.onNext(2);
```
-[Output](/tests/java/itrx/chapter1/RxContractExample.java)
-```
+Вывод
+```JAVA
0
```
+Безопасность не может быть гарантирована везде, где используется Rx, поэтому вам лучше быть в курсе и не нарушать этот принцип, так как это может привести к неопределенным последствиям.
-Safety nets like these are not guaranteed in the entirety of the implementation of Rx. It is best that you are mindful not to violate the contract, as this may lead to undefined behaviour.
+notes
+[1] Или знакомые всем Event Listeners. – Примеч. Автора
+[2] Я, все-таки считаю, что ключевой перегрузкой тут является именно версия с Observer в качестве аргумента, в оригинале в качестве примера приводится версия subscribe(Subscriber subscriber) – Примеч. Автора
+[3] Я буду использовать слово «выдавать», чтобы описать событие передачи данных от Observable Observer’у (to emit в ориг.). – Примеч. Автора
+[4] Автор использует термин последовательность (sequence), чтобы обозначить множество всех данных, которые может выдать Observable. – Примеч. Автора
-#### Continue reading
+#### Продолжить чтение
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| [Why Rx](/Part 1 - Getting Started/1. Why Rx.md) | [Lifetime management](/Part 1 - Getting Started/3. Lifetime management.md) |
+| [Почему Rx](/Part 1 - Getting Started/1. Why Rx.md) | [Жизненный цикл подписки](/Part 1 - Getting Started/3. Lifetime management.md) |
diff --git a/Part 2 - Sequence Basics/1. Creating a sequence.md b/Part 2 - Sequence Basics/1. Creating a sequence.md
index 392e6cb..376edb8 100644
--- a/Part 2 - Sequence Basics/1. Creating a sequence.md
+++ b/Part 2 - Sequence Basics/1. Creating a sequence.md
@@ -1,6 +1,6 @@
# Часть 2 - Основы последовательностей
-Теперь, когда мы понимаем основные принципы Rx, настало время научиться создавать и управлять последовательностями. Стиль управления последовательностями был позаимствован у оригинального C# [LINQ](https://en.wikipedia.org/wiki/Language_Integrated_Query), который в свою очередь был вдохновлен функциональным программироанием. Мы поделим все операции по темам, которые отсортированы в порядке возрастания сложности операций. Большинство операторов Rx управляют уже существующими последовательностями, но для начала мы научимся их создавать.
+Теперь, когда мы понимаем основные принципы Rx, настало время научиться создавать и управлять последовательностями. Стиль управления последовательностями был позаимствован у оригинального C# [LINQ](https://en.wikipedia.org/wiki/Language_Integrated_Query), который в свою очередь был вдохновлен функциональным программированием. Мы поделим все операции по темам, которые отсортированы в порядке возрастания сложности операций. Большинство операторов Rx управляют уже существующими последовательностями, но для начала мы научимся их создавать.
# Создание последовательности
@@ -59,7 +59,7 @@ Subscription subscription = values.subscribe(
);
```
-Код [выше](/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java) ничего не напечатает. Но это не означает что программа блокируется. По-факту она просто мгновенно завершается.
+Код [выше](/tests/java/itrx/chapter2/creating/ObservableFactoriesExample.java) ничего не напечатает. Но это не означает что программа блокируется. По факту она просто мгновенно завершается.
### Observable.error
@@ -95,7 +95,7 @@ now.subscribe(System.out::println);
1431443908375
```
-Обратите внимание как второй подписчик, подписавшись на секунду позже, получил такое же время. Это происходит потому что значение времени было вычислено лишь единажды: когда выполнение доходит до метода `just`. Однако в нашем случае мы хотим вычислять текущее время при каждой подписке. `defer` принимает функцию, которая возвращает `Observable` и будет выполнена для каждого нового подписчика.
+Обратите внимание как второй подписчик, подписавшись на секунду позже, получил такое же время. Это происходит потому что значение времени было вычислено лишь единожды: когда выполнение доходит до метода `just`. Однако в нашем случае мы хотим вычислять текущее время при каждой подписке. `defer` принимает функцию, которая возвращает `Observable` и будет выполнена для каждого нового подписчика.
```java
Observable now = Observable.defer(() ->
@@ -140,9 +140,9 @@ Completed
Когда кто-нибудь подпишется на наш `Observable` (в данном случае `values`), соответствующий экземпляр `Subscriber` будет передан в функцию `create`. По мере выполнения кода, значения будут переданы подписчику. Следует обратить внимание, что нужно самостоятельно вызывать метод `onCompleted` чтобы просигнализировать окончание последовательности.
-Данный метод является рекомендуемым способом создания `Observable` в случае если ни один из других способов не подходит. Это похоже на то, как мы создавали `Subject` и вручную подавали на него значения, однако есть несколько важных отличий. В первую очередь, источних событий аккуратно инкапсулирован и отделен от другого кода. Во-вторых, `Subject`'ы имеют неочевидные опасности: любой кто имеет доступ к обьекту сможет изменить последовательность. Мы еще вернемся к этой проблеме позже.
+Данный метод является рекомендуемым способом создания `Observable` в случае если ни один из других способов не подходит. Это похоже на то, как мы создавали `Subject` и вручную подавали на него значения, однако есть несколько важных отличий. В первую очередь, источник событий аккуратно инкапсулирован и отделен от другого кода. Во-вторых, `Subject`'ы имеют неочевидные опасности: любой кто имеет доступ к объекту сможет изменить последовательность. Мы еще вернемся к этой проблеме позже.
-Еще одним ключевым отличием от использования `Subject` является то, что код выполняется "lazily", только тогда когда прибывает новый подписчик. В примере выше, код выполняется _не_ в момент создания `Observable` (так как подписчиков еще нет), а в момент вызова метода `subscribe`. Это означает, что значения будет вычислены заново для каждого подписчика, как в `ReplaySubject`. Конечный результат похож на `ReplaySubject`, за исключением кеширования. С помощью `create` мы также можем легко перенести выполнение в отделный поток, в то время как с `ReplaySubject` нам приходилось бы вручную создавать потоки для вычисления значений. Мы еще рассмотрим способы сделать выполнение метода `onSubscribe` параллельным.
+Еще одним ключевым отличием от использования `Subject` является то, что код выполняется "lazily", только тогда когда прибывает новый подписчик. В примере выше, код выполняется _не_ в момент создания `Observable` (так как подписчиков еще нет), а в момент вызова метода `subscribe`. Это означает, что значения будет вычислены заново для каждого подписчика, как в `ReplaySubject`. Конечный результат похож на `ReplaySubject`, за исключением кеширования. С помощью `create` мы также можем легко перенести выполнение в отдельный поток, в то время как с `ReplaySubject` нам приходилось бы вручную создавать потоки для вычисления значений. Мы еще рассмотрим способы сделать выполнение метода `onSubscribe` параллельным.
Вы уже могли заметить что любой из предыдущих `Observable` можно реализовать при помощи `Observable.create`. Наш пример для `create` эквивалентен `Observable.just("hello")`.
@@ -163,7 +163,7 @@ Observable values = Observable.range(10, 15);
### Observable.interval
-Эта функция создаст _бесконечную_ последовательность значений, отделенных заданным интервалом времени.
+Эта функция создаст _бесконечную_ последовательность значений, разделенных заданным интервалом времени.
```java
Observable values = Observable.interval(1000, TimeUnit.MILLISECONDS);
@@ -243,7 +243,7 @@ Observable events = Observable.create(o -> {
## Observable.from
-Вы можете превратить любые входные данные в `Observable` при помощи `create`. Однако, для распространенных типов данных, существуют уже готовые методы, призваные облегчить этот процесс.
+Вы можете превратить любые входные данные в `Observable` при помощи `create`. Однако, для распространенных типов данных, существуют уже готовые методы, призванные облегчить этот процесс.
`Future`'ы являются частью Java и вы должно быть сталкивались с ними во время работы с фреймворками использующими многопоточность. Они являются менее мощным многопоточным инструментом чем Rx, так как возвращают только одно значение. Как правило, вы захотите превратить их в `Observable`.
@@ -268,7 +268,7 @@ Received: 21
Completed
```
-`Observable` выдает результат `FutureTask` по-готовности, после чего завершается. Если задача была отменена, observable выдаст ошибку `java.util.concurrent.CancellationException`.
+`Observable` выдает результат `FutureTask` по готовности, после чего завершается. Если задача была отменена, observable выдаст ошибку `java.util.concurrent.CancellationException`.
Если вы заинтересованы в результате `Future` только ограниченное время, существует возможность задать таймаут в качестве аргумента.
@@ -277,7 +277,7 @@ Observable values = Observable.from(f, 1000, TimeUnit.MILLISECONDS);
```
Если за это время `Future` не завершится, observable проигнорирует результат и выдаст `TimeoutException`.
-С помощью `Observable.from` можно превратить любую коллекцию в последовательность. Будет создан `Observable`, выдающий каждый элемент коллекции по-отдельности и `onCompleted` в конце.
+С помощью `Observable.from` можно превратить любую коллекцию в последовательность. Будет создан `Observable`, выдающий каждый элемент коллекции по отдельности и `onCompleted` в конце.
```java
Integer[] is = {1,2,3};
@@ -298,10 +298,8 @@ Completed
`Observable` это не то же что `Iterable` или `Stream`. `Observable` push-ориентированный, в том смысле, что вызов `onNext` провоцирует стек обработчиков выполниться вплоть до последнего `subscribe` метода. Остальные модели pull-ориентированные - значения в них запрашиваются с другой стороны и выполнение блокируется до возвращения результата.
-[Reducing a sequence](/Part 2 - Sequence Basics/2. Reducing a sequence.md) |
+#### Читать далее
-#### Continue reading
-
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| [Lifetime management](/Part 1 - Getting Started/3. Lifetime management.md) |
\ No newline at end of file
+| [Жизненный цикл подписки](/Part 1 - Getting Started/3. Lifetime management.md) | [Фильтрация последовательности](/Part 2 - Sequence Basics/2. Reducing a sequence.md) |
diff --git a/Part 2 - Sequence Basics/2. Reducing a sequence.md b/Part 2 - Sequence Basics/2. Reducing a sequence.md
index 508fa9f..c5c824c 100644
--- a/Part 2 - Sequence Basics/2. Reducing a sequence.md
+++ b/Part 2 - Sequence Basics/2. Reducing a sequence.md
@@ -1,18 +1,18 @@
-# Reducing a sequence
+# Фильтрация последовательности
-The examples we've seen so far were all very small. Nothing should stop you from using Rx on a huge stream of realtime data, but what good would Rx be if it dumped the whole bulk of the data onto you, and force you handle it like you would otherwise? Here we will explore operators that can filter out irrelevant data, or reduce the data to the single value that you want.
+Примеры которые мы видели до этого были достаточно малы. Ничто не должно удерживать вас от использования Rx при больших объемах данных, но что хорошего в Rx если он выбросит на вас весь объем данных, и оставит вас разбираться с этим своими силами? Здесь мы разберем операторы которые помогут отфильтровать ненужные данные, или сократить последовательность к единому нужному нам значению.
-Most of the operators here will be familiar to anyone who has worked with Java's `Stream`s or functional programming in general. All the operators here return a new observable and do _not_ affect the original observable. This principle is present throughout Rx. Transformations of observables create a new observable every time and leave the original unaffected. Subscribers to the original observable should notice no change, but we will see in later chapters that guaranteeing this may require caution from the developer as well.
+Большинство представленных операторов будут знакомы тем кто работал с Java `Stream API` или функциональным программированием. Все операторы возвращают новый объект Observable и _не_ влияют на оригинальный Observable. Этот принцип является ключевым в Rx. Преобразование Observable приводит к созданию нового Observable, оригинальный объект остается незатронутым. Подписчики(Subscribers) оригинального объекта не должны заметить никаких изменений, но как мы увидим дальше гарантирование этого принципа требует также осторожности от разработчика.
-### Marble diagrams
+### Диаграммы Marble
-This is an appropriate time to introduce to concept of marble diagrams. It is a popular way of explaining the operators in Rx, because of their intuitive and graphical nature. They are present a lot in the documentation of RxJava and it only makes sense that we take advantage of their explanatory nature. The format is mostly self-explanatory: time flows left to right, shapes represent values, a slash is an onCompletion, an X is an error. The operator is applied to the top sequence and the result is the sequence below.
+Это подходящий момент чтобы представить концепцию мраморных диаграмм. Это популярный метод иллюстрации работы операторов в Rx, так как он достаточно интуитивен и нагляден. Диаграммы присутствуют во многих местах документации по RxJava и есть смысл ориентироваться в них. Формат в основном описывает сам себя: время течет слева направо, фигуры представляют собой данные, прямая(‘|’) - onCompletion, Х - ошибка. Оператор применяется к верхней последовательности и возвращает последовательность снизу.
## Filter
-`filter` takes a predicate function that makes a boolean decision for each value emitted. If the decision is `false`, the item is omitted from the filtered sequence.
+`filter` - принимает функцию предикат которая рассчитывает и возвращает `true` или `false` для каждого испущенного элемента. Если решение ложно(`false`), элемент отбрасывается из фильтруемой последовательности.
```java
public final Observable filter(Func1 predicate)
@@ -20,7 +20,7 @@ public final Observable filter(Func1 predicate)
-We will use `filter` to create a sequence of numbers and filter out all the even ones, keeping only odd values.
+Отфильтруем последовательность чисел и оставим в ней только четные числа.
```java
Observable values = Observable.range(0,10);
@@ -33,7 +33,7 @@ Subscription oddNumbers = values
);
```
-[Output](/tests/java/itrx/chapter2/reducing/FilterExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/FilterExample.java)
```
0
2
@@ -43,9 +43,9 @@ Subscription oddNumbers = values
Completed
```
-## distinct and distinctUntilChanged
+## distinct и distinctUntilChanged
-`distinct` filters out any element that has already appeared in the sequence.
+`distinct` - отбрасывает элементы, которые уже встречались в последовательности.
@@ -67,7 +67,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
```
1
2
@@ -75,7 +75,7 @@ Subscription subscription = values
Completed
```
-An overload of distinct takes a key selector. For each item, the function generates a key and the key is then used to determine distinctiveness.
+Перегрузка `distinct` принимает функцию-селектор ключа. Для каждого элемента функция создает ключ который используется для сравнения уникальности элементов.
```java
public final Observable distinct(Func1 keySelector)
@@ -83,7 +83,7 @@ public final Observable distinct(Func1 keySelector
-In this example, we use the first character as a key.
+В этом примере используем первую букву в качестве ключа.
```java
Observable values = Observable.create(o -> {
@@ -103,7 +103,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
```
First
Second
@@ -111,11 +111,11 @@ Third
Completed
```
-"Fourth" and "Fifth" were filtered out because their first character is 'F' and that has already appeared in "First".
+"Fourth" и "Fifth" были отброшены так как начинаются с ‘F’, а этот ключ уже встречался в "First".
-An experienced programmer already knows that this operator maintains a set internally with every unique value that passes through the observable and checks every new value against it. While Rx operators neatly hide these things, you should still be aware that an Rx operator can have a significant cost and consider what you are using it on.
+Опытные программисты знают, что этот оператор сохраняет каждый уникальный элемент во внутреннем списке, который прошел через Observable, и проверяет наличие новых элементов в этом списке. Rx аккуратно скрывает такие вещи, вы должны быть в курсе, что это может привести к значительным вычислительным затратам.
-A variant of `distinct` is `distinctUntilChanged`. The difference is that only consecutive non-distinct values are filtered out.
+Разновидность `distinct` - `distinctUntilChanged`. Разница заключается в том, что последовательные неуникальные значения отбрасываются.
```java
public final Observable distinctUntilChanged()
@@ -142,7 +142,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
```
1
2
@@ -151,7 +151,7 @@ Subscription subscription = values
Completed
```
-You can you use a key selector with `distinctUntilChanged`, as well.
+Вы также можете использовать селектор ключа с `distinctUntilChanged`.
```java
Observable values = Observable.create(o -> {
@@ -171,7 +171,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/DistinctExample.java)
```
First
Second
@@ -182,7 +182,7 @@ Completed
## ignoreElements
-`ignoreElements` will ignore every value, but lets pass through `onCompleted` and `onError`.
+`ignoreElements` - игнорирует каждое значение, но пропускает `onCompleted` и `onError`.
```java
Observable values = Observable.range(0, 10);
@@ -195,20 +195,20 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/IgnoreExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/IgnoreExample.java)
```
Completed
```
-`ignoreElements()` produces the same result as `filter(v -> false)`
+`ignoreElements()` - производит такой же результат, что и `filter(v -> false)`
-## skip and take
+## skip и take
-The next group of methods serve to cut the sequence at a specific point based on the item's index, and either take the first part or the second part. `take` takes the first n elements, while `skip` skips them. Note that neither function considers it an error if there are fewer items in the sequence than the specified index.
+Следующая группа элементов служит для обрезания последовательности в определенной точке базируясь на индексе элемента, и возвращает либо первую либо вторую часть. `take` берет первые n элементов, в то время как `skip` пропускает их. Обратите внимание, что ни один из операторов не считает ошибкой если количество элементов в последовательности меньше указанного индекса.
```java
-Observable take(int num)
+Observable take(int num)
```
@@ -225,16 +225,16 @@ Subscription first2 = values
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
0
1
Completed
```
-Users of Java 8 streams should know the `take` operator as `limit`. The `limit` operator exists in Rx too, for symmetry purposes. It is an alias of `take`, but it lacks the richer overloads that we will soon see.
+Пользователи Stream API из Java 8 должны знать оператор `take` как `limit`. Оператор `limit` также присутствует в RxJava 1.X для тех же целей. Это синоним для `take`, но ему не достаёт перегрузок которые мы скоро увидим. В RxJava 2+ оператор `limit` был исключен.
-`take` completes as soon as the n-th item is available. If an error occurs, the error will be forwarded, but not if it occurs after the cutting point. `take` doesn't care what happens in the observable after the n-th item.
+`take` - завершится как только получит n-й элемент. Если произойдет ошибка, она будет проброшена в том случае если она произошла до n-го элемента. `take` - не заботится о том что произошло с Observable после n-го элемента, так как это уже другая, "родительская" последовательность.
```java
Observable values = Observable.create(o -> {
@@ -250,16 +250,16 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
1
Completed
```
-`skip` returns the other half of a `take`.
+`skip` возвращает оставшуюся часть от `take`.
```java
-Observable skip(int num)
+Observable skip(int num)
```
@@ -275,7 +275,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
2
3
@@ -283,11 +283,11 @@ Subscription subscription = values
Completed
```
-There are overloads where the cutoff is a moment in time rather than place in the sequence.
+Есть перегруженные версии операторов где последовательность обрезается в определенный момент времени а не на конкретном элементе.
```java
-Observable take(long time, java.util.concurrent.TimeUnit unit)
-Observable skip(long time, java.util.concurrent.TimeUnit unit)
+Observable take(long time, java.util.concurrent.TimeUnit unit)
+Observable skip(long time, java.util.concurrent.TimeUnit unit)
```
```java
@@ -301,7 +301,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
0
1
@@ -310,10 +310,10 @@ Completed
## skipWhile and takeWhile
-`take` and `skip` work with predefined indices. If you want to "discover" the cutoff point as the values come, `takeWhile` and `skipWhile` will use a predicate instead. `takeWhile` takes items while a predicate function returns `true`
+`take` и `skip` работают с предопределенными индексами. Однако, если вам нужно найти точку отсечения основываясь на входных данных используйте условные `takeWhile` и `skipWhile`. `takeWhile` пропускает значение пока функция предикат возвращает `true`.
```java
-Observable takeWhile(Func1 predicate)
+Observable takeWhile(Func1 predicate)
```
```java
@@ -327,14 +327,14 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
0
1
Completed
```
-As you would expect, `skipWhile` returns the other half of the sequence
+Как и ожидалось, `skipWhile` вернет оставшуюся часть последовательности.
```java
Observable values = Observable.interval(100, TimeUnit.MILLISECONDS);
@@ -347,7 +347,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
2
3
@@ -355,9 +355,9 @@ Subscription subscription = values
...
```
-## skipLast and takeLast
+## skipLast и takeLast
-`skipLast` and `takeLast` work just like `take` and `skip`, with the difference that the point of reference is from the end.
+`skipLast` и `takeLast` работают также как `take` и `skip`, с тем отличием, что точка отсечения отсчитывается с конца.
```java
Observable values = Observable.range(0,5);
@@ -370,22 +370,21 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
0
1
2
Completed
```
+К настоящему времени вы должны догадываться как соотносяться `takeLast` и `skipLast`. Также присутствуют перегрузки с индексами и со временем.
-By now you should be able to guess how `takeLast` is related to `skipLast`. There are overloads for both indices and time.
+## takeUntil и skipUntil
-## takeUntil and skipUntil
+Есть еще два метода - `takeUntil` и `skipUntil`. `takeUntil` работает точно так же как `takeWhile` за исключением того, что он принимает элементы пока предикат возвращает `false`. Так же ведет себя и `skipUntil`.
-There are also two methods named `takeUntil` and `skipUntil`. `takeUntil` works exactly like `takeWhile` except that it takes items while the predictate is false. The same is true of `skipUntil`.
-
-Along with that, `takeUntil` and `skipUntil` each have a very interesting overload. The cutoff point is defined as the moment when _another_ observable emits an item.
+Наряду с этим, `takeUntil` и` skipUntil` имеют очень интересную перегрузку. Точка отсечки определяется в момент, когда другой _Observable_ выдает новый элемент последовательности.
```java
public final Observable takeUntil(Observable other)
@@ -405,16 +404,15 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
0
1
Completed
```
+Как вы помните, `timer` ожидает 250мс и испускает одно событие. `takeUntil` реагирует на этот сигнал и останавливает последовательность. Обратите внимание что сигнал может быть любого типа, так как его значение не используется.
-As you may remember, `timer` here will wait 250ms and emit one event. This signals `takeUntil` to stop the sequence. Note that the signal can be of any type, since the actual value is not used.
-
-Once again `skipUntil` works by the same rules and returns the other half of the observable. Values are ignored until the signal comes to start letting values pass through.
+Еще раз, `skipUntil` работает по тем же правилам и возвращает вторую половину последовательности. Элементы игнорируются пока не придет сигнал о начале трансляции элементов насквозь.
```java
Observable values = Observable.interval(100,TimeUnit.MILLISECONDS);
@@ -428,7 +426,7 @@ Subscription subscription = values
() -> System.out.println("Completed")
);
```
-[Output](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
+[Вывод](/tests/java/itrx/chapter2/reducing/TakeSkipExample.java)
```
2
3
@@ -437,8 +435,8 @@ Subscription subscription = values
```
-#### Continue reading
+#### Продолжить чтение
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| [Creating a sequence](/Part 2 - Sequence Basics/1. Creating a sequence.md) | [Inspection](/Part 2 - Sequence Basics/3. Inspection.md) |
+| [Создание последовательности](/Part 2 - Sequence Basics/1. Creating a sequence.md) | [Исследование последовательности](/Part 2 - Sequence Basics/3. Inspection.md) |
diff --git a/Part 2 - Sequence Basics/3. Inspection.md b/Part 2 - Sequence Basics/3. Inspection.md
index 893edf6..c0ae5ca 100644
--- a/Part 2 - Sequence Basics/3. Inspection.md
+++ b/Part 2 - Sequence Basics/3. Inspection.md
@@ -1,13 +1,13 @@
-# Inspection
+# Исследование последовательности
-In the previous chapter we just saw ways to filter out data that we don't care about. Sometimes what we want is information about the sequence rather than the values themselves. We will now introduce some methods that allow us to reason about a sequence.
+В предыдущей главе мы изучали способы фильтрации данных которые важны для нас. Иногда информация о последовательности является более важной нежели ее значения. Сейчас мы рассмотрим некоторые методы, которые позволят нам рассуждать о содержимом последовательности.
## all
-The `all` method establishes that every value emitted by an observable meets a criterion. Here's the signature and an example:
+`all` - метод который проверяет, что каждое значение произведенное последовательностью отвечает заданному критерию. Вот сигнатура метода и пример:
```java
-public final Observable all(Func1 predicate)
+public final Observable all(Funk predicate)
```
```java
@@ -29,13 +29,14 @@ Subscription evenNumbers = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/AllExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/AllExample.java)
```
true
Completed
```
+Любопытный факт, то что этот метод возвращает последовательность с одним значением, а не логическое значение напрямую. Это все потому что неизвестно сколько времени потребуется чтоб определить ложный или истинный результат. Как только решение будет получено последовательность завершится, даже если исходная последовательность еще не завершилась. Как только предикат вернет `false` для некоторого значения, `false` - будет испущено. `true` не может быть испущено до тех пор пока исходная последовательность завершится и _все_ элементы будут проверены. Это удобный способ сделать операцию асинхронной.
-An interesting fact about this method is that it returns an observable with a single value, rather than the boolean value directly. This is because it is unknown how long it will take to establish whether the result should be true or false. Even though it completes as soon as it can know, that may take as long the source sequence itself. As soon as an item fails the predicate, `false` will be emitted. A value of `true` on the other hand cannot be emitted until the source sequence has completed and _all_ of the items are checked. Returning the decision inside an observable is a convenient way of making the operation non-blocking. We can see `all` failing as soon as possible in the next example:
+В следующем примере оператор `all` возвращает последовательность, которая выдает `false` сразу же после того как предикат возвращает `false` для элемента:
```java
Observable values = Observable.interval(150, TimeUnit.MILLISECONDS).take(5);
@@ -55,7 +56,7 @@ Subscription subscription2 = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/AllExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/AllExample.java)
```
0
1
@@ -67,7 +68,7 @@ All: Completed
Completed
```
-If the source observable emits an error, then `all` becomes irrelevant and the error passes through, terminating the sequence.
+Если исходная последовательность возвращает ошибку, тогда `all` также возвращает ошибку и последовательность завершается.
```java
Observable values = Observable.create(o -> {
@@ -85,12 +86,11 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/AllExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/AllExample.java)
```
Error: java.lang.Exception
```
-
-If, however, the predicate fails, then `false` is emitted and the sequence terminates. Even if the source observable fails after that, the event is ignored, as required by the Rx contract (no events after a termination event).
+В случае если ,предикат не удовлетворяет заданному критерию, тогда испускается `false` и последовательность завершается. Если исходная последовательность после этого завершиться с ошибкой, она будет проигнорирована, так как это требуют принципы Rx (никаких событий после события завершения).
```java
Observable values = Observable.create(o -> {
@@ -108,7 +108,7 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/AllExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/AllExample.java)
```
false
Completed
@@ -116,7 +116,7 @@ Completed
## exists
-The exists method returns an observable that will emit `true` if any of the values emitted by the observable make the predicate true.
+`exists` - возвращает `Observable`, который вернет `true` если хотя бы одно из значений наблюдаемой(исходной) последовательности будет соответствовать предикату.
@@ -132,13 +132,14 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/ExistsExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/ExistsExample.java)
```
false
Completed
```
-Here our range didn't go high enough for the `i > 2` condition to succeed. If we extend our range in the same example with
+Здесь наш диапазон недостаточно длинный чтоб выполнить условие `i > 2`. Если мы расширим диапазон с тем же условием:
+
```java
Observable values = Observable.range(0, 4);
```
@@ -150,7 +151,7 @@ Completed
## isEmpty
-This operator's result is a boolean value, indicating if an observable emitted values before completing or not.
+Оператор возвращает логическое значение указывающее выдавала ли исходная последовательность элементы до завершения или нет.
@@ -166,17 +167,16 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/IsEmptyExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/IsEmptyExample.java)
```
false
Completed
```
-
-Falsehood is established as soon as the first value is emitted. `true` will be returned once the source observable has terminated.
+`false` появится как только исходная последовательность выдаст значение. `true` будет выдано, если исходная последовательность завершится не выдав значений. Например `Observable.empty()`.
## contains
-The method `contains` establishes if a particular element is emitted by an observable. `contains` will use the `Object.equals` method to establish the equality. Just like previous operators, it emits its decision as soon as it can be established and immediately completes.
+Оператор `contains` определяет был ли испущен определенный элемент. `contains` использует `Object.equals` метод для определения эквивалентности. Так же как и предыдущие операторы, он испускает решение как только оно посчитано и сразу же завершается.
@@ -192,17 +192,17 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/ContainsExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/ContainsExample.java)
```
true
Completed
```
-If we had used `contains(4)` where we used `contains(4L)`, nothing would be printed. That's because `4` and `4L` are not equal in Java. Our code would wait for the observable to complete before returning false, but the observable we used is infinite.
+Если мы напишем `contains(4)` вместо `contains(4L)`, ничего не будет напечатано. Это потому что `4` и `4L` не эквивалентны в Java. Наш код будет ждать окончания последовательности до того как испустить `false`, но этого никогда не случится, так как наша последовательность бесконечна.
## defaultIfEmpty
-If an empty sequence would cause you problems, rather than checking with `isEmpty` and handling the case, you can force an observable to emit a value on completion if it didn't emit anything before completing.
+Если пустая последовательность оказалась пустой, вместо проверки на `isEmpty` и обработки вручную, вы можете заставить последовательность выдать значение "по умолчанию" перед завершением.
@@ -218,13 +218,13 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/DefaultIfEmptyExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/DefaultIfEmptyExample.java)
```
2
Completed
```
-The default value is emitted only if no other values appeared and only on successful completion. If the source is not empty, the result is just the source observable. In the case of the error, the default value will _not_ be emitted before the error.
+Если источник не будет пустым, результатом будет последовательность источника. В случае ошибки значение по умолчанию _не_ будет испущено перед событием ошибки.
```java
Observable values = Observable.error(new Exception());
@@ -238,14 +238,14 @@ Subscription subscription = values
);
```
-Output
+[Вывод]
```
Error: java.lang.Exception
```
## elementAt
-You can select exactly one element out of an observable using the `elementAt` method
+Вы можете выбрать один элемент из последовательности используя метод `elementAt`
@@ -261,13 +261,13 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/ElementAtExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/ElementAtExample.java)
```
102
Completed
```
-If the sequence doesn't have enough items, an `java.lang.IndexOutOfBoundsException` will be emitted. To avoid that specific case, we can provide a default value that will be emitted instead of an `IndexOutOfBoundsException`.
+Если последовательность недостаточной длины, будет выброшено исключение `java.lang.IndexOutOfBoundsException`. Чтоб предотвратить этот специфический случай, мы можем определить значение по умолчанию чтобы оно возвращалось взамен `IndexOutOfBoundsException`.
```java
Observable values = Observable.range(100, 10);
@@ -281,7 +281,7 @@ Subscription subscription = values
);
```
-[Output](/tests/java/itrx/chapter2/inspection/ElementAtExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/ElementAtExample.java)
```
0
Completed
@@ -289,7 +289,7 @@ Completed
## sequenceEqual
-The last operator for this chapter establishes that two sequences are equal by comparing the values at the same index. Both the size of the sequences and the values must be equal. The function will either use `Object.equals` or the function that you supply to compare values.
+Последний оператор представлений в этой главе, определяет являются ли две последовательности эквивалентны, сравнивая элементы с одинаковыми индексами. И размеры и значения последовательностей должны быть одинаковыми. Для сравнения используется `Object.equals` или ваша собственная функция для сравнения значений.
```java
Observable strings = Observable.just("1", "2", "3");
@@ -304,15 +304,15 @@ Observable.sequenceEqual(strings, ints, (s,i) -> s.equals(i.toString()))
);
```
-[Output](/tests/java/itrx/chapter2/inspection/SequenceEqualExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/SequenceEqualExample.java)
```
true
Completed
```
-If we swap the operator for the one that is commented out, i.e, the one using the standard `Object.equals`, the result would be `false`.
+Если мы будем использовать закомментированный оператор, он будет использовать `Object.equals` для сравнения, и результат окажется `false`.
-Failing is not part of the comparison. As soon as either sequence fails, the resulting observable forwards the error.
+Исключительная ситуация не является частью сравнения. Как только одна из последовательностей выйдет из строя, результирующая последовательность выдаст ошибку.
```java
Observable values = Observable.create(o -> {
@@ -329,13 +329,13 @@ Observable.sequenceEqual(values, values)
);
```
-[Output](/tests/java/itrx/chapter2/inspection/SequenceEqualExample.java)
+[Вывод](/tests/java/itrx/chapter2/inspection/SequenceEqualExample.java)
```
Error: java.lang.Exception
```
-#### Continue reading
+#### Продолжить чтение
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| [Reducing a sequence](/Part 2 - Sequence Basics/2. Reducing a sequence.md) | [Aggregation](/Part 2 - Sequence Basics/4. Aggregation.md) |
+| [Фильтрация последовательности](/Part 2 - Sequence Basics/2. Reducing a sequence.md) | [Агрегация](/Part 2 - Sequence Basics/4. Aggregation.md) |
diff --git a/README.md b/README.md
index 04a8584..c63b99e 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,32 @@
-# Intro to RxJava
+# Введение в RxJava
-This guide aims to introduce a beginner reactive programmer to the complete power of the [RxJava](https://github.com/ReactiveX/RxJava) implementation of reactive programming for the JVM. It is based on the [IntroToRx](http://www.introtorx.com) guide for Rx.NET.
+Этот туториал предназначен для знакомства начинающего реактивного программиста с мощью библиотеки [RxJava](https://github.com/ReactiveX/RxJava) — реализации принципов реактивного программирования для JVM. Это перевод обширного туториала по RxJava Крисса Фруссиоса, основанного на [IntroToRx](http://www.introtorx.com) для Rx.NET.
-No experience with either reactive or functional programming is needed to follow the book. Familiarity with the basics of Java is required.
+Для следования этой обучающей программе от вас не потребуются знания реактивного или функционального программирования, однако, предполагается наличие базовых знаний Java.
-[Begin learning](/Part 1 - Getting Started/1. Why Rx.md)
+[Начать изучение](/Part 1 - Getting Started/1. Why Rx.md)
-### Structure
+### Структура
-The content of this book is meant to be read from start to finish. It is bigger than your average tutorial and smaller than an actual book. It begins with the basics and every subsequent chapter introduces increasingly advanced features and concepts. Sections of the book are intended to be self-containing and to-the-point, so that the book can be referred back to by non-beginners.
+Материал этих статей рассчитан на прочтение от начала до конца. Его объем больше среднего туториала, но меньше реальной книги. Мы начнем с самых основ и, от раздела к разделу, будем переходить к всё более продвинутым сценариям и концепциям. Каждый раздел задумывался самодостаточным и лаконичным для того, чтобы к нему можно было вернуться в будущем.
-The examples used in the book are also [available in compilable java files](/tests/java/itrx) in two formats:
-* Examples that print to standard output (recommended for first-time readers)
-* Silent, self-checking examples in the form of [JUnit](http://junit.org/) tests.
-The readers are invited to study whichever style suits them best.
+Примеры к этим материалам доступны в двух видах:
+Примеры с выводом в консоль (рекоммендовано для читающих в первый раз)
+Самопроверяющиеся примеры в форме JUnit тестов
+
+
+[Примеры](/tests/java/itrx) к этим материалам доступны в двух видах:
+ * Примеры с выводом в консоль (рекомендовано для читающих в первый раз)
+ * Самопроверяющиеся примеры в форме JUnit тестов
+
+Используйте наиболее удобный для вас вариант.
+
+### В процессе перевода
+
+Многие части все еще не переведены. Помощь в виде пул-реквестов с переводами и исправлениями очень приветствуется.
+
+### Участники
+* [FARsh](https://github.com/FARsh)
+* [KlGleb](https://github.com/KlGleb)
+* [AnatolyBurtsev](https://github.com/anatolyburtsev)