docs(ru): Translation update (#1445)

* structure.md исправлена опечатка

* actions.md мелкие правки

* api.md мелкие правки

* intro.md мелкие правки

* state.md мелкие правки

* strict.md мелкие правки

* testing.md мелкие правки

* actions.md правки

* testing.md правки

* Fix typos. ru

* SUMMARY.md правки заголовков

* Минусы на тире

* [RU] Moved to VuePress

* Fix & single quotes

* [RU] Update

* Remove settings.json

* fix link

* fix images links

* translated ru image and ai sources

* Localized images

* README.md исправлена ссылка

* api: formatting example

* api: fix links

* docs: remove core-concepts.md

* modules.md правка примеров

* docs: [RU] fix links anchors

* docs: (ru) plugins.md fix

* api.md добавлен devtools

* api.md добавлена ссылка

* api.md обновление

* installation.md обновление

* README.md обновление

* getting-started.md удален, дубль

* README.md обновление

* installation.md изменена ссылка

* README.md правка

* state.md обновление

* state.md правки

* getters.md правки

* README.md fix

* state.md fix

* state.md правки

* hot-reload.md правка

* mutations.md правка

docs/ru/README.md

@@ -1,10 +1,10 @@
 # Что такое Vuex?
 
-Vuex — это **паттерн управления состоянием и библиотека** для приложений на Vue.js. Он служит центральным хранилищем данных для всех компонентов приложения и обеспечивает предсказуемость изменения данных при помощи определённых правил. Кроме того, Vuex интегрируется с официальным [расширением инструментов разработчика](https://github.com/vuejs/vue-devtools) Vue, предоставляя "из коробки" такие продвинутые возможности, как "машину времени" при отладке и экспорт/импорт слепков состояния данных.
+Vuex — **паттерн управления состоянием + библиотека** для приложений на Vue.js. Он служит централизованным хранилищем данных для всех компонентов приложения с правилами, гарантирующими, что состояние может быть изменено только предсказуемым образом. Vuex интегрируется с официальным расширением [vue-devtools](https://github.com/vuejs/vue-devtools), предоставляя «из коробки» такие продвинутые возможности, как «машину времени» для отладки и экспорт/импорт слепков состояния данных.
 
-### Что такое "паттерн управления состоянием"?
+### Что такое «паттерн управления состоянием»?
 
-Давайте начнём с простого приложения, реализующего счётчик с использованием Vue:
+Давайте начнём с простого приложения Vue, реализующего счётчик:
 
 ```js
 new Vue({
@@ -29,35 +29,35 @@ new Vue({
 
 Это самостоятельное приложение состоит из следующих частей:
 
-* **Состояние** — "источник истины", управляющий приложением;
-* **Представление** — декларативно заданное отображение **состояния**;
+* **Состояние** — «источник истины», управляющий приложением;
+* **Представление** — отображение **состояния** заданное декларативно;
 * **Действия** — возможные пути изменения состояния приложения в ответ на взаимодействие пользователя с **представлением**.
 
-Вот простейшее представление концепции "однонаправленного потока данных":
+Вот простейшее представление концепции «однонаправленного потока данных»:
 
 <p style="text-align: center; margin: 2em">
   <img style="width:100%;max-width:450px;" src="/ru/flow.png">
 </p>
 
-Простота, к сожалению, быстро исчезает при появлении **нескольких компонентов, основывающихся на одном и том же состоянии**, когда:
+Однако простота быстро исчезает, когда у нас появляется **нескольких компонентов, основывающихся на одном и том же состоянии**:
 
 * Несколько представлений могут зависеть от одной и той же части состояния приложения.
 * Действия из разных представлений могут оказывать влияние на одни и те же части состояния приложения.
 
-Разбираясь с первой проблемой, вам придётся передавать одни и те же данные в несколько глубоко вложенных компонентов. Это часто сложно и неприятно, а для соседних компонентов такое и вовсе не сработает. Решая вторую проблему, приходится обращаться напрямую к родителям и потомкам компонента, или синхронизировать изменения с другими местами в приложении событиями. Оба подхода хрупки и быстро приводят к появлению кода, который невозможно поддерживать.
+Решая первую проблему, придётся передавать одни и те же данные входными параметрами в глубоко вложенные компоненты. Это часто сложно и утомительно, а для соседних компонентов такое и вовсе не сработает. Решая вторую проблему, можно прийти к таким решениям, как обращение по ссылкам к родительским/дочерним экземплярам или попыткам изменять и синхронизировать несколько копий состояния через события. Оба подхода хрупки и быстро приводят к появлению кода, который невозможно поддерживать.
 
-Так почему бы не вынести всё общее состояние приложения из компонентов в глобальный синглтон? При использовании этого подхода, дерево компонентов превращается в одно большое "представление", а каждый компонент получает доступ к состоянию приложения, наряду с возможностью вызывать действия для изменения состояния, независимо от расположения этого компонента в дереве.
+Так почему бы не вынести всё общее состояние приложения из компонентов и управлять им в глобальном синглтоне? При этом наше дерево компонентов становится одним большим «представлением» и любой компонент может получить доступ к состоянию приложения или вызывать действия для изменения состояния, независимо от того, где они находятся в дереве!
 
-Кроме того, чётко определяя и разделяя концепции, возникающие при управлении состоянием, и требуя соблюдения некоторых правил, мы улучшаем структурированность и поддерживаемость нашего кода.
+Кроме того, чётко определяя и разделяя концепции, возникающие при управлении состоянием, и требуя соблюдения определённых правил, мы лучше структурируем код и облегчаем его поддержку.
 
-Такова основная идея, лежащая в основе Vuex, вдохновлённого [Flux](https://facebook.github.io/flux/docs/overview.html), [Redux](http://redux.js.org/) и [Архитектурой Elm](https://guide.elm-lang.org/architecture/). В отличие от других паттернов, Vuex реализован в виде библиотеки, специально заточенной на использование совместно с Vue.js и использующей его производительную систему реактивных обновлений.
+Это основная идея Vuex, вдохновлённого [Flux](https://facebook.github.io/flux/docs/overview.html), [Redux](http://redux.js.org/) и [Архитектурой Elm](https://guide.elm-lang.org/architecture/). В отличие от других паттернов, Vuex реализован в виде библиотеки, специально предназначенной для Vue.js, чтобы использовать его систему реактивности для эффективного обновления.
 
 ![vuex](/ru/vuex.png)
 
-### В каких случаях использовать Vuex?
+### Когда следует использовать Vuex?
 
-Vuex помогает управлять совместно используемым состоянием ценой привнесения новых концепций и вспомогательного кода. Кратковременная продуктивность страдает во благо долгосрочной.
+Хотя Vuex помогает управлять совместно используемым состоянием, это реализуется ценой привнесения новых концепций и вспомогательного кода. Компромисс, когда кратковременная продуктивность страдает на благо долгосрочной.
 
-Если вам ещё не доводилось создавать крупномасштабные одностраничные приложения, Vuex может показаться многословным и обескураживающим. Это нормально — несложные приложения вполне могут обойтись и без Vuex. Возможно, вам вполне хватит простой [глобальной шины событий](https://ru.vuejs.org/v2/guide/state-management.html#Простой-контейнер-состояния-с-нуля). Но если вы создаёте SPA среднего или крупного размера, вероятно вам уже приходилось сталкиваться с ситуациями, заставляющими задуматься о методах более эффективного управления состоянием приложения за пределами компонентов Vue, и Vuex в таком случае может оказаться вполне естественным следующим шагом. Вот неплохая цитата от Дэна Абрамова, автора Redux:
+Если ещё не приходилось создавать крупные SPA и вы лишь знакомитесь с Vuex, это может показаться многословным и сложным. Всё в порядке — простые приложения могут легко обходиться и без Vuex. Возможно, будет достаточно простого паттерна [глобальной шины событий](https://ru.vuejs.org/v2/guide/state-management.html#Простой-контейнер-состояния-с-нуля). Но если вы создаёте SPA среднего или крупного размера, то, скорее всего, уже сталкивались с ситуациями, которые заставляли задуматься о том, как лучше управлять состоянием вне компонентов Vue, а Vuex в таком случае может стать вполне естественным следующим шагом. Есть хорошая цитата от Дэна Абрамова, автора Redux:
 
-> Flux-библиотеки подобны очкам: если они вам действительно нужны, вы на этот счёт не сомневаетесь.
+> Flux-библиотеки похожи на очки: вы будете точно знать, когда они вам понадобятся.

docs/ru/api/README.md

@@ -20,13 +20,13 @@ const store = new Vuex.Store({ ...options });
 
   Корневой объект состояния хранилища Vuex. [Подробнее](../guide/state.md)
 
-  Если вы передаёте функцию, возвращающую объект, то возвращаемый объект будет использован в качестве корневого состояния. Это может быть полезным, если вы хотите повторно использовать объект состояния, особенно при повторном использовании модулей. [Подробнее](../guide/modules.md#повторное-испоnьзование-модуnей)
+  При передаче функции, возвращающей объект, возвращаемый объект будет использован в качестве корневого состояния. Это пригодится, если необходимо повторно использовать объект состояния, особенно при повторном использовании модулей. [Подробнее](../guide/modules.md#повторное-испоnьзование-модуnей)
 
 ### mutations
 
 * тип: `{ [type: string]: Function }`
 
-  Регистрирует доступные для хранилища мутации. Обработчики мутаций первым аргументом всегда получают `state` (при использовании модулей это будет локальный state модуля). Вторым аргументом передаётся "нагрузка" (`payload`), если она есть.
+  Доступные мутации хранилища. Обработчики мутаций первым аргументом получают `state` (при использовании модулей это будет локальное состояние модуля). Вторым аргументом передаётся «нагрузка» (`payload`), если она есть.
 
   [Подробнее](../guide/mutations.md)
 
@@ -34,7 +34,7 @@ const store = new Vuex.Store({ ...options });
 
 * тип: `{ [type: string]: Function }`
 
-  Регистрирует действия хранилища. В функции-обработчики передаётся объект `context`, со следующими свойствами:
+  Доступные действия хранилища. В обработчики передаётся объект `context`, со следующими свойствами:
 
   ```js
   {
@@ -47,7 +47,7 @@ const store = new Vuex.Store({ ...options });
   }
   ```
 
-  И также получает вторым аргументом `payload` если нагрузка была передана.
+  Вторым аргументом передаётся «нагрузка» (`payload`), если она есть.
 
   [Подробнее](../guide/actions.md)
 
@@ -55,7 +55,7 @@ const store = new Vuex.Store({ ...options });
 
 * тип: `{ [key: string]: Function }`
 
-  Регистрирует геттеры, используемые в хранилище. Геттер-функции при вызове получают следующие аргументы:
+  Доступные геттеры хранилища. Функция получает следующие аргументы:
 
   ```
   state,     // при использовании модулей — локальный state модуля
@@ -71,7 +71,7 @@ const store = new Vuex.Store({ ...options });
   rootGetters  // все геттеры
   ```
 
-  Зарегистрированные геттеры далее доступны в `store.getters`.
+  Зарегистрированные геттеры доступны через `store.getters`.
 
   [Подробнее](../guide/getters.md)
 
@@ -79,7 +79,7 @@ const store = new Vuex.Store({ ...options });
 
 * тип: `Object`
 
-  Объект, содержащий подмодули для помещения в хранилище, в формате:
+  Объект, содержащий под-модули для помещения в хранилище, в формате:
 
   ```js
   {
@@ -95,7 +95,7 @@ const store = new Vuex.Store({ ...options });
   }
   ```
 
-  Каждый модуль может содержать `state` и `mutations`, как и корневое хранилище. Состояние модуля будет прикреплено к корневому, по указанному ключу. Мутации и геттеры модуля получают при вызове первым аргументом только локальное состояние, а не корневое. При вызове действий `context.state` аналогичным образом указывает на локальное состояние модуля.
+  У каждого модуля могут быть свои `state` и `mutations`, аналогично корневому хранилищу. Состояние модуля прикрепляется к корневому, по указанному ключу. Мутации и геттеры модуля получают первым аргументом локальное состояние, а не корневое. При вызове действий `context.state` аналогичным образом указывает на локальное состояние модуля.
 
   [Подробнее](../guide/modules.md)
 
@@ -103,7 +103,7 @@ const store = new Vuex.Store({ ...options });
 
 * тип: `Array<Function>`
 
-  Массив функций-плагинов, которые будут применены к хранилищу. Плагины попросту получают хранилище в качестве единственного аргумента, и могут как отслеживать мутации (для сохранения исходящих данных, логирования или отладки) или инициировать их (для обработки входящих данных, например, веб-сокетов или наблюдателей).
+  Массив функций-плагинов, которые применяются к хранилищу. Плагины просто получают хранилище в качестве единственного аргумента, и могут как отслеживать мутации (для сохранения исходящих данных, логирования или отладки) или инициировать их (для обработки входящих данных, например, websockets или observables).
 
   [Подробнее](../guide/plugins.md)
 
@@ -112,10 +112,22 @@ const store = new Vuex.Store({ ...options });
 * тип: `Boolean`
 * по умолчанию: `false`
 
-  Заставляет хранилище Vuex использовать strict mode. В strict mode любые изменения состояния, происходящие за пределами обработчиков мутаций, будут выбрасывать ошибки.
+  Форсирует использование «строгого режима» в хранилище Vuex. В нём любые изменения состояния, происходящие вне обработчиков мутаций, будут выбрасывать ошибки.
 
   [Подробнее](../guide/strict.md)
 
+### devtools
+
+* тип: `Boolean`
+
+  Интеграция в devtools конкретного экземпляра Vuex. Например, передача `false` сообщает экземпляру хранилища Vuex, что не требуется подписываться на плагин devtools. Это будет полезно если у вас несколько хранилищ на одной странице. 
+  
+  ``` js
+  {
+    devtools: false
+  }
+  ```
+
 ## Свойства экземпляра Vuex.Store
 
 ### state
@@ -137,34 +149,34 @@ const store = new Vuex.Store({ ...options });
 * `commit(type: string, payload?: any, options?: Object)`
 * `commit(mutation: Object, options?: Object)`
 
-Запускает мутацию. `options` может содержать опцию `root: true` что разрешает совершать корневые (root) мутации [в модулях со своим пространством имён](../guide/modules.md#пространства-имён). [Подробнее](../guide/mutations.md)
+Запуск мутации. `options` может содержать опцию `root: true` что позволяет запускать корневые (root) мутации [в модулях со своим пространством имён](../guide/modules.md#пространства-имён). [Подробнее](../guide/mutations.md)
 
 ### dispatch
 
 * `dispatch(type: string, payload?: any, options?: Object)`
 * `dispatch(action: Object, options?: Object)`
 
-Инициирует действие. `options` может содержать опцию `root: true` что разрешает совершать корневые (root) действия [в модулях со своим пространством имён](../guide/modules.md#пространства-имён). Возвращает Promise который разрешает все обработчики инициируемых действий. [Подробнее](../guide/actions.md)
+Запуск действия. `options` может содержать опцию `root: true` что позволяет запускать корневые (root) действия [в модулях со своим пространством имён](../guide/modules.md#пространства-имён). Возвращает Promise который разрешает все обработчики инициируемых действий. [Подробнее](../guide/actions.md)
 
 ### replaceState
 
 * `replaceState(state: Object)`
 
-Позволяет заменить корневое состояние хранилища. Используйте только для гидрации состояния / функциональности "машины времени".
+Замена корневого состояние хранилища новым. Используйте только для гидратации состояния и/или функциональности «машины времени».
 
 ### watch
 
 * `watch(fn: Function, callback: Function, options?: Object): Function`
 
-Реактивно отслеживает возвращаемое значение `fn`, и вызывает коллбэк в случае изменений. `fn` получает состояние хранилища первым аргументом, и геттеры вторым аргументом. Принимает опциональный объект с настройками, с такими же параметрами как и у метода Vue `vm.$watch`.
+Реактивно отслеживает возвращаемое значение `fn`, и вызывает коллбэк в случае изменений. Первым аргументом `fn` будет состояние хранилища, вторым — геттеры. Опционально может принимать объект с настройками, с такими же параметрами как и у [метода Vue `vm.$watch`](https://ru.vuejs.org/v2/api/#vm-watch).
 
-Для прекращения наблюдения, необходимо вызвать возвращаемую функцию обработчик.
+Для прекращения отслеживания, необходимо вызвать возвращаемую методом функцию.
 
 ### subscribe
 
 * `subscribe(handler: Function): Function`
 
-Подписывается на мутации хранилища. Обработчик `handler` вызывается после каждой мутации и получает в качестве параметров дескриптор мутации и состояние после мутации:
+Отслеживание вызова мутаций хранилища. Обработчик `handler` вызывается после каждой мутации и получает в качестве параметров дескриптор мутации и состояние после мутации:
 
 ```js
 store.subscribe((mutation, state) => {
@@ -173,7 +185,7 @@ store.subscribe((mutation, state) => {
 });
 ```
 
-Для остановки слежения необходимо вызвать возвращаемую функцию.
+Для прекращения отслеживания, необходимо вызвать возвращаемую методом функцию.
 
 Чаще всего используется в плагинах. [Подробнее](../guide/plugins.md)
 
@@ -183,7 +195,7 @@ store.subscribe((mutation, state) => {
 
 > Добавлено в версии 2.5.0
 
-Подписывается на действие хранилища. Обработчик `handler` вызывается после каждого действия и получает в качестве параметров дескриптов действия и текущее состояние хранилища:
+Отслеживание вызова действий хранилища. Обработчик `handler` вызывается после каждого действия и получает в качестве параметров дескриптор действия и текущее состояние хранилища:
 
 ```js
 store.subscribeAction((action, state) => {
@@ -192,7 +204,7 @@ store.subscribeAction((action, state) => {
 });
 ```
 
-Для остановки слежения необходимо вызвать возвращаемую функцию.
+Для прекращения отслеживания, необходимо вызвать возвращаемую методом функцию.
 
 Чаще всего используется в плагинах. [Подробнее](../guide/plugins.md)
 
@@ -202,19 +214,19 @@ store.subscribeAction((action, state) => {
 
 Регистрирует динамический модуль. [Подробнее](../guide/modules.md#динамическая-регистрация-модуnей)
 
-`options` может иметь опцию `preserveState: true`, что позволяет сохранить предыдущее состояние. Полезно с рендерингом на стороне сервера.
+`options` может иметь опцию `preserveState: true`, что позволяет сохранить предыдущее состояние. Полезно при отрисовке на стороне сервера (SSR).
 
 ### unregisterModule
 
 * `unregisterModule(path: string | Array<string>)`
 
-Разрегистрирует динамический модуль. [Подробнее](../guide/modules.md#динамическая-регистрация-модуnей)
+Удаление зарегистрированного динамического модуля. [Подробнее](../guide/modules.md#динамическая-регистрация-модуnей)
 
 ### hotUpdate
 
 * `hotUpdate(newOptions: Object)`
 
-Осуществляет горячую замену действий и мутаций. [Подробнее](../guide/hot-reload.md)
+Горячая перезагрузка действий и мутаций. [Подробнее](../guide/hot-reload.md)
 
 ## Вспомогательные функции для компонентов
 
@@ -222,9 +234,9 @@ store.subscribeAction((action, state) => {
 
 * `mapState(namespace?: string, map: Array<string> | Object<string | function>): Object`
 
-Создаёт проксирующие вычисляемые свойства компонента, возвращающие поддерево state'а хранилища Vuex [Подробнее](../guide/state.md#вспомогатеnьная-функция-mapstate)
+Создаёт вычисляемые свойства компонента, возвращающие под-дерево состояния хранилища Vuex. [Подробнее](../guide/state.md#вспомогатеnьная-функция-mapstate)
 
-Первый аргумент опционально может быть строкой с указанным namespace. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
+Первый опциональный аргумент может быть строкой пространства имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
 
 Второй аргумент вместо объекта может быть функцией. `function(state: any)`
 
@@ -232,17 +244,17 @@ store.subscribeAction((action, state) => {
 
 * `mapGetters(namespace?: string, map: Array<string> | Object<string>): Object`
 
-Создаёт проксирующие вычисляемые свойства компонента, проксирующие доступ к геттерам. [Подробнее](../guide/getters.md#вспомогатеnьная-функция-mapgetters)
+Создаёт вычисляемые свойства компонента для доступа к геттерам. [Подробнее](../guide/getters.md#вспомогатеnьная-функция-mapgetters)
 
-Первый аргумент опционально может быть строкой с указанным namespace. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
+Первый опциональный аргумент может быть строкой пространства имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
 
 ### mapActions
 
 * `mapActions(namespace?: string, map: Array<string> | Object<string | function>): Object`
 
-Создаёт проксирующие методы компонента, позволяющие диспетчеризировать действия. [Подробнее](../guide/actions.md#диспетчеризация-действий-в-компонентах)
+Создаёт проксирующие методы компонента для вызова действий хранилища. [Подробнее](../guide/actions.md#диспетчеризация-действий-в-компонентах)
 
-Первый аргумент опционально может быть строкой с указанным namespace. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
+Первый опциональный аргумент может быть строкой пространства имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
 
 Второй аргумент вместо объекта может быть функцией. `function(dispatch: function, ...args: any[])`
 
@@ -250,9 +262,9 @@ store.subscribeAction((action, state) => {
 
 * `mapMutations(namespace?: string, map: Array<string> | Object<string | function>): Object`
 
-Создаёт проксирующие методы компонента, позволяющие инициировать мутации. [Подробнее](../guide/mutations.md#вызов-мутаций-в-компонентах)
+Создаёт проксирующие методы компонента для вызова мутаций хранилища. [Подробнее](../guide/mutations.md#вызов-мутаций-в-компонентах)
 
-Первый аргумент опционально может быть строкой с указанным namespace. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
+Первый опциональный аргумент может быть строкой пространства имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
 
 Второй аргумент вместо объекта может быть функцией. `function(commit: function, ...args: any[])`
 
@@ -260,4 +272,4 @@ store.subscribeAction((action, state) => {
 
 * `createNamespacedHelpers(namespace: string): Object`
 
-Создаёт вспомогательные функции для связывания с компонентами для указанного пространства имён. Возвращаемый объект содержит `mapState`, `mapGetters`, `mapActions` и `mapMutations`, которые связаны с указанным пространством имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)
+Создаёт вспомогательные функции связывания с компонентами для указанного пространства имён. Возвращаемый объект содержит `mapState`, `mapGetters`, `mapActions` и `mapMutations`, которые связаны с указанным пространством имён. [Подробнее](../guide/modules.md#подкnючение-с-помощью-вспомогатеnьных-функций-к-пространству-имён)

docs/ru/guide/README.md

@@ -1,19 +1,19 @@
 # Введение
 
-В центре любого Vuex-приложения находится **хранилище**. "Хранилище" — это, упрощённо говоря, контейнер, который хранит **состояние** вашего приложения. Два момента отличают хранилище Vuex от простого глобального объекта:
+В центре любого Vuex-приложения находится **хранилище**. «Хранилище» — это контейнер, в котором хранится **состояние** вашего приложения. Два момента отличают хранилище Vuex от простого глобального объекта:
 
-1. Хранилища Vuex реактивны. Если компоненты Vue зависят от их состояния, изменение состояния хранилища спровоцирует соответствующие изменения компонентов.
+1. Хранилище Vuex реактивно. Когда компоненты Vue полагаются на его состояние, то они будут реактивно и эффективно обновляться, если состояние хранилища изменяется.
 
-2. Непосредственное изменение состояния хранилища запрещено. Единственный способ внести изменения — явно **вызвать мутацию**. Этот подход позволяет быть уверенным, что каждое изменение оставляет в системе след и даёт возможность использовать инструменты, позволяющие лучше понять работу приложения.
+2. Нельзя напрямую изменять состояние хранилища. Единственный способ внести изменения — явно **вызвать мутацию**. Это гарантирует, что любое изменение состояния оставляет след и позволяет использовать инструментарий, чтобы лучше понимать ход работы приложения.
 
-### Простейшее Хранилище
+### Простейшее хранилище
 
-> **ЗАМЕЧАНИЕ:** Мы будем использовать синтаксис ES2015 для примеров кода на всём протяжении этой документации. Если вы с ним ещё не разобрались, [сейчас самое время](https://babeljs.io/docs/learn-es2015/)!
+> **ЗАМЕЧАНИЕ:** В примерах кода документации используется синтаксис ES2015. Если вы с ним ещё не знакомы, [сейчас самое время изучить](https://babeljs.io/docs/learn-es2015/)!
 
-После [установки](../installation.md) Vuex, давайте создадим хранилище. Всё довольно просто: нужно лишь указать исходное состояние и мутации:
+После [установки](../installation.md) Vuex, давайте создадим хранилище. Это довольно просто — необходимо указать начальный объект состояния и некоторые мутации:
 
 ``` js
-// Удостоверьтесь, что вызвали Vue.use(Vuex) в коде до этого, если используете модульный сборщик
+// Убедитесь, что вызвали Vue.use(Vuex) сначала, если используете систему сборки
 
 const store = new Vuex.Store({
   state: {
@@ -27,7 +27,7 @@ const store = new Vuex.Store({
 })
 ```
 
-Теперь мы можем получить доступ к объекту состояния `store.state` или вызвать изменение состояния методом `store.commit`:
+Теперь можно получить доступ к объекту состояния через `store.state` и вызвать изменение состояния с помощью метода `store.commit`:
 
 ``` js
 store.commit('increment')
@@ -35,8 +35,10 @@ store.commit('increment')
 console.log(store.state.count) // -> 1
 ```
 
-Ещё раз заметим: мы вызываем мутацию, вместо того чтобы напрямую изменить `store.state.count`, потому что мы хотим явным образом отслеживать изменения. Это простое архитектурное соглашение делает намерения более очевидными и упрощает понимание изменений состояния приложения при чтении кода. Кроме того, этот подход позволяет реализовать инструменты для логирования каждой мутации, создания моментальных слепков состояния приложения и даже применения "машины времени" при отладке.
+Запомните, причина, по которой мы вызываем мутацию, вместо изменения `store.state.count` напрямую, в том, что мы хотим явным образом отслеживать её. Это простое соглашение делает наше намерение более явным, что упрощает понимание происходящих изменений состояния приложения при чтении кода. Кроме того, это позволяет использовать инструменты для отслеживания каждой мутации, создания снимков состояния или даже использования «машины времени» для отладки.
 
-Using store state in a component simply involves returning the state within a computed property, because the store state is reactive. Triggering changes simply means committing mutations in component methods.
+Использование состояние хранилища в компоненте предполагает просто возврат необходимой части состояния в вычисляемом свойстве, поскольку состояние хранилища реактивно. Инициирование изменений — это просто запуск мутаций в методах компонентов.
 
 Вот пример [простейшего приложения Vuex, реализующего счётчик](https://jsfiddle.net/n9jmu5v7/1269/).
+
+Далее мы разберём все основные понятия детальнее и начнём с состояния.

docs/ru/guide/forms.md

@@ -1,14 +1,14 @@
 # Работа с формами
 
-Если вы используете Vuex в strict mode, привязать `v-model` к состоянию, хранимому во Vue, может быть немного непросто:
+При использовании строгого режима Vuex может показаться неочевидным как использовать `v-model` с частью состояния Vuex:
 
 ```html
 <input v-model="obj.message">
 ```
 
-Предположим, что `obj` — это вычисляемое свойство, возвращающее ссылку на объект из хранилища. В таком случае, `v-model` будет пытаться напрямую изменить значение `obj.message` в ответ на действия пользователя. В strict mode это спровоцирует ошибку, поскольку это изменение происходит вне обработчика мутации Vuex.
+Предположим, что `obj` — это вычисляемое свойство, которое просто возвращает ссылку на объект из хранилища. В таком случае, `v-model` будет пытаться напрямую изменять значение `obj.message` при действиях пользователя. В строгом режиме такие изменения спровоцируют ошибку, поскольку они происходят вне обработчиков мутаций Vuex.
 
-Чтобы подружить Vuex с такой ситуацией, следует однонаправленно связать атрибут `value` элемента `<input>` с полем объекта, а для учёта изменений использовать событие `change`:
+Для работы с Vuex в такой ситуации, следует привязать значение к `<input>` и отслеживать его изменения по событию `input` или `change`:
 
 ```html
 <input :value="message" @input="updateMessage">
@@ -39,7 +39,7 @@ mutations: {
 }
 ```
 
-### Двухнаправленные вычисляемые свойства
+### Двунаправленные вычисляемые свойства
 
 Заметно, что получившаяся выше запись — куда многословнее, чем используемая в связке `v-model` с локальным состоянием, да и некоторые полезные возможности `v-model` мы таким образом упускаем. В качестве альтернативы можно предложить использование двунаправленного вычисляемого свойства с сеттером:
 

docs/ru/guide/getters.md

@@ -1,6 +1,6 @@
 # Геттеры
 
-Иногда может понадобится доступ к производным данным, основывающимся на состоянии хранилища: например, к отфильтрованной версии списка или количеству элементов в нём:
+Иногда может потребоваться вычислять производное состояние на основе состояния хранилища, например, отфильтровать список и затем подсчитать количество элементов:
 
 ```js
 computed: {
@@ -10,11 +10,11 @@ computed: {
 }
 ```
 
-Если эта функциональность требуется более чем одному компоненту, понадобится либо дублировать функцию, либо выносить её в совместно используемый хелпер и импортировать в нескольких местах. Оба эти подхода далеки от идеала.
+Если такие вычисления потребуются более чем в одном компоненте, придётся или дублировать функцию, или выносить её в общий метод, который затем импортировать во всех местах — оба подхода далеки от идеала.
 
-Vuex позволяет определять в хранилище «геттеры». Вы можете считать их вычисляемыми свойствами для хранилища. Как и вычисляемые свойства, результаты геттера кэшируются, основываясь на своих зависимостях и будут пересчитаны только тогда, когда изменится одна из его зависимостей.
+Vuex позволяет определять «геттеры» в хранилище. Можете считать их вычисляемыми свойствами хранилища. Как и вычисляемые свойства, результаты геттера кэшируются, на основе его зависимостей и пересчитываются только при изменении одной из зависимостей.
 
-Геттеры получают первым аргументом ссылку на состояние хранилища:
+Геттеры получают состояние хранилища первым аргументом:
 
 ```js
 const store = new Vuex.Store({
@@ -34,13 +34,13 @@ const store = new Vuex.Store({
 
 ### Стиль обращения как к свойствам
 
-Геттеры доступны в объекте `store.getters`, и вы можете получить доступ к значениям как для обычных свойств:
+Геттеры доступны в объекте `store.getters`, и вы можете получить доступ к значениям как свойствам:
 
 ```js
 store.getters.doneTodos; // -> [{ id: 1, text: '...', done: true }]
 ```
 
-Вторым аргументом передаётся список всех геттеров:
+Вторым аргументом передаются другие геттеры:
 
 ```js
 getters: {
@@ -55,7 +55,7 @@ getters: {
 store.getters.doneTodosCount; // -> 1
 ```
 
-Теперь мы можем легко использовать их внутри любых компонентов:
+Теперь можно легко использовать его внутри любого компонента:
 
 ```js
 computed: {
@@ -69,7 +69,7 @@ computed: {
 
 ### Стиль обращения как к методам
 
-Вы также можете передавать аргументы геттерам возвращая функцию. Это особенно полезно, если вы хотите вернуть элемент (или часть элементов) массива по переданному критерию:
+Можно также передавать аргументы геттерам, возвращая функцию. Это например пригодится, когда необходимо возвращать массив по указанному критерию:
 
 ```js
 getters: {
@@ -88,7 +88,7 @@ store.getters.getTodoById(2); // -> { id: 2, text: '...', done: false }
 
 ### Вспомогательная функция `mapGetters`
 
-Функция `mapGetters` попросту проксирует геттеры хранилища через локальные вычисляемые свойства компонента:
+Функция `mapGetters` просто проксирует геттеры хранилища в локальные вычисляемые свойства компонента:
 
 ```js
 import { mapGetters } from 'vuex';
@@ -96,7 +96,7 @@ import { mapGetters } from 'vuex';
 export default {
   // ...
   computed: {
-    // примешиваем геттеры в вычисляемые свойства оператором расширения
+    // смешиваем результат mapGetters с внешним объектом computed
     ...mapGetters([
       'doneTodosCount',
       'anotherGetter'
@@ -106,11 +106,11 @@ export default {
 };
 ```
 
-Если вы хотите использовать при проксировании другое имя, примените объектный синтаксис:
+Если необходимо указать другое имя, используйте объектный синтаксис:
 
 ```js
 ...mapGetters({
-  // проксируем `this.doneCount` в `store.getters.doneTodosCount`
+  // проксирует `this.doneCount` в `store.getters.doneTodosCount`
   doneCount: 'doneTodosCount'
 })
 ```

docs/ru/guide/getting-started.md

@@ -1,44 +0,0 @@
-# Введение
-
-В центре любого Vuex-приложения находится **хранилище**. "Хранилище" — это, упрощённо говоря, контейнер, который хранит **состояние** вашего приложения. Два момента отличают хранилище Vuex от простого глобального объекта:
-
-1.  Хранилища Vuex реактивны. Если компоненты Vue зависят от их состояния, изменение состояния хранилища спровоцирует соответствующие изменения компонентов.
-
-2.  Непосредственное изменение состояния хранилища запрещено. Единственный способ внести изменения — явно **вызвать мутацию**. Этот подход позволяет быть уверенным, что каждое изменение оставляет в системе след и даёт возможность использовать инструменты, позволяющие лучше понять работу приложения.
-
-### Простейшее хранилище
-
-> **ПРИМЕЧАНИЕ:** Мы будем использовать синтаксис ES2015 для примеров кода на всём протяжении этой документации. Если вы с ним ещё не разобрались, [сейчас самое время](https://babeljs.io/docs/learn-es2015/)!
-
-После [установки](../installation.md) Vuex, давайте создадим хранилище. Всё довольно просто: нужно лишь указать исходное состояние и мутации:
-
-```js
-// Удостоверьтесь, что вызвали Vue.use(Vuex) в коде до этого, если используете модульный сборщик
-
-const store = new Vuex.Store({
-  state: {
-    count: 0
-  },
-  mutations: {
-    increment(state) {
-      state.count++;
-    }
-  }
-});
-```
-
-Теперь мы можем получить доступ к объекту состояния `store.state` или вызвать изменение состояния методом `store.commit`:
-
-```js
-store.commit('increment');
-
-console.log(store.state.count); // -> 1
-```
-
-Ещё раз заметим: мы вызываем мутацию, вместо того чтобы напрямую изменить `store.state.count`, потому что мы хотим явным образом отслеживать изменения. Это простое архитектурное соглашение делает намерения более очевидными и упрощает понимание изменений состояния приложения при чтении кода. Кроме того, этот подход позволяет реализовать инструменты для логирования каждой мутации, создания моментальных слепков состояния приложения и даже применения "машины времени" при отладке.
-
-Поскольку хранилище реактивно, для использования его состояния в компонентах достаточно просто создать вычисляемые свойства. Изменения состояния можно вызывать, инициализируя мутации в методах компонентов.
-
-Вот пример [простейшего приложения Vuex, реализующего счётчик](https://jsfiddle.net/n9jmu5v7/1269/).
-
-Далее мы подробно рассмотрим все основные понятия, начиная с [состояния](state.md)

docs/ru/guide/hot-reload.md

@@ -30,7 +30,7 @@ if (module.hot) {
     // (нужно указать .default из-за формата вывода Babel 6)
     const newMutations = require('./mutations').default
     const newModuleA = require('./modules/a').default
-    // заменяем старые действия и мутации новыми
+    // заменяем на новые модули и мутации
     store.hotUpdate({
       mutations: newMutations,
       modules: {

docs/ru/guide/mutations.md

@@ -85,13 +85,13 @@ mutations: {
 
 2.  При добавлении новых свойств объекту необходимо либо:
 
-* Использовать `Vue.set(obj, 'newProp', 123)`, или
+    * Использовать `Vue.set(obj, 'newProp', 123)`, или
 
-* Целиком заменить старый объект новым. Например, используя [синтаксис расширения объектов](https://github.com/sebmarkbage/ecmascript-rest-spread) из stage-3, можно написать так:
+    * Целиком заменить старый объект новым. Например, используя [синтаксис расширения объектов](https://github.com/sebmarkbage/ecmascript-rest-spread) можно написать так:
 
-  ```js
-  state.obj = { ...state.obj, newProp: 123 };
-  ```
+    ```js
+    state.obj = { ...state.obj, newProp: 123 };
+    ```
 
 ### Использование констант для обозначения типов мутаций
 

docs/ru/guide/state.md

@@ -2,13 +2,13 @@
 
 ### Единое дерево состояния
 
-Vuex использует **единое дерево состояния** — таким образом, один-единственный объект содержит всё глобальное состояние приложения и служит "единственным источником истины". Кроме того, это значит, что обычно для каждого приложения существует только одно хранилище. Благодаря единому дереву можно легко найти нужную часть состояния или делать слепки всего состояния приложения для отладки.
+Vuex использует **единое дерево состояния** — когда один объект содержит всё глобальное состояние приложения и служит «единственным источником истины». Это также означает, что в приложении будет только одно такое хранилище. Единое дерево состояния позволяет легко найти нужную его часть или делать снимки текущего состояния приложения в целях отладки.
 
-Единое дерево состояния не конфликтует с концепцией модульности — в последующих главах мы расскажем, как можно разбить хранилище на подмодули.
+Единое дерево состояния не противоречит модульности — в следующих главах мы изучим, как можно разделить состояние и мутации на под-модули.
 
-### Передача состояния Vuex в компоненты Vue
+### Использование состояния Vuex в компонентах Vue
 
-Так как же отобразить состояние хранилища в компонентах Vue? Поскольку хранилище Vuex реактивно, проще всего использовать [вычисляемые свойства](https://ru.vuejs.org/v2/guide/computed.html):
+Итак, как использовать состояние хранилища в компонентах Vue? Поскольку хранилище Vuex реактивно, самый простой способ «получения» — просто вернуть часть состояния хранилища в [вычисляемом свойстве](https://ru.vuejs.org/v2/guide/computed.html):
 
 ```js
 // создадим компонент-счётчик:
@@ -22,17 +22,17 @@ const Counter = {
 };
 ```
 
-Любые изменения `store.state.count` вызовут обновление вычисляемого свойства, которые инициируют соответствующие обновления в DOM.
+Любые изменения `store.state.count` вызовут перерасчёт вычисляемого свойства и запуск связанных с ним обновлений DOM.
 
-Однако этот паттерн заставляет компонент явно полагаться на глобальный синглтон хранилища. При использовании модульной системы, это потребует импортирования хранилища в каждый компонент, использующий глобальное состояние и приведет к усложнению тестирования.
+Однако этот паттерн заставляет компонент полагаться на синглтон глобального хранилища. При использовании модульной системы, это потребует импортировать хранилище в каждом компоненте, который использует его состояние, а также усложнит тестирование компонента.
 
-Vuex предоставляет механизм "инъекции" хранилища всем потомкам компонента, у которого указана опция `store` (предварительно необходимо вызвать `Vue.use(Vuex)`):
+Vuex предоставляет механизм «внедрения» хранилища во всех дочерних компонентах корневого компонента, у которого указана опция `store` (включается в `Vue.use(Vuex)`):
 
 ```js
 const app = new Vue({
   el: '#app',
-  // указываем хранилище в опции "store", что обеспечит
-  // доступ к нему также и для всех дочерних компонентов
+  // указываем хранилище в опции «store», что обеспечит
+  // доступ к нему также и во всех дочерних компонентах
   store,
   components: { Counter },
   template: `
@@ -43,7 +43,7 @@ const app = new Vue({
 });
 ```
 
-Указывая опцию `store` для корневого экземпляра, мы обеспечиваем доступ к хранилищу всем дочерним компонентам в `this.$store`. Давайте обновим наш пример со счётчиком:
+Указывая опцию `store` в корневом экземпляре, мы обеспечиваем доступ к хранилищу во всех дочерних компонентах через `this.$store`. Давайте обновим реализацию `Counter`:
 
 ```js
 const Counter = {
@@ -58,22 +58,23 @@ const Counter = {
 
 ### Вспомогательная функция `mapState`
 
-Если компонент использует множество свойств или геттеров хранилища, объявление доступа к ним всем вручную может заставить изрядно заскучать, да и код получится многословный. Чтобы обойти эту проблему, можно использовать хелпер `mapState`, автоматически генерирующий вычисляемые свойства, проксирующие доступ к состоянию и геттерам хранилища:
+Когда компонент должен использовать множество свойств или геттеров хранилища, объявлять все эти вычисляемые свойства может быть утомительно. В таких случаях можно использовать функцию `mapState`, которая автоматически генерирует вычисляемые свойства:
 
 ```js
-// с полной сборкой можно использовать как Vuex.mapState
+// В полной сборке функция доступна через Vuex.mapState
 import { mapState } from 'vuex';
 
 export default {
   // ...
   computed: mapState({
-    // стрелочные функции позволяют писать код очень лаконично
+    // стрелочные функции могут сделать код очень кратким
     count: state => state.count,
 
-    // передача строки 'count' эквивалентна записи `state => state.count`
+    // передача строки 'count' аналогична записи `state => state.count`
     countAlias: 'count',
 
-    // если требуется доступ и к локальному состоянию, нужно использовать традиционную функцию
+    // для доступа к локальному состоянию через `this`,
+    // необходимо использовать обычную функцию
     countPlusLocalState(state) {
       return state.count + this.localCount;
     }
@@ -81,23 +82,23 @@ export default {
 };
 ```
 
-В простых случаях в `mapState` можно передать и просто массив строк:
+Можно передавать массив строк в `mapState`, когда имя сопоставляемого вычисляемого свойства совпадает с именем в дереве состояний:
 
 ```js
 computed: mapState([
-  // проксирует через this.count доступ к store.state.count
+  // проксирует в this.count доступ к store.state.count
   'count'
 ]);
 ```
 
 ### Оператор распространения объектов
 
-Обратите внимание: `mapState` возвращает объект. Как же быть, если нам нужны и локальные вычисляемые свойства? Обычно в таких случаях приходилось использовать вспомогательные утилиты для слияния объектов, и передавать уже результат их работы в `computed`. Однако, применив [оператор распространения объектов](https://github.com/sebmarkbage/ecmascript-rest-spread) (находящегося в статусе stage-4 ECMAScript proposal) мы можем изрядно упростить запись:
+Обратите внимание, `mapState` возвращает объект. Как же его использовать в сочетании с другими локальными вычисляемыми свойствами? Для этого обычно приходилось использовать вспомогательные утилиты для объединения нескольких объектов в один, который передавать в `computed`. Однако, с помощью [оператора распространения объектов](https://github.com/sebmarkbage/ecmascript-rest-spread) (предложение находится в статусе stage-4 ECMAScript) можно значительно упростить синтаксис:
 
 ```js
 computed: {
   localComputed () { /* ... */ },
-  // результаты работы mapState будут добавлены в уже существующий объект
+  // смешиваем результат mapState с внешним объектом
   ...mapState({
     // ...
   })
@@ -106,4 +107,4 @@ computed: {
 
 ### Компоненты всё ещё могут иметь локальное состояние
 
-То что вы используете Vuex не значит, что нужно выносить в хранилище **всё** состояние приложения. Поместив большую часть логики во Vuex, вы сделаете мутации более красноречивыми и удобными для отладки, но это иногда может привести к излишней многословности и ненужному усложнению логики. Если состояние компонента полностью локально, выносить его во Vuex может быть бессмысленно. Конечное решение всегда остаётся на усмотрение разработчика и зависит от потребностей конкретного приложения.
+Использование Vuex **не означает, что нужно выносить всё состояние** в хранилище. Хотя перемещение большей части состояния во Vuex, сделает мутации более явными и удобными для отладки, это также может привести к многословности и ненужному усложнению логики. Если часть состояния относится только к одному компоненту, лучше оставить его в качестве локального состояния. Вы должны взвесить все компромиссы и принять решение, соответствующее потребностям приложения и вектора его развития.

docs/ru/installation.md

@@ -6,7 +6,7 @@
 
 <!--email_off-->
 
-[Unpkg.com](https://unpkg.com) предоставляет CDN-ссылки на содержимое NPM-пакетов. Приведённая выше ссылка всегда будет указывать на самый свежий релиз Vuex, доступный в NPM. Кроме того, можно указать конкретную версию или тег, например `https://unpkg.com/vuex@2.0.0`.
+[Unpkg.com](https://unpkg.com) предоставляет CDN-ссылки для NPM-пакетов. Ссылка, приведённая выше, всегда указывает на самый последней релиз Vuex, доступный в NPM. Кроме того, можно указывать в ссылке конкретную версию или тег, например `https://unpkg.com/vuex@2.0.0`.
 
 <!--/email_off-->
 
@@ -29,7 +29,7 @@ npm install vuex --save
 yarn add vuex
 ```
 
-Если вы используете систему сборки, установите Vuex явным образом командой `Vue.use()`:
+При использовании системы сборки — явно установите Vuex с помощью команды `Vue.use()`:
 
 ```js
 import Vue from 'vue';
@@ -42,24 +42,24 @@ Vue.use(Vuex);
 
 ### Promise
 
-Vuex для работы необходимы [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises). Если браузеры, которые вы поддерживаете не реализуют Promise (например, IE), то вы можете использовать библиотеку-полифилл, такую как [es6-promise](https://github.com/stefanpenner/es6-promise).
+Vuex использует в своей работе [Promise](https://developer.mozilla.org/ru/docs/Web/JavaScript/Guide/Ispolzovanie_promisov). Если необходимо поддерживать старые браузеры, которые не реализуют Promise (например, IE) — добавьте полифил, например [es6-promise](https://github.com/stefanpenner/es6-promise).
 
-Вы можете подключить её через CDN:
+Его можно подключить через CDN:
 
 ```html
 <script src="https://cdn.jsdelivr.net/npm/es6-promise@4/dist/es6-promise.auto.js"></script>
 ```
 
-Тогда `window.Promise` будет доступен автоматически.
+После этого `window.Promise` будет доступен автоматически.
 
-Если вы предпочитаете использовать менеджер пакетов, такой как NPM или Yarn, то установите пакет с помощью следующей команды:
+Если используете менеджер пакетов NPM или Yarn, то установите пакет следующей командой:
 
 ```bash
 npm install es6-promise --save # NPM
 yarn add es6-promise # Yarn
 ```
 
-Кроме того, добавьте строку ниже в любое место вашего кода перед использованием Vuex:
+И добавьте строку ниже с импортом в любое место вашего кода перед использованием Vuex:
 
 ```js
 import 'es6-promise/auto';
@@ -67,7 +67,7 @@ import 'es6-promise/auto';
 
 ### Версия для разработки
 
-Если вы хотите использовать самую новую dev-сборку `vuex`, то придётся вручную склонировать репозиторий с GitHub и запустить сборку:
+Для использования самой новой dev-сборки `vuex` — склонируйте репозиторий с GitHub вручную и запустите сборку:
 
 ```bash
 git clone https://github.com/vuejs/vuex.git node_modules/vuex