diff --git a/Part 1 - Getting Started/1. Why Rx.md b/Part 1 - Getting Started/1. Why Rx.md index 5ea1fff..172298b 100644 --- a/Part 1 - Getting Started/1. Why Rx.md +++ b/Part 1 - Getting Started/1. Why Rx.md @@ -2,7 +2,7 @@ ## Почему Rx? -> Пользователи ожидают данных в реальном времени. Они хотят твиты сейчас. Подтвержение заказа сейчас. Им необходимы цены по состоянию на сейчас. Как разработчик, вы нуждаетесь в самонаводящихся сообщениях. Вы не хотите быть блокированным в ожидании результата. Вы хотите, чтобы результат пришел к вам по готовности. Даже более того, вы хотите работать с результатом по частям: вы не хотите ждать пока загрузится всё перед тем как отобразить первую строку. Мир перешел в режим уведомлений. У разработчиков есть инструменты, чтобы уведомлять, это легко. Им нужны инструменты чтобы реагировать на уведомления. +> Пользователи ожидают данных в реальном времени. Они хотят твиты сейчас. Подтверждение заказа сейчас. Им необходимы цены по состоянию на сейчас. Как разработчик, вы нуждаетесь в самонаводящихся сообщениях. Вы не хотите быть блокированным в ожидании результата. Вы хотите, чтобы результат пришел к вам по готовности. Даже более того, вы хотите работать с результатом по частям: вы не хотите ждать пока загрузится всё перед тем как отобразить первую строку. Мир перешел в режим уведомлений. У разработчиков есть инструменты, чтобы уведомлять, это легко. Им нужны инструменты чтобы реагировать на уведомления. Добро пожаловать в Rx. Rx – это мощный инструмент, который позволяет решать проблемы в элегантном декларативном стиле, присущем функциональному программированию. Rx обладает следующими преимуществами: @@ -11,7 +11,7 @@ * Расширяемость * RxJava может быть расширена пользовательскими операторами. И хотя Java не позволяет сделать это элегантным образом, RxJava предлагает всю расширяемость доступную в реализациях Rx на любом другом языке. * Декларативность - * Функциональные трансформации обьявлены декларативно. + * Функциональные трансформации объявлены декларативно. * Компонуемость * Операторы в Rx легко компонуются, чтобы проводить сложные операции. * Преобразуемость @@ -27,7 +27,7 @@ Rx применяется для составления и обработки п * UI события, такие как mouse move, button click * События вроде изменения свойства, обновления коллекции, «Заказ оформлен», «Регистрация закончена» и т.д. * Инфраструктурные события (сообщения от системы, WMI или файловых менеджеров) -* Интеграция с событиями от шины сообщений (message bus), сообщениями из WebScoket API +* Интеграция с событиями от шины сообщений (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) ### Возможно использование Rx diff --git a/Part 1 - Getting Started/2. Key types.md b/Part 1 - Getting Started/2. Key types.md index 627ff7f..d93424b 100644 --- a/Part 1 - Getting Started/2. Key types.md +++ b/Part 1 - Getting Started/2. Key types.md @@ -99,7 +99,7 @@ Late: 2 ``` Все значения были получены, несмотря на то, что один из подписчиков подписался позже другого. Обратите внимание, что до того как получить новое значение, подписчик получает все пропущенные. Таким образом, порядок последовательности для подписчика не нарушен. -Кэшировать всё подряд не всегда лучшая идея, так как последовательности могут быть длинными или даже бесконечными. Фабричный метод ReplaySubject.createWithSize ограничивает размер буфера, а ReplaySubject.createWithTime время, которое объекты будут оставаться в кеше. +Кэшировать всё подряд не всегда лучшая идея, так как последовательности могут быть длинными или даже бесконечными. Фабричный метод ReplaySubject.createWithSize ограничивает размер буфера, а ReplaySubject.createWithTime время, которое объекты будут оставаться в кэше. ```JAVA ReplaySubject s = ReplaySubject.createWithSize(2); diff --git a/Part 2 - Sequence Basics/1. Creating a sequence.md b/Part 2 - Sequence Basics/1. Creating a sequence.md index ced9f83..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}; diff --git a/Part 2 - Sequence Basics/2. Reducing a sequence.md b/Part 2 - Sequence Basics/2. Reducing a sequence.md index f2ff8fb..c5c824c 100644 --- a/Part 2 - Sequence Basics/2. Reducing a sequence.md +++ b/Part 2 - Sequence Basics/2. Reducing a sequence.md @@ -1,6 +1,6 @@ # Фильтрация последовательности -Примеры которые мы видели до этого были достаточно малы. Ничто не должно удерживать вас от использования Rx при больших объемах данных, но что хорошего в Rx если он выбросит на вас весь обьем данных, и оставит вас разбираться с этим своими силами? Здесь мы разберем операторы которые помогут отфильтровать ненужные данные, или сократить последовательность к единому нужному нам значению. +Примеры которые мы видели до этого были достаточно малы. Ничто не должно удерживать вас от использования Rx при больших объемах данных, но что хорошего в Rx если он выбросит на вас весь объем данных, и оставит вас разбираться с этим своими силами? Здесь мы разберем операторы которые помогут отфильтровать ненужные данные, или сократить последовательность к единому нужному нам значению. Большинство представленных операторов будут знакомы тем кто работал с Java `Stream API` или функциональным программированием. Все операторы возвращают новый объект Observable и _не_ влияют на оригинальный Observable. Этот принцип является ключевым в Rx. Преобразование Observable приводит к созданию нового Observable, оригинальный объект остается незатронутым. Подписчики(Subscribers) оригинального объекта не должны заметить никаких изменений, но как мы увидим дальше гарантирование этого принципа требует также осторожности от разработчика. @@ -12,7 +12,7 @@ ## Filter -`filter` - принимает функцию предикат которая рассчитывает и возвращает истинна или лож для каждого испущенного элемента. Если решение ложно(`false`) элемент отбрасывается из фильтруемой последовательности. +`filter` - принимает функцию предикат которая рассчитывает и возвращает `true` или `false` для каждого испущенного элемента. Если решение ложно(`false`), элемент отбрасывается из фильтруемой последовательности. ```java public final Observable filter(Func1 predicate) @@ -45,7 +45,7 @@ Completed ## distinct и distinctUntilChanged -`distinct` - отбрасывает элементы которые уже встречались в последовательности. +`distinct` - отбрасывает элементы, которые уже встречались в последовательности. ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/distinct.png) @@ -113,9 +113,9 @@ Completed "Fourth" и "Fifth" были отброшены так как начинаются с ‘F’, а этот ключ уже встречался в "First". -Опытные программисты знают что этот оператор сохраняет каждый уникальный элемент во внутреннем списке который прошел через Observable и сравнивает новые элементы с этим списком. Rx аккуратно скрывает такие вещи, вы должны быть в курсе, что это может привести к значительным затратам. +Опытные программисты знают, что этот оператор сохраняет каждый уникальный элемент во внутреннем списке, который прошел через Observable, и проверяет наличие новых элементов в этом списке. Rx аккуратно скрывает такие вещи, вы должны быть в курсе, что это может привести к значительным вычислительным затратам. -Разновидность `distinct` - `distinctUntilChanged`. Разница заключается в том, что последовательные не уникальные значения отбрасываются. +Разновидность `distinct` - `distinctUntilChanged`. Разница заключается в том, что последовательные неуникальные значения отбрасываются. ```java public final Observable distinctUntilChanged() @@ -182,7 +182,7 @@ Completed ## ignoreElements -`ignoreElements` - игнорирует каждое значение но пропускает `onCompleted` и `onError`. +`ignoreElements` - игнорирует каждое значение, но пропускает `onCompleted` и `onError`. ```java Observable values = Observable.range(0, 10); @@ -200,7 +200,7 @@ Subscription subscription = values Completed ``` -`ignoreElements()` - производит такой же результат что и `filter(v -> false)` +`ignoreElements()` - производит такой же результат, что и `filter(v -> false)` ## skip и take @@ -234,7 +234,7 @@ Completed Пользователи Stream API из Java 8 должны знать оператор `take` как `limit`. Оператор `limit` также присутствует в RxJava 1.X для тех же целей. Это синоним для `take`, но ему не достаёт перегрузок которые мы скоро увидим. В RxJava 2+ оператор `limit` был исключен. -`take` - завершится как только получит n-й элемент. Если произойдет ошибка, она будет пробоброшена в том случае если она произошла до n-го элемента. `take` - не заботится о том что произошло с Observable после n-го элемента, так как это уже другая, "родительская" последовательность. +`take` - завершится как только получит n-й элемент. Если произойдет ошибка, она будет проброшена в том случае если она произошла до n-го элемента. `take` - не заботится о том что произошло с Observable после n-го элемента, так как это уже другая, "родительская" последовательность. ```java Observable values = Observable.create(o -> { @@ -310,7 +310,7 @@ Completed ## skipWhile and takeWhile -`take` и `skip` работают с предопределенными индексами. Однако, если вам нужно найти точку отсечения основываясь на входных данных используйте условные `takeWhile` и `skipWhile`. `takeWhile` пропускает значение пока функция предикат возвращает истину. +`take` и `skip` работают с предопределенными индексами. Однако, если вам нужно найти точку отсечения основываясь на входных данных используйте условные `takeWhile` и `skipWhile`. `takeWhile` пропускает значение пока функция предикат возвращает `true`. ```java Observable takeWhile(Func1 predicate) @@ -382,7 +382,7 @@ Completed ## takeUntil и skipUntil -Есть еще два метода - `takeUntil` и `skipUntil`. `takeUntil` работает точно так же как `takeWhile` за исключением того, что он принимает элементы пока предикат возвращает false. Так же ведет себя и `skipUntil`. +Есть еще два метода - `takeUntil` и `skipUntil`. `takeUntil` работает точно так же как `takeWhile` за исключением того, что он принимает элементы пока предикат возвращает `false`. Так же ведет себя и `skipUntil`. Наряду с этим, `takeUntil` и` skipUntil` имеют очень интересную перегрузку. Точка отсечки определяется в момент, когда другой _Observable_ выдает новый элемент последовательности. @@ -412,7 +412,7 @@ Completed ``` Как вы помните, `timer` ожидает 250мс и испускает одно событие. `takeUntil` реагирует на этот сигнал и останавливает последовательность. Обратите внимание что сигнал может быть любого типа, так как его значение не используется. -Еще раз `skipUntil` работает по тем же правилам и возвращает вторую половину последовательности. Элементы игнорируются пока не прийдет сигнал о начале трансляции элементов насквозь. +Еще раз, `skipUntil` работает по тем же правилам и возвращает вторую половину последовательности. Элементы игнорируются пока не придет сигнал о начале трансляции элементов насквозь. ```java Observable values = Observable.interval(100,TimeUnit.MILLISECONDS); diff --git a/Part 2 - Sequence Basics/3. Inspection.md b/Part 2 - Sequence Basics/3. Inspection.md index 3352ec2..c0ae5ca 100644 --- a/Part 2 - Sequence Basics/3. Inspection.md +++ b/Part 2 - Sequence Basics/3. Inspection.md @@ -1,10 +1,10 @@ # Исследование последовательности -В предыдущей главе мы изучали способы фильтрации данных которые важны для нас. Иногда информация о последовательности является более важной нежели ее значения. Сейчас мы рассмотрим некоторые методы которые позволят нам рассуждать о содержимом последовательности. +В предыдущей главе мы изучали способы фильтрации данных которые важны для нас. Иногда информация о последовательности является более важной нежели ее значения. Сейчас мы рассмотрим некоторые методы, которые позволят нам рассуждать о содержимом последовательности. ## all -`all` - метод который уславливает что каждое значение испущенное последовательностью отвечает критерию. Вот сигнатура метода и пример: +`all` - метод который проверяет, что каждое значение произведенное последовательностью отвечает заданному критерию. Вот сигнатура метода и пример: ```java public final Observable all(Funk predicate) @@ -34,9 +34,9 @@ Subscription evenNumbers = values true Completed ``` -Любопытный факт, то что этот метод возвращает последовательность с одним значением, а не логическое значение напрямую. Это все потому что неизвестно сколько времени потребуется чтоб определить ложный или истинный результат. Как только решение будет получено последовательность завершится, даже если исходная последовательность еще не завершилась. Как только предикат вернет ложь для некоторого значения, `false` - будет испущено. `true` не может быть испущено до тех пор пока исходная последовательность завершится и _все_ элементы будут проверены. Это удобный способ сделать операцию асинхронной. +Любопытный факт, то что этот метод возвращает последовательность с одним значением, а не логическое значение напрямую. Это все потому что неизвестно сколько времени потребуется чтоб определить ложный или истинный результат. Как только решение будет получено последовательность завершится, даже если исходная последовательность еще не завершилась. Как только предикат вернет `false` для некоторого значения, `false` - будет испущено. `true` не может быть испущено до тех пор пока исходная последовательность завершится и _все_ элементы будут проверены. Это удобный способ сделать операцию асинхронной. -В следующем примере оператор `all` возвращает последовательность, которая выдает ложь сразу же после того как предикат возвращает ложь для элемента: +В следующем примере оператор `all` возвращает последовательность, которая выдает `false` сразу же после того как предикат возвращает `false` для элемента: ```java Observable values = Observable.interval(150, TimeUnit.MILLISECONDS).take(5); @@ -90,7 +90,7 @@ Subscription subscription = values ``` Error: java.lang.Exception ``` -В случае если предикат возвращает ложь, тогда испускается `false` и последовательность завершается. Если исходная последовательность после этого завершиться с ошибкой, она будет проигнорирована, так как это требуют принципы Rx (никаких событий после события завершения). +В случае если ,предикат не удовлетворяет заданному критерию, тогда испускается `false` и последовательность завершается. Если исходная последовательность после этого завершиться с ошибкой, она будет проигнорирована, так как это требуют принципы Rx (никаких событий после события завершения). ```java Observable values = Observable.create(o -> { @@ -116,7 +116,7 @@ Completed ## exists -`exists` - возвращает последовательность которая вернет истину если хотя бы одно из значений наблюдаемой(исходной) последовательности будет соответствовать предикату. +`exists` - возвращает `Observable`, который вернет `true` если хотя бы одно из значений наблюдаемой(исходной) последовательности будет соответствовать предикату. ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/exists.png) @@ -172,11 +172,11 @@ Subscription subscription = values false Completed ``` -Ложь появится как только исходная последовательность выдаст значение. Истина будет выдана если исходная последовательность завершится не выдав значений. Например `Observable.empty()`. +`false` появится как только исходная последовательность выдаст значение. `true` будет выдано, если исходная последовательность завершится не выдав значений. Например `Observable.empty()`. ## contains -Оператор `contains` определяет был ли испущен определенный элемент. `contains` использует `Object.equals` метод для определения эквивалентности. Так же как и предидущие операторы, он испускает решение как только оно посчитано и сразу же завершается. +Оператор `contains` определяет был ли испущен определенный элемент. `contains` использует `Object.equals` метод для определения эквивалентности. Так же как и предыдущие операторы, он испускает решение как только оно посчитано и сразу же завершается. ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/contains.png) @@ -198,11 +198,11 @@ true Completed ``` -Если мы напишем `contains(4)` вместо `contains(4L)`, ничего не будет напечатано. Это потому что `4` и `4L` не эквивалентны в Java. Наш код будет ждать окончания последовательности до того как испустить ложь, но этого никогда не случится, так как наша последовательность бесконечна. +Если мы напишем `contains(4)` вместо `contains(4L)`, ничего не будет напечатано. Это потому что `4` и `4L` не эквивалентны в Java. Наш код будет ждать окончания последовательности до того как испустить `false`, но этого никогда не случится, так как наша последовательность бесконечна. ## defaultIfEmpty -Если пустая последовательность оказалась пустой, вместо проверки на `isEmpty` и обработки вручную, вы можете заставить последовательность выдать значение "по-умолчанию" перед завершением. +Если пустая последовательность оказалась пустой, вместо проверки на `isEmpty` и обработки вручную, вы можете заставить последовательность выдать значение "по умолчанию" перед завершением. ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/defaultIfEmpty.png) @@ -267,7 +267,7 @@ Subscription subscription = values Completed ``` -Если последовательность недостаточной длины, будет выброшено исключение `java.lang.IndexOutOfBoundsException`. Чтоб предотвратить этот специфический случай, мы можем определить значение по умолчанию чтобы оно возпращалось взамен `IndexOutOfBoundsException`. +Если последовательность недостаточной длины, будет выброшено исключение `java.lang.IndexOutOfBoundsException`. Чтоб предотвратить этот специфический случай, мы можем определить значение по умолчанию чтобы оно возвращалось взамен `IndexOutOfBoundsException`. ```java Observable values = Observable.range(100, 10); @@ -310,7 +310,7 @@ true Completed ``` -Если мы будем использовать закоментированный оператор, он будет использовать `Object.equals` для сравнения, и результат окажется `false`. +Если мы будем использовать закомментированный оператор, он будет использовать `Object.equals` для сравнения, и результат окажется `false`. Исключительная ситуация не является частью сравнения. Как только одна из последовательностей выйдет из строя, результирующая последовательность выдаст ошибку. diff --git a/README.md b/README.md index ed7284c..c63b99e 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ ### Структура -Материал этих статей расчитан на прочтение от начала до конца. Его обьем больше, чем среднего туториала, но меньше чем реальной книги. Мы начнем с самых основ и от раздела к разделу будем переходить к всё более продвинутым сценариям и концепциям. Каждый раздел задумывался самодостаточным и лаконичным для того, чтобы к нему можно было вернуться в будущем. +Материал этих статей рассчитан на прочтение от начала до конца. Его объем больше среднего туториала, но меньше реальной книги. Мы начнем с самых основ и, от раздела к разделу, будем переходить к всё более продвинутым сценариям и концепциям. Каждый раздел задумывался самодостаточным и лаконичным для того, чтобы к нему можно было вернуться в будущем. Примеры к этим материалам доступны в двух видах: @@ -24,8 +24,9 @@ ### В процессе перевода -Многие части все еще не переведены. Помощь в виде пул-реквестов с переводами и исправлениями очень привествуется. +Многие части все еще не переведены. Помощь в виде пул-реквестов с переводами и исправлениями очень приветствуется. ### Участники * [FARsh](https://github.com/FARsh) * [KlGleb](https://github.com/KlGleb) +* [AnatolyBurtsev](https://github.com/anatolyburtsev)