some orpho/language corrections

Author: shamansir

doc/ru/array/constructor.md

@@ -1,6 +1,6 @@
 ## Конструктор `Array`
 
-Так как в конструкторе `Array` есть некоторая двусмысленность кастательно его параметров, настоятельно рекомендуется всегда использовать синтаксис литеральной нотации — `[]` — при создании массивов.
+Так как в конструкторе `Array` есть некоторая двусмысленность касающаяся его параметров, настоятельно рекомендуется при создании массивов всегда использовать синтаксис литеральной нотации — `[]`.
 
     [1, 2, 3]; // Результат: [1, 2, 3]
     new Array(1, 2, 3); // Результат: [1, 2, 3]
@@ -9,7 +9,7 @@
     new Array(3); // Результат: []
     new Array('3') // Результат: ['3']
 
-В случае, когда в конструктор `Array` передается один аргумент и этот аргумент имеет тип `Number`, конструктор возвращает новый, *запоненный случайными значениями*, массив, имеющий длину равную значению переданного аргумента. Стоит заметить, что в этом случае будет установлено только свойство `length` нового массива, фактически индексы массива не будут проинициализированы.
+В случае, когда в конструктор `Array` передаётся один аргумент и этот аргумент имеет тип `Number`, конструктор возвращает новый, *заполненный случайными значениями*, массив, имеющий длину равную значению переданного аргумента. Стоит заметить, что в этом случае будет установлено только свойство `length` нового массива, индексы массива фактически не будут проинициализированы.
 
     var arr = new Array(3);
     arr[1]; // не определён, undefined

doc/ru/array/general.md

@@ -1,6 +1,6 @@
 ##  Итерации по массивам и свойства
 
-Не смотря на то, что массивы в JavaScript являются объектами, нет достаточных оснований для использования [цикла `for in`](#object.forinloop) для итерации по элементами. Фактически, существует несколько весомых причин **против** использования `for in` в массивах.
+Несмотря на то, что массивы в JavaScript являются объектами, нет достаточных оснований для использования [цикла `for in`](#object.forinloop) для итерации по элементам массива. Фактически, существует несколько весомых причин **против** использования `for in` в массивах.
 
 > **Замечание:** Массивы в JavaScript **не** являются *ассоциативными массивами*. Для связывания ключей и значений в JavaScript есть только [объекты](#object.general). И при том, что ассоциативные массивы **сохраняют** заданный порядок, объекты **не** делают этого.
 
@@ -17,13 +17,13 @@
 
 В примере выше есть один дополнительный приём, с помощью которого кэшируется величина длины массива: `l = list.length`.
 
-Не смотря на то, что свойство length определено в самом массиве, поиск этого свойства накладывает дополнительные расходы на каждой итерации цикла. Несмотря на то, что в этом случае новые движки JavaScript **могут** применять оптимизацию, нет способа узнать, будет оптимизирован код на новом движке или нет.
+Несмотря на то, что свойство `length` определено в самом массиве, поиск этого свойства накладывает дополнительные расходы на каждой итерации цикла. Пусть в этом случае новые движки JavaScript теоретически **могут** применить оптимизацию, но нет никакого способа узнать, будет оптимизирован код на новом движке или нет.
 
 Фактически, отсутствие кэширования может привести к выполнению цикла в **два раза медленнее**, чем при кэшировании длины
 
 ### Свойство `length`
 
-Несмотря на то, что *геттер* свойства `length` просто возвращает количество элементов содежащихся в массиве, *сеттер* можно использовать для **обрезания** массива.
+Хотя *геттер* свойства `length` просто возвращает количество элементов содежащихся в массиве, *сеттер* можно использовать для **обрезания** массива.
 
     var foo = [1, 2, 3, 4, 5, 6];
     foo.length = 3;
@@ -32,9 +32,9 @@
     foo.length = 6;
     foo; // [1, 2, 3]
 
-Присвоение свойству `length` меньшей величины урезает массив, однако присвоение большего значения не влечёт никакого эффекта.
+Присвоение свойству `length` меньшей величины урезает массив, однако присвоение большего значения не даст никакого эффекта.
 
 ### Заключение
 
-Для оптимального работы кода рекомендуется всегда использовать простой цикл `for` и кэшировать свойство `length`. Использование `for in` с массивами является признаком плохого кода, обладающего предпосылками к ошибкам и может привести к низкой скорости его выполнения.
+Для оптимальной работы кода рекомендуется всегда использовать простой цикл `for` и кэшировать свойство `length`. Использование `for in` с массивами является признаком плохого кода, обладающего предпосылками к ошибкам и может привести к низкой скорости его выполнения.
 

doc/ru/core/eval.md

@@ -1,6 +1,6 @@
 ## Почему нельзя использовать `eval`
 
-Функция `eval` выполняет строку кода JavaScript в локальном области видимости.
+Функция `eval` выполняет строку кода JavaScript в локальной области видимости.
 
     var foo = 1;
     function test() {
@@ -11,7 +11,7 @@
     test(); // 3
     foo; // 1
 
-Но `eval` исполняется в локальной области видимости только когда он вызывается **напрямую** *и при этом* имя вызываемой функции именно `eval`.
+Но `eval` исполняется в локальной области видимости только тогда, когда он вызывается **напрямую** *и при этом* имя вызываемой функции именно `eval`.
 
     var foo = 1;
     function test() {
@@ -31,9 +31,9 @@
 
 ### Проблемы с безопасностью
 
-Кроме всего прочего, функция `eval` — это проблема в безопасности, поскольку исполняется **любой** переданный в неё код, **никогда** не следует использовать её со строками из неизвестных или недоверительных источников.
+Кроме всего прочего, функция `eval` — это проблема в безопасности, поскольку исполняется **любой** переданный в неё код; **никогда** не следует использовать её со строками из неизвестных или недоверительных источников.
 
 ### Заключение
 
-Никогда не стоит использовать `eval`: любое применение такого кода поднимает вопросы о качестве его работы, производительности и безопасности. Если вдруг для работы вам необходим `eval`, эта часть должна тут же ставиться под сомнение и **не** должна использоваться в первую очередь — нужно использовать *лучший способ* , которому не требуются вызовы `eval`.
+Никогда не стоит использовать `eval`: любое применение такого кода поднимает вопросы о качестве его работы, производительности и безопасности. Если вдруг для работы вам необходим `eval`, эта часть должна тут же ставиться под сомнение и **не** должна использоваться в первую очередь — необходимо найти *лучший способ* , которому не требуются вызовы `eval`.
 

doc/ru/core/semicolon.md

@@ -2,7 +2,7 @@
 
 Хоть JavaScript и имеет синтаксис, подобный языкам семейства C, он при этом **не** принуждает вас ставить точки с запятой в исходном коде — вы всегда можете их опустить.
 
-При этом JavaScript — не язык без точек с запятой, они на самом деле нужны ему, чтобы он мог разобраться в вашем коде. Поэтому парсер JavaScript **автоматически** вставляет их в те места, где сталкивается с ошибкой парсинга из-за отсутствия точки с запятой.
+При этом JavaScript — не язык без точек с запятой, они на самом деле нужны ему, чтобы он мог разобраться в вашем коде. Поэтому парсер JavaScript **автоматически** вставляет их в те места, где сталкивается с ошибкой парсинга из-за их отсутствия.
 
     var foo = function() {
     } // ошибка разбора, ожидается точка с запятой
@@ -77,7 +77,7 @@
 
     })(window); //<- вставлена
 
-> **Замечание:** Парсер JavaScript некорректно обрабатывает оператор return, за которым следует новая строка; кстати, причина может быть и не в автоматической вставке точек с запятой, но это в любом случае нежелательный побочный эффект
+> **Замечание:** Парсер JavaScript некорректно обрабатывает оператор `return`, за которым следует новая строка; кстати, причина может быть и не в автоматической вставке точек с запятой, но это в любом случае нежелательный побочный эффект
 
 Парсер радикально подменил поведение изначального кода, а в определённых случаях он сделал **абсолютно неправильные выводы**.
 
@@ -96,5 +96,5 @@
 
 ### Заключение
 
-Настоятельно рекомендуем **никогда** не забывать ставить или опускать точку с запятой; так же рекомендуется оставлять скобки на одной строке с соответствующим оператором и никогда не опускать их для выражений с использованием `if` / `else`. Оба этих совета не только повысят читабельность вашего кода, но и предотвратят от изменения поведения этого кода, произведённого парсером втихую.
+Настоятельно рекомендуем **никогда** не забывать ставить точку с запятой; так же рекомендуется оставлять скобки на одной строке с соответствующим оператором и никогда не опускать их для выражений с использованием `if` / `else`. Оба этих совета не только повысят читабельность вашего кода, но и предотвратят от изменения поведения кода, произведённого парсером втихую.
 

doc/ru/core/undefined.md

@@ -21,9 +21,9 @@
 
 ### Обработка изменений значения `undefined`
 
-Поскольку глобальная переменная `undefined` содержит копию настоящего *значения* `undefined`, присвоение этой переменной нового значения **не** изменяет значения или *типа* `undefined`.
+Поскольку глобальная переменная `undefined` содержит копию настоящего *значения* `undefined`, присвоение этой переменной нового значения **не** изменяет значения *типа* `undefined`.
 
-Но при этом, чтобы сравнить что-либо со значением `undefined` прежде важно получить значение самой переменной `undefined`.
+Но при этом, чтобы сравнить что-либо со *значением* `undefined` прежде нужно получить значение самой *переменной* `undefined`.
 
 Чтобы защитить код от переопределения переменной `undefined`, часто используется техника [анонимной обёртки](#function.scopes), которая использует отсутствующий аргумент.
 
@@ -34,7 +34,7 @@
 
     })('Hello World', 42);
 
-Другой способ достичь того же эффекта — использовать опредение внутри обёртки.
+Другой способ достичь того же эффекта — использовать определение внутри обёртки.
 
     var undefined = 123;
     (function(something, foo) {

doc/ru/function/arguments.md

@@ -66,7 +66,7 @@
 
 ### Мифы и правда о производительности
 
-Объект `arguments` создаётся во всех случаях, лишь за двумя исключениями — когда он переопределён внутри функции (по имени) или когда одним из её параметров является переменная с таким именем. Не важно, используется при этом сам объект или нет.
+Объект `arguments` создаётся во всех случаях, лишь за двумя исключениями — когда он переопределён внутри функции (по имени) или когда одним из её параметров является переменная с таким именем. Неважно, используется при этом сам объект или нет.
 
 *Геттеры* и *сеттеры* создаются **всегда**; так что, их использование практически никак не влияет на производительность.
 
@@ -85,7 +85,7 @@
         }
     }
 
-В коде выше, `foo` больше не может [быть развёрнута][1], потому что для работы ей необходима ссылка и на себя и на вызвавший её объект. Это не только кладёт на лопатки механизм развёртывания, но и нарушает принцип инкапсуляции, поскольку функция становится зависима от конкретного контекста вызова.
+В коде выше, функция `foo` не может [быть развёрнута][1] (а могла бы), потому что для корректной работы ей необходима ссылка и на себя и на вызвавший её объект. Это не только кладёт на лопатки механизм развёртывания, но и нарушает принцип инкапсуляции, поскольку функция становится зависима от конкретного контекста вызова.
 
 **Крайне не рекомендуется** использовать `arguments.callee` или какое-либо из его свойств. **Никогда**.
 

doc/ru/function/closures.md

@@ -1,6 +1,6 @@
 ## Замыкания и ссылки
 
-Одним из самых мощных инструментов JavaScript'а считаются возмжность создавать *замыкания* — это когда наша область видимости **всегда** имеет доступ к внешней области, в которой она была объявлена. Собственно, единственный механизм работы с областями видимости в JavaScript — это [функции](#function.scopes): т.е. объявляя функцию, вы автоматически реализуете замыкания.
+Одним из самых мощных инструментов JavaScript'а считаются возможность создавать *замыкания* — это такой приём, когда наша область видимости **всегда** имеет доступ к внешней области, в которой она была объявлена. Собственно, единственный механизм работы с областями видимости в JavaScript — это [функции](#function.scopes): т.о. объявляя функцию, вы автоматически реализуете замыкания.
 
 ### Эмуляция приватных свойств