fix(guide): simplify directory structure

guide/russian/javascript/standard-objects/array/array-destructuring/index.md

@@ -0,0 +1,91 @@
+---
+title: Array Destructuring
+localeTitle: Разрушение массива
+---
+# Разрушение массива
+
+Деструктурирование - удобный способ извлечения нескольких значений из данных, хранящихся в массивах. Он может использоваться в местах, которые получают данные (например, левую часть задания). Эта функция представлена ​​в `ECMAScript 6` .
+
+Как извлечь значения задается с помощью шаблонов (читайте далее для примеров).
+
+### Основное назначение переменных
+```
+var names = ['neel', 'meet', 'darshan']; 
+ var [nameOne, nameTwo, nameThree] = names; 
+ console.log(nameOne); // "neel" 
+ console.log(nameTwo); // "meet" 
+ console.log(nameThree); // "darshan" 
+```
+
+### Назначение отдельно от декларации
+
+Переменной может быть присвоено ее значение через деструктурирование отдельно от объявления переменной.
+```
+var a, b; 
+ 
+ [a, b] = [1, 2]; 
+ console.log(a); // 1 
+ console.log(b); // 2 
+```
+
+### Значения по умолчанию
+
+Переменной может быть присвоено значение по умолчанию, в случае, если значение, распакованное из массива, не `undefined` .
+```
+var a, b; 
+ 
+ [a=5, b=7] = [1]; 
+ console.log(a); // 1 
+ console.log(b); // 7 
+```
+
+### Анализ массива, возвращаемого функцией
+
+Всегда можно было возвращать массив из функции. Деструктурирование может сделать работу с возвращаемым значением массива более кратким.
+
+В этом примере `getNames()` возвращает значения `['neel', 'meet']` качестве своего вывода, которые могут быть проанализированы в одной строке с деструктурированием.
+```
+function getNames() { 
+  return ['neel', 'meet']; 
+ } 
+ 
+ var neel, meet; 
+ [nameOne, nameTwo] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameTwo); // meet 
+```
+
+### Игнорирование некоторых возвращаемых значений
+
+Вы можете игнорировать возвращаемые значения, которые вам не интересны:
+```
+function getNames() { 
+  return ['neel', 'meet', 'darshan']; 
+ } 
+ 
+ var [nameOne, , nameThree] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameThree); // darshan 
+```
+
+Вы также можете игнорировать все возвращаемые значения:
+```
+[,,] = getNames(); 
+```
+
+### Присвоение остальной части массива переменной
+
+При деструкции массива вы можете распаковать и назначить оставшуюся часть переменной переменной, используя шаблон rest:
+```
+var [a, ...b] = [1, 2, 3]; 
+ console.log(a); // 1 
+ console.log(b); // [2, 3] 
+```
+
+Обратите внимание, что `SyntaxError` будет `SyntaxError` , если задняя запятая используется с левой стороны с элементом отдыха:
+```
+var [a, ...b,] = [1, 2, 3]; 
+ // SyntaxError: rest element may not have a trailing comma 
+```
+
+См. Также: **Разрушение массива** | [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Array_destructuring)

guide/russian/javascript/standard-objects/array/array-from/index.md

@@ -0,0 +1,19 @@
+---
+title: Array from
+localeTitle: Массив из
+---
+## Массив из
+
+Метод Array.from () создает новый экземпляр массива из объекта, подобного массиву или итерации.
+
+### Синтаксис:
+
+«»» Array.from (arrayLike \[, mapFn \[, thisArg\]\]) «»»
+
+### Пример:
+
+«»» Array.from ( 'Foo'); // \["f", "o", "o"\] «»»
+
+#### Дополнительная информация:
+
+[Документация MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from)

guide/russian/javascript/standard-objects/array/array-isarray/index.md

@@ -0,0 +1,38 @@
+---
+title: Array isArray
+localeTitle: Array isArray
+---
+Метод `Array.isArray()` возвращает `true` если объект является массивом, `false` если это не так.
+
+## Синтаксис
+```
+Array.isArray(obj) 
+```
+
+### параметры
+
+**obj** Объект, подлежащий проверке.
+
+[Ссылка MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) | [Ссылка MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff848265%28v=vs.94%29.aspx)
+
+## Примеры
+```
+// all following calls return true 
+ Array.isArray([]); 
+ Array.isArray([1]); 
+ Array.isArray(new Array()); 
+ // Little known fact: Array.prototype itself is an array: 
+ Array.isArray(Array.prototype); 
+ 
+ // all following calls return false 
+ Array.isArray(); 
+ Array.isArray({}); 
+ Array.isArray(null); 
+ Array.isArray(undefined); 
+ Array.isArray(17); 
+ Array.isArray('Array'); 
+ Array.isArray(true); 
+ Array.isArray(false); 
+ Array.isArray({ __proto__: Array.prototype }); 
+
+```

guide/russian/javascript/standard-objects/array/array-length/index.md

@@ -0,0 +1,26 @@
+---
+title: Array Length
+localeTitle: Длина массива
+---
+## Длина массива
+
+`length` - свойство массивов в JavaScript, которое возвращает или задает количество элементов в заданном массиве.
+
+Свойство `length` массива может быть возвращено так же.
+
+```js
+let desserts = ["Cake", "Pie", "Brownies"]; 
+ console.log(desserts.length); // 3 
+```
+
+Оператор присваивания в сочетании с свойством `length` может использоваться для установки количества элементов в массиве, подобном этому.
+
+```js
+let cars = ["Saab", "BMW", "Volvo"]; 
+ cars.length = 2; 
+ console.log(cars.length); // 2 
+```
+
+#### Дополнительная информация:
+
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Array/length

guide/russian/javascript/standard-objects/array/array-of/index.md

@@ -0,0 +1,27 @@
+---
+title: Array of
+localeTitle: Массив
+---
+## Массив
+
+Метод Array.of () создает новый экземпляр Array с переменным числом аргументов, независимо от числа или типа аргументов.
+
+Синтаксис:
+
+```javascript
+Array.of(element0[, element1[, ...[, elementN]]]) 
+```
+
+## пример
+
+```javascript
+Array.of(7);       // [7] - creates an array with a single element 
+ Array.of(1, 2, 3); // [1, 2, 3] 
+ 
+ Array(7);          // [ , , , , , , ] - creates an empty array with a length property of 7 
+ Array(1, 2, 3);    // [1, 2, 3] 
+```
+
+#### Дополнительная информация:
+
+Для получения дополнительной информации посетите [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

guide/russian/javascript/standard-objects/array/array-prototype-concat/index.md

@@ -0,0 +1,45 @@
+---
+title: Array.prototype.concat
+localeTitle: Array.prototype.concat
+---
+## Array.prototype.concat
+
+Метод concat возвращает новый массив, состоящий из элементов массива, на который вы его вызываете, за которым следуют элементы аргументов в том порядке, в котором они переданы.
+
+Вы можете передать несколько аргументов методу 'concat'. Аргументами могут быть массивы или типы данных, такие как логические строки, строки и числа.
+
+### Синтаксис
+
+```javascript
+const newArray = array.concat(value1, value2, value3...); 
+```
+
+### Примеры
+
+#### Объединение двух массивов
+
+```javascript
+var cold = ['Blue', 'Green', 'Purple']; 
+ var warm = ['Red', 'Orange', 'Yellow']; 
+ 
+ var result = cold.concat(warm); 
+ 
+ console.log(result); 
+ // results in ['Blue', 'Green', 'Purple', 'Red', 'Orange', 'Yellow']; 
+```
+
+#### Объединение значения в массив
+
+```javascript
+const odd = [1, 3, 5, 7, 9]; 
+ const even = [0, 2, 4, 6, 8]; 
+ 
+ const oddAndEvenAndTen = odd.concat(even, 10); 
+ 
+ console.log(oddAndEvenAndTen); 
+ // results in [1, 3, 5, 7, 9, 0, 2, 4, 6, 8, 10]; 
+```
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)

guide/russian/javascript/standard-objects/array/array-prototype-copywithin/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.copyWithin
+localeTitle: Array.prototype.copyWithin
+---
+## Array.prototype.copyWithin
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-copywithin/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/javascript/standard-objects/array/array-prototype-entries/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.entries
+localeTitle: Array.prototype.entries
+---
+## Array.prototype.entries
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-entries/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/javascript/standard-objects/array/array-prototype-every/index.md

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.every
+localeTitle: Array.prototype.every
+---
+Метод `every()` проверяет, прошли ли все элементы массива тест, реализованный предоставленной функцией.
+
+**Синтаксис**
+
+```javascript
+  arr.every(callback[, thisArg]) 
+```
+
+## параметры
+
+*   **callback** Функция для проверки для каждого элемента, принимая три аргумента:
+    
+    *   **currentValue** (обязательно)
+        
+        Текущий элемент обрабатывается в массиве.
+        
+    *   **индекс** (необязательно)
+        
+        Индекс текущего элемента обрабатывается в массиве.
+        
+    *   **массив** (необязательно)
+        
+        Каждый массив был вызван.
+        
+*   **thisArg** Необязательно. Значение, которое необходимо использовать при выполнении обратного вызова.
+    
+
+[Ссылка MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) | [Ссылка MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679981%28v=vs.94%29.aspx)
+
+## Описание
+
+`every` метод вызывает функцию `callback` один раз для каждого элемента массива в порядке возрастания индекса, пока функция `callback` вернет значение false. Если элемент, вызывающий `callback` для возврата false, найден, каждый метод немедленно возвращает `false` . В противном случае каждый метод возвращает `true` .
+
+Функция обратного вызова не вызывается для отсутствующих элементов массива.
+
+В дополнение к объектам массива, каждый метод может использоваться любым объектом, обладающим свойством length и имеющим численные индексированные имена свойств. `every` не мутирует массив, на который он вызывается.
+
+## Примеры
+
+```javascript
+  function isBigEnough(element, index, array) { 
+    return element >= 10; 
+  } 
+  [12, 5, 8, 130, 44].every(isBigEnough);   // false 
+  [12, 54, 18, 130, 44].every(isBigEnough); // true 
+ 
+  // Define the callback function. 
+  function CheckIfEven(value, index, ar) { 
+      document.write(value + " "); 
+ 
+      if (value % 2 == 0) 
+          return true; 
+      else 
+          return false; 
+  } 
+ 
+  // Create an array. 
+  var numbers = [2, 4, 5, 6, 8]; 
+ 
+  // Check whether the callback function returns true for all of the 
+  // array values. 
+  if (numbers.every(CheckIfEven)) 
+      document.write("All are even."); 
+  else 
+      document.write("Some are not even."); 
+ 
+  // Output: 
+  // 2 4 5 Some are not even. 
+
+```

guide/russian/javascript/standard-objects/array/array-prototype-fill/index.md

@@ -0,0 +1,26 @@
+---
+title: Array.prototype.fill
+localeTitle: Array.prototype.fill
+---
+## Array.prototype.fill
+
+Метод fill () заполняет все элементы массива статическим значением.
+
+Синтаксис:
+
+\`\` \`javascript arr.fill (значение) arr.fill (значение, начало) arr.fill (значение, начало, конец)
+```
+The fill method takes up to three arguments value, start and end. The start and end arguments are optional with default values of 0 and the length of the this object. 
+ 
+ The fill method is a mutable method, it will change this object itself, and return it, not just return a copy of it. 
+ 
+ ## Examples 
+```
+
+Javascript \[1, 2, 3\]. Заполнить (4); // \[4, 4, 4\] \[1, 2, 3\]. Заполнить (4, 1); // \[1, 4, 4\]
+
+var fruits = \["Grape", "Pear", "Apple", "Strawberry"\]; fruit.fill («Арбуз», 2, 4); // Банан, груша, арбуз, арбуз \`\` \`
+
+#### Дополнительная информация:
+
+Для получения дополнительной информации посетите [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill)

guide/russian/javascript/standard-objects/array/array-prototype-filter/index.md

@@ -0,0 +1,78 @@
+---
+title: Array.prototype.filter
+localeTitle: Array.prototype.filter
+---
+## Array.prototype.filter
+
+Метод фильтра принимает массив как вход. Он принимает каждый элемент в массиве и применяет к нему условное утверждение. Если это условие возвращает true, элемент получает «push» в выходной массив.
+
+Как только каждый элемент входного массива «фильтруется» как таковой, он выводит новый массив, содержащий каждый элемент, который возвращал true.
+
+В этом примере ниже представлен массив, в котором есть несколько объектов. Как правило, для итерации через этот массив вы можете использовать цикл for.
+
+В этом случае мы хотим получить всех учеников, чьи оценки больше или равны 90.
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ //Define an array to push student objects to. 
+ var studentsGrades = [] 
+ for (var i = 0; i < students.length; i++) { 
+  //Check if grade is greater than 90 
+  if (students[i].grade >= 90) { 
+    //Add a student to the studentsGrades array. 
+    studentsGrades.push(students[i]) 
+  } 
+ } 
+ 
+ return studentsGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+Это для цикла работает, но он довольно длинный. Также может потребоваться много времени писать для циклов для многих массивов, которые вам нужно перебирать.
+
+Это отличный вариант для фильтра!
+
+Вот тот же пример с использованием фильтра:
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ 
+ var studentGrades = students.filter(function (student) { 
+  //This tests if student.grade is greater than or equal to 90. It returns the "student" object if this conditional is met. 
+  return student.grade >= 90; 
+ }); 
+ 
+ return studentGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+Метод фильтра намного быстрее записывается и чистят, чтобы читать, все еще выполняя одно и то же. Используя синтаксис ES6, мы можем даже реплицировать 6-строчный цикл for-loop с фильтром:
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ 
+ var studentGrades = students.filter(student => student.grade >= 90); 
+ return studentGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+Фильтр очень полезен и имеет большой выбор для циклов для фильтрации массивов по условным операторам.
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)

guide/russian/javascript/standard-objects/array/array-prototype-find/index.md

@@ -0,0 +1,71 @@
+---
+title: Array.prototype.find
+localeTitle: Array.prototype.find
+---
+## Информация
+
+Метод `find()` возвращает значение первого элемента в массиве, который удовлетворяет предоставленной функции тестирования. В противном случае возвращается undefined. Метод `find()` не мутирует массив, на который он вызывается.
+
+Синтаксис:
+```
+arr.find(callback[, thisArg]) 
+```
+
+##### параметры
+
+*   `callback`
+*   Функция для выполнения по каждому значению в массиве, используя три аргумента:
+*   `element`
+    *   Текущий элемент обрабатывается в массиве.
+*   `index`
+    *   Индекс текущего элемента обрабатывается в массиве.
+*   `array`
+    *   Призыв массива был вызван.
+*   `thisArg` (необязательно)
+*   Объект, который будет использоваться при выполнении обратного вызова.
+
+##### Возвращаемое значение
+
+Значение в массиве, если элемент проходит тест; в противном случае не определено.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
+
+## Примеры
+
+Этот пример найдет соответствующий элемент в массиве и вернет объект из него.
+
+```javascript
+let items = [ 
+    {name: 'books', quantity: 2}, 
+    {name: 'movies', quantity: 1}, 
+    {name: 'games', quantity: 5} 
+ ]; 
+ 
+ function findMovies(item) { 
+    return item.name === 'movies'; 
+ } 
+ 
+ console.log(items.find(findMovies)); 
+ 
+ // Output 
+ //  { name: 'movies', quantity: 1 } 
+```
+
+В следующем примере показан вывод каждого необязательного параметра функции обратного вызова. Это вернет `undefined` потому что ни один из элементов не вернет true из функции обратного вызова.
+
+```javascript
+function showInfo(element, index, array) { 
+  console.log('element = ' + element + ', index = ' + index + ', array = ' + array); 
+  return false; 
+ } 
+ 
+ console.log('return = ' + [4, 6, 8, 12].find(showInfo)); 
+ 
+ // Output 
+ //  element = 4, index = 0, array = 4,6,8,12 
+ //  element = 6, index = 1, array = 4,6,8,12 
+ //  element = 8, index = 2, array = 4,6,8,12 
+ //  element = 12, index = 3, array = 4,6,8,12 
+ //  return = undefined 
+
+```

guide/russian/javascript/standard-objects/array/array-prototype-findindex/index.md

@@ -0,0 +1,73 @@
+---
+title: Array.prototype.findIndex
+localeTitle: Array.prototype.findIndex
+---
+## Информация
+
+Метод `findIndex()` возвращает индекс первого элемента в массиве, который удовлетворяет предоставленной функции тестирования. В противном случае возвращается -1.
+
+Метод `findIndex()` не мутирует массив, на который он вызывается.
+
+Синтаксис:
+```
+arr.findIndex(callback[, thisArg]) 
+```
+
+##### параметры
+
+*   `callback`
+*   Функция для выполнения по каждому значению в массиве, используя три аргумента:
+*   `element`
+    *   Текущий элемент обрабатывается в массиве.
+*   `index`
+    *   Индекс текущего элемента обрабатывается в массиве.
+*   `array`
+    *   Был вызван массив findIndex ().
+*   `thisArg` (необязательно)
+*   Объект, который будет использоваться при выполнении обратного вызова.
+
+##### Возвращаемое значение
+
+Индекс в массиве, если элемент проходит тест; в противном случае -1.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
+
+## Примеры
+
+Этот пример найдет соответствующий элемент в массиве и вернет индекс из него.
+
+```javascript
+let items = [ 
+    {name: 'books', quantity: 2}, 
+    {name: 'movies', quantity: 1}, 
+    {name: 'games', quantity: 5} 
+ ]; 
+ 
+ function findMovies(item) { 
+    return item.name === 'movies'; 
+ } 
+ 
+ console.log(items.findIndex(findMovies)); 
+ 
+ // Index of 2nd element in the Array is returned, 
+ // so this will result in '1' 
+```
+
+В следующем примере показан вывод каждого необязательного параметра функции обратного вызова. Это вернет `-1` потому что ни один из элементов не вернет true из функции обратного вызова.
+
+```javascript
+function showInfo(element, index, array) { 
+  console.log('element = ' + element + ', index = ' + index + ', array = ' + array); 
+  return false; 
+ } 
+ 
+ console.log('return = ' + [4, 6, 8, 12].findIndex(showInfo)); 
+ 
+ // Output 
+ //  element = 4, index = 0, array = 4,6,8,12 
+ //  element = 6, index = 1, array = 4,6,8,12 
+ //  element = 8, index = 2, array = 4,6,8,12 
+ //  element = 12, index = 3, array = 4,6,8,12 
+ //  return = -1 
+
+```

guide/russian/javascript/standard-objects/array/array-prototype-foreach/index.md

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.forEach
+localeTitle: Array.prototype.forEach
+---
+## Array.prototype.forEach
+
+Метод массива 'forEach' используется для итерации по каждому элементу массива. Метод вызывается в массиве Object и передается функция, вызываемая для каждого элемента массива.
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr.forEach(number => console.log(number * 2)); 
+ 
+ // 2 
+ // 4 
+ // 6 
+ // 8 
+ // 10 
+```
+
+Функция обратного вызова также может принимать второй параметр индекса, если вам нужно ссылаться на индекс текущего элемента в массиве.
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr.forEach((number, i) => console.log(`${number} is at index ${i}`)); 
+ 
+ // '1 is at index 0' 
+ // '2 is at index 1' 
+ // '3 is at index 2' 
+ // '4 is at index 3' 
+ // '5 is at index 4' 
+```
+
+#### Дополнительная информация:
+
+[Статья MDN на Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)

guide/russian/javascript/standard-objects/array/array-prototype-includes/index.md

@@ -0,0 +1,24 @@
+---
+title: Array.prototype.includes
+localeTitle: Array.prototype.includes
+---
+## Array.prototype.includes
+
+Метод `includes()` определяет, содержит ли массив значение. Он возвращает true или false.
+
+Это два аргумента:
+
+1.  `searchValue` - элемент для поиска в массиве.
+2.  `fromIndex` - позиция в массиве, чтобы начать поиск созданного `searchValue` . Если подано отрицательное значение, оно начинается с длины массива минус отрицательное значение.
+
+### пример
+
+```js
+const a = [1, 2, 3]; 
+ a.includes(2); // true 
+ a.includes(4); // false 
+```
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)

guide/russian/javascript/standard-objects/array/array-prototype-indexof/index.md

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.indexOf
+localeTitle: Array.prototype.indexOf
+---
+## Array.prototype.indexOf
+
+Метод `indexOf()` возвращает первый индекс, в котором данный элемент может быть найден в массиве. Если элемент отсутствует, он возвращает -1.
+
+**Синтаксис**
+
+```javascript
+  arr.indexOf(searchElement[, fromIndex]) 
+```
+
+## параметры
+
+*   **searchElement** Element, для которого вы ищете
+    
+*   **fromIndex** Дополнительно. Индекс, по которому вы хотите начать поиск. Если значение Index больше или равно длине массива, массив не выполняется, и метод возвращает -1. Если fromIndex является отрицательным числом, он считает смещение от конца массива (массив по-прежнему ищет вперед оттуда). Значение по умолчанию равно 0, что означает поиск всего массива.
+    
+
+## Описание
+
+Метод `indexOf` принимает каждый элемент массива в порядке возрастания индекса и проверяет его на `searchElement` с использованием строгого равенства ( `===` ). Когда он найдет элемент, который возвращает `true` , он возвращает свой индекс.
+
+## Примеры
+
+```javascript
+var array = [1, 2, 4, 1, 7] 
+ 
+ array.indexOf(1); // 0 
+ array.indexOf(7); // 4 
+ array.indexOf(6); // -1 
+ array.indexOf('1'); // -1 
+ array.indexOf('hello'); // -1 
+ array.indexOf(1, 2); // 3 
+ array.indexOf(1, -3); // 3 
+```
+
+### Дополнительная информация:
+
+[Ссылка MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+
+[Ссылка MSDN](https://docs.microsoft.com/en-us/scripting/javascript/reference/indexof-method-array-javascript)

guide/russian/javascript/standard-objects/array/array-prototype-join/index.md

@@ -0,0 +1,39 @@
+---
+title: Array.prototype.join
+localeTitle: Array.prototype.join
+---
+Метод массива JavaScript `.join()` объединяет все элементы массива в одну строку.
+
+**Синтаксис**
+
+```javascript
+  var array = ["Lorem", "Ipsum", "Dolor", "Sit"]; 
+  var str = array.join([separator]); 
+```
+
+## параметры
+
+**разделитель**
+
+Необязательный. Указывает строку, используемую для разделения каждого элемента исходного массива. Если разделитель не является строкой, он будет преобразован в строку. Если параметр разделителя не указан, элементы массива по умолчанию разделяются запятой. Если разделитель представляет собой пустую строку `""` , все элементы массива соединяются без разделительного символа между ними.
+
+## Описание
+
+`.join()` объединяет все элементы массива в одну строку. Если какой-либо из элементов массива не `undefined` или равен `null` , этот элемент преобразуется в пустую строку `""` .
+
+## Примеры
+
+**Использование `.join()` четыре разных способа**
+
+```javascript
+  var array = ["Lorem", "Ipsum", "Dolor" ,"Sit"]; 
+ 
+  var join1 = array.join();           /* assigns "Lorem,Ipsum,Dolor,Sit" to join1 variable 
+                                         (because no separator was provided .join() 
+                                         defaulted to using a comma) */ 
+  var join2 = array.join(", ");       // assigns "Lorem, Ipsum, Dolor, Sit" to join2 variable 
+  var join3 = array.join(" + ");      // assigns "Lorem + Ipsum + Dolor + Sit" to join3 variable 
+  var join4 = array.join("");         // assigns "LoremIpsumDolorSit" to join4 variable 
+```
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join)

guide/russian/javascript/standard-objects/array/array-prototype-lastindexof/index.md

@@ -0,0 +1,75 @@
+---
+title: Array.prototype.lastIndexOf
+localeTitle: Array.prototype.lastIndexOf
+---
+## Array.prototype.lastIndexof
+
+Метод `lastIndexOf()` возвращает последний индекс, в котором данный элемент может быть найден в массиве, или -1, если он отсутствует. Массив выполняется в обратном порядке, начиная `fromIndex` .
+
+**Синтаксис**
+
+```javascript
+  arr.lastIndexOf(searchElement, fromIndex = arr.length - 1]) 
+```
+
+## параметры
+
+*   **searchElement**
+    
+    *   Элемент для поиска в массиве.
+*   **fromIndex**
+    
+    *   _Необязательно_ . Индекс, с которого нужно начать поиск назад. По умолчанию используется длина массива минус единица, т. Е. Будет проверен весь массив. Если индекс больше или равен длине массива, будет проверен весь массив. Если значение отрицательное, оно принимается за смещение от конца массива. Обратите внимание, что даже когда индекс отрицательный, массив по-прежнему выполняется с обратной стороны. Если вычисленный индекс меньше 0, возвращается -1, т.е. массив не будет искать.
+
+[Ссылка MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) | [Ссылка MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679972%28v=vs.94%29.aspx)
+
+## Возвращает
+
+Индекс последнего вхождения `searchElement` в массиве, или -1, если `searchElement` не найден.
+
+## Описание
+
+`lastIndexOf` сравнивает `searchElement` с элементами массива с использованием строгого равенства (тот же метод, который используется оператором === или triple-equals, operator).
+
+## замечания
+
+Поиск происходит в порядке убывания индекса (последний член сначала). Для поиска в порядке возрастания используйте метод `indexOf` .
+
+Необязательный аргумент `fromIndex` указывает индекс массива, с которого начинается поиск. Если `fromIndex` больше или равно длине массива, выполняется поиск всего массива. Если `fromIndex` отрицательный, поиск начинается с длины массива плюс `fromIndex` . Если вычисленный индекс меньше 0, возвращается -1.
+
+## Примеры
+
+```javascript
+  var array = [2, 5, 9, 2]; 
+  array.lastIndexOf(2);     // 3 
+  array.lastIndexOf(7);     // -1 
+  array.lastIndexOf(2, 3);  // 3 
+  array.lastIndexOf(2, 2);  // 0 
+  array.lastIndexOf(2, -2); // 0 
+  array.lastIndexOf(2, -1); // 3 
+ 
+  // Create an array. 
+  var ar = ["ab", "cd", "ef", "ab", "cd"]; 
+ 
+  // Determine the first location, in descending order, of "cd". 
+  document.write(ar.lastIndexOf("cd") + "<br/>"); 
+ 
+  // Output: 4 
+ 
+  // Find "cd" in descending order, starting at index 2. 
+  document.write(ar.lastIndexOf("cd", 2) + "<br/>"); 
+ 
+  // Output: 1 
+ 
+  // Search for "gh" (which is not found). 
+  document.write(ar.lastIndexOf("gh")+ "<br/>"); 
+ 
+  // Output: -1 
+ 
+  // Find "ab" with a fromIndex argument of -3. 
+  // The search in descending order starts at index 3, 
+  // which is the array length minus 2. 
+  document.write(ar.lastIndexOf("ab", -3) + "<br/>"); 
+  // Output: 0 
+
+```

guide/russian/javascript/standard-objects/array/array-prototype-map/index.md

@@ -0,0 +1,32 @@
+---
+title: Array.prototype.map
+localeTitle: Array.prototype.map
+---
+## Array.prototype.map
+
+Метод `.map()` проходит через данный массив и выполняет предоставленную функцию для каждого элемента. Он возвращает новый массив, который содержит результаты вызова функции для каждого элемента.
+
+### Примеры
+
+**ES5**
+
+```js
+var arr = [1, 2, 3, 4]; 
+ var newArray = arr.map(function(element) { return element * 2}); 
+ console.log(newArray); // [2, 4, 6, 8] 
+```
+
+**ES6**
+
+```js
+const arr = [1, 2, 3, 4]; 
+ const newArray = arr.map(element => element * 2); 
+ console.log(newArray); 
+ //[2, 4, 6, 8] 
+```
+
+**Дополнительная информация**
+
+Вот интерактивный скринкаст Scrimba, который объясняет `Array.prototype.map()` :
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)

guide/russian/javascript/standard-objects/array/array-prototype-pop/index.md

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.pop
+localeTitle: Array.prototype.pop
+---
+# Array.prototype.pop
+
+Метод `pop()` удаляет последний элемент из и изменяет длину массива.
+
+**Синтаксис**
+
+```js
+    arr.pop() 
+```
+
+**Возвращаемое значение**
+
+*   Удаленный элемент из массива; undefined, если массив пуст.
+
+## Описание
+
+Метод `pop()` удаляет последний элемент из массива и возвращает это значение вызывающему.
+
+Если вы вызываете `pop()` в пустом массиве, он возвращает undefined.
+
+## Примеры
+
+```js
+let array = [1, 2, 3, 4]; 
+ array.pop(); // removes 4 
+ console.log(array); // [1, 2, 3] 
+ 
+ [].pop() // undefined 
+```
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

guide/russian/javascript/standard-objects/array/array-prototype-push/index.md

@@ -0,0 +1,52 @@
+---
+title: Array.prototype.push
+localeTitle: Array.prototype.push
+---
+Метод `push()` используется для добавления одного или нескольких новых элементов в конец массива. Он также возвращает новую длину массива.
+
+### Синтаксис
+
+```javascript
+arr.push([element1[, ...[, elementN]]]) 
+```
+
+### параметры
+
+*   **elementN** Элементы для добавления в конец массива.
+
+### Возвращаемое значение
+
+Новая длина массива, на который был вызван метод.
+
+## Описание
+
+Метод `push()` будет _толкать_ элементы до конца массива. Он может принимать ноль или более аргументов. Если аргументы не предоставлены, он просто вернет текущую длину массива. Если предоставлен один или несколько аргументов, он добавит эти аргументы в массив в том порядке, в котором они написаны.
+
+Этот метод также возвращает новую длину массива после нажатия на элемент (элементы).
+
+## Пример:
+
+```javascript
+var myStarkFamily = ['John', 'Robb', 'Sansa', 'Bran']; 
+```
+
+Предположим, у вас есть массив детей Дома Старка из «Игры престолов». Однако один из членов, **Арья** , отсутствует. Зная код выше, вы можете добавить ее, присвоив `'Arya'` массиву в индексе после последнего индекса, например:
+
+```javascript
+myStarkFamily[4] = 'Arya'; 
+```
+
+Проблема с этим решением заключается в том, что он не может обрабатывать общие случаи. Если вы заранее не знали, что такое длина массива, вы не можете добавлять новые элементы таким образом. Это то, что для `push()` . Нам не нужно знать, как долго массив. Мы просто добавляем наш элемент до конца массива.
+
+```javascript
+myStarkFamily.push('Arya'); 
+ console.log(myStarkFamily);  // ['John', 'Robb', 'Sansa', 'Bran', 'Arya'] 
+ 
+ var newLength = myStarkFamily.push('Rickon');  // oops! forgot Rickon 
+ console.log(newLength);  // 6 
+ console.log(myStarkFamily);  // ['John', 'Robb', 'Sansa', 'Bran', 'Arya', 'Rickon'] 
+```
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)

guide/russian/javascript/standard-objects/array/array-prototype-reduce/index.md

@@ -0,0 +1,67 @@
+---
+title: Array.prototype.reduce
+localeTitle: Array.prototype.reduce
+---
+## Array.prototype.reduce
+
+Метод `reduce()` уменьшает массив значений до одного значения.
+
+Единственное возвращаемое значение может быть любого типа.
+
+### Пример 1
+
+Преобразуйте массив целых чисел в сумму всех целых чисел в массиве.
+
+```js
+    var numbers = [1,2,3]; 
+    var sum = numbers.reduce(function(total, current){ 
+        return total + current; 
+    }); 
+    console.log(sum); 
+```
+
+Это выведет `6` на консоль.
+
+### Описание
+
+Метод `reduce()` был назван швейцарским армейским ножом или мультиинструментом методов преобразования массива. Другие, такие как `map()` и `filter()` , обеспечивают более конкретные преобразования, тогда как `reduce()` может использоваться для преобразования массивов в любой желаемый результат.
+
+### Синтаксис
+
+```js
+    arr.reduce(callback[, initialValue]) 
+```
+
+*   Аргумент `callback` - это функция, которая будет вызываться один раз для каждого элемента массива. Эта функция принимает четыре аргумента, но часто используются только первые две.
+    *   _accumulator_ - возвращаемое значение предыдущей итерации
+    *   _currentValue_ - текущий элемент массива
+    *   _index_ - индекс текущего элемента
+    *   _array_ - исходный массив, на который был вызван сокращение
+*   Аргумент `initialValue` является обязательным. Если это предусмотрено, оно будет использоваться в качестве начального значения аккумулятора при первом вызове функции обратного вызова (см. Пример 2 ниже).
+
+### Пример 2.
+
+Преобразуйте массив строк в один объект, который показывает, сколько раз каждая строка появляется в массиве. Обратите внимание, что этот вызов уменьшает пропускает пустой объект `{}` как параметр `initialValue` . Это будет использоваться в качестве начального значения аккумулятора (первого аргумента), переданного функции обратного вызова.
+
+```js
+var pets = ['dog', 'chicken', 'cat', 'dog', 'chicken', 'chicken', 'rabbit']; 
+ 
+ var petCounts = pets.reduce(function(obj, pet){ 
+    if (!obj[pet]) { 
+        obj[pet] = 1; 
+    } else { 
+        obj[pet]++; 
+    } 
+    return obj; 
+ }, {}); 
+ 
+ console.log(petCounts); 
+```
+
+Вывод: `js { dog: 2, chicken: 3, cat: 1, rabbit: 1 }`
+
+## Дополнительная информация:
+
+*   [Как работает метод сокращения JavaScript, когда его использовать, и некоторые из интересных вещей, которые он может сделать](https://medium.freecodecamp.org/reduce-f47a7da511a9)
+*   [Расширенное сокращение](https://www.youtube.com/watch?v=1DMolJ2FrNY)
+*   [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)

guide/russian/javascript/standard-objects/array/array-prototype-reduceright/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.reduceRight
+localeTitle: Array.prototype.reduceRight
+---
+## Array.prototype.reduceRight
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-reduceright/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/javascript/standard-objects/array/array-prototype-reverse/index.md

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.reverse
+localeTitle: Array.prototype.reverse
+---
+Метод массива JavaScript `.reverse()` изменит порядок элементов в массиве.
+
+**Синтаксис**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  array.reverse(); 
+```
+
+## Описание
+
+`.reverse()` меняет индекс элементов массива.
+
+## Примеры
+
+**Используйте `.reverse()` чтобы отменить элементы массива**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  console.log(array); 
+  // Console will output 1, 2, 3, 4, 5 
+ 
+  array.reverse(); 
+ 
+  console.log(array); 
+  /* Console will output 5, 4, 3, 2, 1 and 
+  the variable array now contains the set [5, 4, 3, 2, 1] */ 
+```
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)

guide/russian/javascript/standard-objects/array/array-prototype-shift/index.md

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.shift
+localeTitle: Array.prototype.shift
+---
+Метод массива JavaScript `.shift()` удаляет первый элемент из массива и возвращает это значение. Это также изменит длину массива
+
+**Синтаксис**
+
+```javascript
+  var array = [1, 2, 3, 4]; 
+  array.shift(); 
+```
+
+## Описание
+
+`.shift()` удалит элемент по индексу 0 массива, на который он вызывается. Затем он возвращает удаленное значение и сдвигает все оставшиеся элементы на 1 значение индекса.
+
+`.shift()` возвратит `undefined` если массив, который он вызывается, не содержит элементов.
+
+## Примеры
+
+**Перенос первого значения из массива**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  console.log(array); 
+  // Console will output 1, 2, 3, 4, 5 
+ 
+  array.shift(); 
+  // If we console.log(array.shift()); the console would output 1. 
+ 
+  console.log(array); 
+  /* Console will output 2, 3, 4, 5 and 
+  the variable array now contains the set [2, 3, 4, 5] where 
+  each element has been moved down 1 index value. */ 
+```
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift)

guide/russian/javascript/standard-objects/array/array-prototype-slice/index.md

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.slice
+localeTitle: Array.prototype.slice
+---
+Метод массива JavaScript `.slice()` вернет новый объект массива, который будет сегментом (срезом) исходного массива. Исходный массив не изменяется.
+
+**Синтаксис**
+
+```javascript
+  array.slice() 
+  arr.slice(startIndex) 
+  arr.slice(startIndex, endIndex) 
+```
+
+## параметры
+
+*   **startIndex** Индекс, основанный на нулевом **значении,** где должен начинаться срез. Если значение опущено, оно начнется с 0.
+    
+*   **endIndex.** Этот срез закончится **до** этого индекса на основе нуля. Отрицательный индекс используется для смещения от конца массива. Если значение опущено, сегмент будет срезать до конца массива.
+    
+
+## Примеры
+
+```javascript
+  var array = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+ 
+  var everything = array.slice() 
+  // everything = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+ 
+  var kitchen = array.slice(2, 4) 
+  // kitchen = ['cup', 'sandwich'] 
+ 
+  var random = array.slice(4) 
+  // random = ['bag', 'phone', 'cactus'] 
+ 
+  var noPlants = array.slice(0, -1) 
+  // noPlats = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone'] 
+ 
+  // array will still equal ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+```
+
+#### Дополнительная информация:
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)

guide/russian/javascript/standard-objects/array/array-prototype-some/index.md

@@ -0,0 +1,92 @@
+---
+title: Array.prototype.some
+localeTitle: Array.prototype.some
+---
+Метод массива JavaScript `.some()` будет выполнять функцию обратного вызова для проверки каждого элемента в массиве; как только обратный вызов возвращает `true` то `.some()` немедленно вернет true.
+
+**Синтаксис**
+
+```javascript
+  var arr = [1, 2, 3, 4]; 
+  arr.some(callback[, thisArg]); 
+```
+
+## Функция обратного вызова
+
+**Синтаксис**
+
+```javascript
+  var isEven = function isEven(currentElement, index, array) { 
+      if(currentElement % 2 === 0) { 
+          return true; 
+      } else { 
+          return false; 
+      } 
+  } 
+```
+
+См. [Wiki](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators) в разделе « [Арифметические операторы»,](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators) чтобы увидеть оператор остатка `%`
+
+**Имеет 3 аргумента**
+
+*   currentElement
+    
+    *   это переменная, представляющая элемент, передаваемый обратному вызову.
+*   индекс
+    
+    *   это значение индекса текущего элемента, начинающегося с 0
+*   массив
+    
+    *   массив, к `.some()` был `.some()` .
+
+Функция обратного вызова должна реализовывать тестовый пример.
+
+## thisArg
+
+Дополнительный параметр и дополнительная информация можно найти в \[MDN
+
+## Описание
+
+`.some()` будет запускать функцию обратного вызова для каждого элемента массива. Как только обратный вызов вернет true, `.some()` вернет `true` . Если обратный вызов возвращает [значение фальши](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) для _каждого_ элемента в массиве, то `.some()` возвращает false.
+
+`.some()` не будет изменять / мутировать массив, который его вызвал.
+
+## Примеры
+
+**Передача функции в `.some()`**
+
+```javascript
+  var isEven = function isEven(currentElement, index, array) { 
+      if(currentElement % 2 === 0) { 
+          return true; 
+      } else { 
+          return false; 
+      } 
+  } 
+ 
+  var arr1 = [1, 2, 3, 4, 5, 6]; 
+  arr1.some(isEven);  // returns true 
+  var arr2 = [1, 3, 5, 7]; 
+  arr2.some(isEven);  // returns false 
+```
+
+**Анонимная функция**
+
+```javascript
+  var arr3 = ['Free', 'Code', 'Camp', 'The Amazing']; 
+  arr3.some(function(curr, index, arr) { 
+      if (curr === 'The Amazing') { 
+          return true; 
+      } 
+      }); // returns true 
+ 
+  var arr4 = [1, 2, 14, 5, 17, 9]; 
+  arr4.some(function(curr, index, arr) { 
+      return curr > 20; 
+      });  // returns false 
+ 
+  // ES6 arrows functions 
+  arr4.some((curr) => curr >= 14)  // returns true 
+```
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)

guide/russian/javascript/standard-objects/array/array-prototype-sort/index.md

@@ -0,0 +1,51 @@
+---
+title: Array.prototype.sort
+localeTitle: Array.prototype.sort
+---
+## Array.prototype.sort
+
+Этот метод сортирует элементы массива на месте и возвращает массив.
+
+Метод `sort()` следует **порядку ASCII** !
+
+Индекс | характер --- | --- 33 |! 34 |» 35 | # 36 | $ 37 |%
+
+```js
+var myArray = ['#', '!']; 
+ var sortedArray = myArray.sort();   // ['!', '#'] because in the ASCII table "!" is before "#" 
+ 
+ myArray = ['a', 'c', 'b']; 
+ console.log(myArray.sort()); // ['a', 'b', 'c'] 
+ console.log(myArray) // ['a', 'b', 'c'] 
+ 
+ myArray = ['b', 'a', 'aa']; 
+ console.log(myArray.sort());   // ['a', 'aa', 'b'] 
+ 
+ myArray = [1, 2, 13, 23]; 
+ console.log(myArray.sort());   // [1, 13, 2, 23] numbers are treated like strings! 
+```
+
+# Расширенное использование
+
+Метод `sort()` также может принимать параметр: `array.sort(compareFunction)`
+
+### Например
+
+```js
+function compare(a, b){ 
+  if (a < b){return -1;} 
+  if (a > b){return 1;} 
+  if (a === b){return 0;} 
+ } 
+ 
+ var myArray = [1, 2, 23, 13]; 
+ console.log(myArray.sort()); // [ 1, 13, 2, 23 ] 
+ console.log(myArray.sort(compare));   // [ 1, 2, 13, 23 ] 
+ 
+ myArray = [3, 4, 1, 2]; 
+ sortedArray = myArray.sort(function(a, b){.....});   // it depends from the compareFunction 
+```
+
+#### Дополнительная информация:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

guide/russian/javascript/standard-objects/array/array-prototype-splice/index.md

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.splice
+localeTitle: Array.prototype.splice
+---
+## Array.prototype.splice
+
+Метод splice похож на [Array.prototype.slice](https://guide.freecodecamp.org/javascript/standard-objects/array/array-prototype-slice) , но в отличие от `slice()` он мутирует массив, на который он вызывается. Он также отличается тем, что его можно использовать для добавления значений в массив, а также для их удаления.
+
+### параметры
+
+`splice()` может принимать один или несколько
+
+#### сращивать (начало)
+
+Если включен только один параметр, то `splice(start)` удалит все элементы массива от `start` до конца массива.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(2); 
+ // exampleArray is now ['first', 'second']; 
+```
+
+Если `start` отрицательно, оно будет отсчитываться назад от конца массива.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(-1); 
+ // exampleArray is now ['first', 'second', 'third']; 
+```
+
+#### сращивание (start, deleteCount)
+
+Если включен второй параметр, то `splice(start, deleteCount)` удалит элементы `deleteCount` из массива, начиная с `start` .
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth']; 
+```
+
+#### splice (start, deleteCount, newElement1, newElement2, ....)
+
+Если включено более двух параметров, дополнительными параметрами будут новые элементы, которые добавляются в массив. Расположение этих добавленных элементов начнется с `start` .
+
+Элементы могут быть добавлены без удаления каких-либо элементов, передав `0` в качестве второго параметра.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 0, 'new 1', 'new 2'); 
+ // exampleArray is now ['first', 'new 1', 'new 2', 'second', 'third', 'fourth'] 
+```
+
+Элементы также могут быть заменены.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 2, 'new second', 'new third'); 
+ // exampleArray is now ['first', 'new second', 'new third', 'fourth'] 
+```
+
+### Возвращаемое значение
+
+В дополнение к изменению массива, на который он вызывается, `splice()` также возвращает массив, содержащий удаленные значения. Это способ разрезать массив на два разных массива.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ let newArray = exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth'] 
+ // newArray is ['second', 'third'] 
+```
+
+#### Дополнительная информация:
+
+[MDN - Array.prototype.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)

guide/russian/javascript/standard-objects/array/array-prototype-tolocalstring/index.md

@@ -0,0 +1,49 @@
+---
+title: Array.prototype.toLocaleString
+localeTitle: Array.prototype.toLocaleString
+---
+## Array.prototype.toLocaleString
+
+Метод `toLocaleString()` возвращает строку, представляющую элементы массива. Все элементы преобразуются в строки с использованием методов toLocaleString. Результат вызова этой функции предназначен для конкретной локали.
+
+##### Синтаксис:
+```
+arr.toLocaleString(); 
+```
+
+##### параметры
+
+*   `locales` (Необязательно) - аргумент, содержащий либо строку, либо массив языковых тегов [BCP 47](http://tools.ietf.org/html/rfc5646) .
+*   `options` (Необязательно) - объект с параметрами конфигурации
+
+##### Возвращаемое значение
+
+Строка, представляющая элементы массива, разделенные строкой, специфичной для локали (например, запятая ",")
+
+## Примеры
+
+```javascript
+var number = 12345; 
+ var date = new Date(); 
+ var myArray = [number, date, 'foo']; 
+ var myString = myArray.toLocaleString(); 
+ 
+ console.log(myString); 
+ // OUTPUT '12345,10/25/2017, 4:20:02 PM,foo' 
+```
+
+Различные выходы могут отображаться на основе идентификатора языка и региона (локали).
+
+```javascript
+var number = 54321; 
+ var date = new Date(); 
+ var myArray = [number, date, 'foo']; 
+ var myJPString = myArray.toLocaleString('ja-JP'); 
+ 
+ console.log(myJPString); 
+ // OUTPUT '54321,10/26/2017, 5:20:02 PM,foo' 
+```
+
+### Дополнительная информация:
+
+Источник: [MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString)

guide/russian/javascript/standard-objects/array/array-prototype-tosource/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.toSource
+localeTitle: Array.prototype.toSource
+---
+## Array.prototype.toSource
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-tosource/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/javascript/standard-objects/array/array-prototype-tostring/index.md

@@ -0,0 +1,25 @@
+---
+title: Array.prototype.toString
+localeTitle: Array.prototype.toString
+---
+Метод массива JavaScript `.toString()` используется для преобразования массива в одну строку, причем каждый элемент соединен запятой. Для этого метода нет параметров.
+
+**Синтаксис**
+
+```javascript
+  var arr = [1, 2, 3, 4]; 
+  arr.toString(); 
+```
+
+## использование
+
+```javascript
+  var str1 = [1, 2, 3, 4, 5].toString();  // str1 = '1,2,3,4,5'; 
+  var str2 = ['1', '2', '3', '4'].toString();  // str2 = '1,2,3,4'; 
+  var str3 = ['Free', 'Code', 'Camp'].toString();  // str3 = 'Free,Code,Camp'; 
+  var str4 = ['phone', '555-6726'].toString();   // str4 = 'phone,555-6726'; 
+  var str5 = ['August', 'September', 'October'].toString();  // str5 = 'August,September,October'; 
+  var str6 = ['Words', 'and', 3, 4].toString();  // str6 = 'Words,and,3,4'; 
+```
+
+Источник: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString)

guide/russian/javascript/standard-objects/array/array-prototype-unshift/index.md

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.unshift
+localeTitle: Array.prototype.unshift
+---
+Метод массива JavaScript `.unshift()` добавляет один или несколько элементов в начало массива и возвращает новую длину массива.
+
+**Синтаксис**
+```
+arr.unshift([element1[, ...[, elementN]]]) 
+```
+
+## параметры
+
+Элементы для добавления к фронту массива.
+
+## Возвращает
+
+Новая `length` массива, на который был вызван метод.
+
+## Примеры
+```
+var array = [1, 2, 3, 4, 5]; 
+ 
+ array.unshift(0); 
+ // If we console.log(array.shift()); the console would output 6. 
+ // array is now [0, 1, 2, 3, 4, 5]; 
+ 
+ array.unshift([-1]); 
+ // array is now [[-1], 0, 1, 2, 3, 4, 5]; 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/C2V3)
+
+Источник [MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)

guide/russian/javascript/standard-objects/array/array-prototype-values/index.md

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.values
+localeTitle: Array.prototype.values
+---
+## Array.prototype.values
+
+Метод `values` возвращает новый объект `Array Iterator` который содержит значения для каждого индекса в массиве.
+
+### Синтаксис
+
+```javascript
+arr.values() 
+```
+
+### Возвращает
+
+Новый объект ittertator `array` .
+
+### пример
+
+```javascript
+let friends = ["Rachel", "Monica", "Chandler", "Phoebe", "Joey", "Ross"] 
+ 
+ for (let friend of friends) { 
+  console.log(friend) 
+ } 
+ 
+ // Rachel 
+ // Monica 
+ // Chandler 
+ // Phoebe 
+ // Joey 
+ // Ross 
+```
+
+#### Дополнительная информация:
+
+[Документация MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)

guide/russian/javascript/standard-objects/array/index.md

@@ -0,0 +1,11 @@
+---
+title: Array
+localeTitle: массив
+---
+## массив
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация: