fix(guide): simplify directory structure

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

@@ -0,0 +1,23 @@
+---
+title: JSON
+localeTitle: JSON
+---
+Обозначение объекта JavaScript или `JSON` использует формат JavaScript-объектов для хранения данных. JSON является гибким, поскольку он позволяет создавать `Data Structures` с произвольными комбинациями `strings` , `numbers` , `booleans` , `arrays` и `objects` .
+
+Вот пример объекта JSON:
+```
+var ourMusic = [ 
+  { 
+    "artist": "Daft Punk", 
+    "title": "Homework", 
+    "release_year": 1997, 
+    "formats": [ 
+      "CD", 
+      "Cassette", 
+      "LP" ], 
+    "gold": true 
+  } 
+ ]; 
+```
+
+Это массив объектов, и объект имеет разные фрагменты `metadata` об альбоме. Он также имеет вложенный массив `formats` . Дополнительные альбомы могут быть добавлены в массив верхнего уровня.

guide/russian/javascript/standard-objects/json/json-arrays/index.md

@@ -0,0 +1,30 @@
+---
+title: JSON Arrays
+localeTitle: Массивы JSON
+---
+## Массивы JSON
+
+Массивы JSON не отличаются от обычных объектов массива, которые вы используете в Javascript. Его объект массива, который содержит несколько `JSON Objects` .
+
+Вот пример массива JSON:
+
+```Javascript
+    var aMyPlaylist = [{ 
+        artist: "Ed Sheeran", 
+        track: "Supermarket flowers", 
+        myRating: 10 
+    }, { 
+        artist: "Tracy Chapman", 
+        track: "Fastcar", 
+        myRating: 9 
+    }]; 
+```
+
+Это массив JSON, названный как `aMyPlaylist` . Все методы массива, такие как `map` , `filter` , `sort` и т. Д., Могут применяться и на любом массиве JSON
+
+#### Дополнительная информация:
+
+Дополнительные методы массива можно найти в следующих ссылках
+
+*   [Массив - Freecodecamp](https://guide.freecodecamp.org/javascript/standard-objects/array)
+*   [Array - Сеть разработчиков Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)

guide/russian/javascript/standard-objects/json/json-parse/index.md

@@ -0,0 +1,58 @@
+---
+title: JSON Parse
+localeTitle: JSON Parse
+---
+## JSON Parse
+
+Метод `JSON.parse()` анализирует строку и создает новый объект, описываемый строкой.
+
+#### Синтаксис:
+
+```javascript
+    JSON.parse(text [, reviver]) 
+```
+
+##### Параметры:
+
+`text` Строка для синтаксического анализа как JSON
+
+`reviver` (необязательно) Функция получит `key` и `value` качестве аргументов. Эта функция может использоваться для преобразования значения результата.
+
+Ниже приведен пример использования `JSON.parse()` :
+
+```javascript
+var data = '{"foo": "bar"}'; 
+ 
+ console.log(data.foo); // This will print `undefined` since `data` is of type string and has no property named as `foo` 
+ 
+ // You can use JSON.parse to create a new JSON object from the given string 
+ var convertedData = JSON.parse(data); 
+ 
+ console.log(convertedData.foo); // This will print `bar 
+```
+
+[Демо-версия Repl.it](https://repl.it/MwgK/0)
+
+Вот пример с `reviver` :
+
+```javascript
+var data = '{"value": 5}'; 
+ 
+ var result = JSON.parse(data, function(key, value) { 
+    if (typeof value === 'number') { 
+        return value * 10; 
+    } 
+    return value; 
+ }); 
+ 
+ // Original Data 
+ console.log("Original Data:", data); // This will print Original Data: {"value": 5} 
+ // Result after parsing 
+ console.log("Parsed Result: ", result); // This will print Parsed Result:  { value: 50 } 
+```
+
+В приведенном выше примере все числовые значения [умножаются](https://repl.it/Mwfp/0) на `10` - [Repl.it Demo](https://repl.it/Mwfp/0)
+
+#### Дополнительная информация:
+
+[JSON.parse - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse)

guide/russian/javascript/standard-objects/json/json-stringify/index.md

@@ -0,0 +1,201 @@
+---
+title: JSON Stringify
+localeTitle: JSON Stringify
+---
+## JSON Stringify
+
+Метод `JSON.stringify()` преобразует _JSON-безопасное_ значение JavaScript в строку, совместимую с JSON.
+
+Что такое JSON-безопасные значения? Давайте составим список всех JSON-небезопасных значений, а все, что отсутствует в списке, можно считать безопасным для JSON.
+
+#### JSON-небезопасные значения:
+
+*   `undefined`
+*   `function(){}`
+*   (ES6 +) `Symbol`
+*   Объект с круговой ссылкой (-ами) в нем
+
+#### Синтаксис
+
+```javascript
+  JSON.stringify( value [, replacer [, space]]) 
+```
+
+В своей простейшей и наиболее часто используемой форме:
+
+```javascript
+  JSON.stringify( value ) 
+```
+
+#### параметры
+
+`value` : `value` JavaScript, которое должно быть «stringified».
+
+`replacer` : (Необязательно) Функция или массив, который служит фильтром для свойств объекта значения, который должен быть включен в строку JSON.
+
+`space` : (Необязательно) Числовое или строковое значение для предоставления отступов для строки JSON. Если числовое значение предоставлено, то многие пробелы (до 10) действуют как indentaion на каждом уровне. Если задано строковое значение, эта строка (до первых 10 символов) действует как отступ на каждом уровне.
+
+#### Тип возврата
+
+Тип возвращаемого метода: `string` .
+
+## Описание
+
+Значения JSON-safe преобразуются в соответствующую строковую строку JSON. С другой стороны, JSON-небезопасные значения возвращают:
+
+*   `undefined` если они переданы как значения для метода
+*   `null` если они переданы как элемент массива
+*   ничего, если передать свойства объекта
+*   выдает ошибку, если ее объект с круговыми ссылками (ссылками) на нем.
+
+```javascript
+  //JSON-safe values 
+  JSON.stringify({});                  // '{}' 
+  JSON.stringify(true);                // 'true' 
+  JSON.stringify('foo');               // '"foo"' 
+  JSON.stringify([1, 'false', false]); // '[1,"false",false]' 
+  JSON.stringify({ x: 5 });            // '{"x":5}' 
+  JSON.stringify(new Date(2006, 0, 2, 15, 4, 5))  // '"2006-01-02T15:04:05.000Z"' 
+ 
+  //JSON-unsafe values passed as values to the method 
+  JSON.stringify( undefined );                    // undefined 
+  JSON.stringify( function(){} );                    // undefined 
+ 
+  //JSON-unsafe values passed as array elements 
+  JSON.stringify({ x: [10, undefined, function(){}, Symbol('')] });  // '{"x":[10,null,null,null]}' 
+ 
+ //JSON-unsafe values passed as properties on a object 
+  JSON.stringify({ x: undefined, y: Object, z: Symbol('') });  // '{}' 
+ 
+  //JSON-unsafe object with circular reference on it 
+  var o = { }, 
+    a = { 
+      b: 42, 
+      c: o, 
+      d: function(){} 
+    }; 
+ 
+  // create a circular reference inside `a` 
+  oe = a; 
+ 
+  // would throw an error on the circular reference 
+  // JSON.stringify( a ); 
+```
+
+`JSON.stringify(...)` ведет себя по-другому, если объект, переданный ему, имеет метод `toJSON()` определенный на нем. Возвращаемое значение из `toJSON()` будет сериализоваться вместо самого объекта.
+
+Это очень удобно, когда объект содержит какое-либо незаконное значение JSON.
+
+```javascript
+   //JSON-unsafe values passed as properties on a object 
+   var obj = { x: undefined, y: Object, z: Symbol('') }; 
+ 
+   //JSON.stringify(obj);  logs '{}' 
+   obj.toJSON = function(){ 
+    return { 
+      x:"undefined", 
+      y: "Function", 
+      z:"Symbol" 
+    } 
+   } 
+   JSON.stringify(obj);  //"{"x":"undefined","y":"Function","z":"Symbol"}" 
+ 
+  //JSON-unsafe object with circular reference on it 
+  var o = { }, 
+    a = { 
+      b: 42, 
+      c: o, 
+      d: function(){} 
+    }; 
+ 
+  // create a circular reference inside `a` 
+  oe = a; 
+ 
+  // would throw an error on the circular reference 
+  // JSON.stringify( a ); 
+ 
+  // define a custom JSON value serialization 
+  a.toJSON = function() { 
+    // only include the `b` property for serialization 
+    return { b: this.b }; 
+  }; 
+ 
+  JSON.stringify( a ); // "{"b":42}" 
+```
+
+#### `replacer`
+
+`replacer` , как упоминалось ранее, является фильтром, который указывает, какие свойства должны быть включены в строку JSON. Это может быть либо массив, либо функция. Когда массив, replacer содержит строковые представления только тех свойств, которые должны быть включены в строку JSON.
+
+```javascript
+  var foo = {foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7}; 
+  JSON.stringify(foo, ['week', 'month']);    // '{"week":45,"month":7}', only keep "week" and "month" properties 
+```
+
+Если `replacer` является функцией, он будет вызываться один раз для самого объекта, а затем один раз для каждого свойства в объекте и каждый раз передается два аргумента, _ключ_ и _значение_ . Чтобы пропустить _ключ_ в сериализации, `undefined` должен быть возвращен. В противном случае возвращаемое _значение_ должно быть возвращено. Если любое из этих _значений_ является самими объектами, функция `replacer` сериализует их рекурсивно.
+
+```javascript
+  function replacer(key, value) { 
+    // Filtering out properties 
+    if (typeof value === 'string') { 
+      return undefined; 
+    } 
+    return value; 
+  } 
+ 
+  var foo = {foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7}; 
+  JSON.stringify(foo, replacer);  // '{"week":45,"month":7}' 
+```
+
+Если массив передается в `JSON.stringify()` а `replacer` возвращает `undefined` для любого из его элементов, значение элемента заменяется на `null` . Функции- `replacer` не могут удалить значения из массива.
+
+```javascript
+  function replacer(key, value) { 
+    // Filtering out properties 
+    if (typeof value === 'string') { 
+      return undefined; 
+    } 
+    return value; 
+  } 
+ 
+  var foo = ['Mozilla', 'box', 45, 'car', 7]; 
+  JSON.stringify(foo, replacer);  // "[null,null,45,null,7]" 
+```
+
+#### `space`
+
+Параметр `space` используемый для отступа, делает результат `JSON.stringify()` более `JSON.stringify()` .
+
+```javascript
+  var a = { 
+    b: 42, 
+    c: "42", 
+    d: [1,2,3] 
+  }; 
+ 
+  JSON.stringify( a, null, 3 ); 
+  // "{ 
+  //    "b": 42, 
+  //    "c": "42", 
+  //    "d": [ 
+  //       1, 
+  //       2, 
+  //       3 
+  //    ] 
+  // }" 
+ 
+  JSON.stringify( a, null, "-----" ); 
+  // "{ 
+  // -----"b": 42, 
+  // -----"c": "42", 
+  // -----"d": [ 
+  // ----------1, 
+  // ----------2, 
+  // ----------3 
+  // -----] 
+  // }" 
+```
+
+#### Дополнительная информация:
+
+Обратитесь к [документам MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) .

guide/russian/javascript/standard-objects/json/json-syntax/index.md

@@ -0,0 +1,112 @@
+---
+title: JSON Syntax
+localeTitle: Синтаксис JSON
+---
+## Синтаксис JSON
+
+Синтаксис JSON является подмножеством синтаксиса JavaScript.
+
+### Правила синтаксиса JSON
+
+*   JSON Object - неупорядоченный набор пар имя / значение.
+*   За именами объектов следует двоеточие (:).
+*   Кулистые фигурные скобки {} используются для хранения объектов. Объект начинается с {(левая фигурная скобка) и заканчивается на} (правая фигурная скобка).
+*   Данные объекта JSON представлены в виде набора пар имя / значение.
+*   Каждая пара имен / значений разделяется запятой (,)
+*   Квадратные фигурные скобки \[\] используются для хранения массивов.
+
+### Данные JSON - имя и стоимость
+
+Данные JSON записываются как пары имя / значение.
+
+Пара имя / значение состоит из имени поля (в двойных кавычках), за которым следует двоеточие, за которым следует значение:
+```
+"handle":"moghya" 
+```
+
+*   Для имен JSON требуются двойные кавычки.
+
+### JSON - оценивает объекты JavaScript
+
+Формат JSON почти идентичен JavaScript-объектам.
+
+В JSON ключи должны быть строками, написанными двойными кавычками:
+
+*   JSON
+```
+"handle":"moghya" 
+```
+
+*   JavaScript
+```
+handle:"moghya" 
+```
+
+### Значения JSON
+
+В JSON значения должны быть одного из следующих типов данных:
+
+*   строка
+*   число
+*   объект (объект JSON)
+*   массив
+*   логическое
+*   ноль
+
+В значениях JavaScript могут быть все перечисленные выше, а также любое другое действительное выражение JavaScript, в том числе:
+
+*   функция
+*   свидание
+*   не определено
+
+### JSON использует синтаксис JavaScript
+
+Поскольку синтаксис JSON получен из нотации объекта JavaScript, для работы с JSON в JavaScript требуется очень мало дополнительного программного обеспечения.
+
+С помощью JavaScript вы можете создать объект и присвоить ему данные, например:
+```
+var person = { 
+  "name":"Shubham", 
+  "age":21, 
+  "handle":"moghya", 
+  "website":"http://moghya.me/" 
+  }; 
+```
+
+Вы можете получить доступ к объекту JavaScript следующим образом:
+```
+//returns moghya 
+ person.handle; 
+```
+
+Он также может быть доступен следующим образом:
+```
+//returns http://moghya.me/ 
+ person["website"]; 
+```
+
+### Массивы в JSON
+```
+var team = { 
+  "name":"novatoscript", 
+  "members" : 
+  [ 
+    { 
+      "name":"Shubham Sawant", 
+      "age":21, 
+      "handle":"moghya", 
+      "website":"http://moghya.me", 
+    }, 
+    { 
+      "name":"Saurabh Banore", 
+      "age":21, 
+      "handle":"banoresaurabh", 
+      "website":"http://banoresaurabh.me/", 
+    } 
+  ] 
+ } 
+```
+
+### пример
+
+Очень большой пример JSON [здесь!](http://moghya.me/js/profile.json) ,