@rogolev/value 0.0.1 → 0.0.2

package/docs/types/NaN.md

@@ -1,30 +1,30 @@
-[Главная](../../README.md) / [Типы данных](../types.md) / Не число
-
-# Не число
-
-## Не число в JavaScript
-
-Глобальное свойство **NaN** является значением, представляющим не-число (Not-A-Number).
-
-Значение `NaN` имеет тип `number`.
-
-```js
-typeof NaN; // "number"
-```
-
-[Подробнее...](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN)
-
-## Не число в value.js
-
-Библиотека не вносит ни каких изменений в определение не числа, а лишь выделяет значение `NaN` в
-отдельный тип `NaN`.
-
-### Проверка типа
-
-Проверить, является ли значение не числом, можно с помощью функции [is_nan](../helpers/is_nan.md).
-
-```js
-is_nan(NaN); // true
-
-gettype(NaN); // "NaN"
-```
+[Главная](../../README.md) / [Типы данных](../types.md) / Не число
+
+# Не число
+
+## Не число в JavaScript
+
+Глобальное свойство **NaN** является значением, представляющим не-число (Not-A-Number).
+
+Значение `NaN` имеет тип `number`.
+
+```js
+typeof NaN; // "number"
+```
+
+[Подробнее...](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN)
+
+## Не число в value.js
+
+Библиотека не вносит ни каких изменений в определение не числа, а лишь выделяет значение `NaN` в
+отдельный тип `NaN`.
+
+### Проверка типа
+
+Проверить, является ли значение не числом, можно с помощью функции [is_nan](../helpers/is_nan.md).
+
+```js
+is_nan(NaN); // true
+
+gettype(NaN); // "NaN"
+```

package/docs/types/array.md

@@ -1,252 +1,252 @@
-[Главная](../../README.md) / [Типы данных](../types.md) / Массивы
-
----
-
-# Массивы
-
-## Массивы в JavaScript
-
-**Массив в JavaScript** — объект типа `Array`, позволяющий хранить набор из нескольких
-элементов под одним именем переменной.
-[Подробнее.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-
-Для массива `Array` оператор
-[typeof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/typeof) возвращает
-`"object"`.
-
-```js
-const array = [1, 2, 3];
-Array.isArray(array); // true
-typeof array; // "object"
-```
-
-Данные массивы являются списками, а значит имеют индексные ключи (`0, 1, 2, ...`). Если вам нужен
-ассоциативный массив (массив пар ключ-значение, где ключи являются строками), то можно использовать
-объекты (`Object`).
-
-```js
-const array = {
-    key1: 'value1',
-    key2: 'value2',
-    key3: 'value3',
-};
-Array.isArray(array); // false
-typeof array; // "object"
-```
-
-Как видно из примера, оператор
-[typeof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/typeof) для
-ассоциативного массива также возвращает `"object"`. Это правильно с точки зрения **JavaScript**, но
-нам бы хотелось, как-то различать массивы и объекты. Да, списки мы можем отличить от объекта с
-помощью метода `Array.isArray` или с помощью оператора `instanceof`, а как отличить ассоциативный
-массив от экземпляра класса **ES6**?
-
-### Задача
-
-Отличить ассоциативный массив от экземпляра класса.
-
-#### Решение 1
-
-Можно использовать встроенную коллекцию
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
-добавленную в **ES6**.
-
-```js
-const map = new Map();
-map.set('key1', 'value1');
-map.set('key2', 'value2');
-map.set('key3', 'value3');
-console.log(map); // Map(3) {key1: "value1", key2: "value2", key...}
-```
-
-Передавать ключи и значения в метод `set` не всегда удобно. Можно передавать список ключей и
-значений в конструктор.
-
-```js
-const data = {
-    key1: 'value1',
-    key2: 'value2',
-    key3: 'value3',
-};
-const entries = Object.entries(data);
-const map = new Map(entries);
-console.log(map); // Map(3) {key1: "value1", key2: "value2", key...}
-```
-
-Передать объект `data` напрямую без преобразования в `entries` не получится.
-
-```js
-const data = {
-    key1: 'value1',
-    key2: 'value2',
-    key3: 'value3',
-};
-const map = new Map(data); // TypeError: object is not iterable (cannot read property Symbol(Symbol.iterator))
-```
-
-Отличить экземпляр
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) от
-экземпляра класса мы можем с помощью оператора `instanceof`.
-
-```js
-const map = new Map();
-map instanceof Map; // true
-```
-
-#### Решение 2
-
-Отличить ассоциативный массив от экземпляра класса можно проверкой его прототипа.
-
-```js
-const array = {
-    key1: 'value1',
-    key2: 'value2',
-    key3: 'value3',
-};
-Object.getPrototypeOf(array) === Object.prototype; // true
-
-const list = [1, 2, 3];
-Object.getPrototypeOf(list) === Object.prototype; // false
-
-const map = new Map();
-Object.getPrototypeOf(map) === Object.prototype; // false
-```
-
-Если прототипом является `Object.prototype`, значит это ассоциативный массив, иначе это экземпляр
-класса.
-
-#### Итог
-
-Подведем итог из приведенных выше решений:
-
-В качестве ассоциативных массивов в первом решении мы использовали экземпляры встроенной коллекции
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), а во
-втором решении обычные объекты типа `Object`. У обоих подходов есть свои плюсы и минусы. Сравнение
-обоих подходов приведено в
-[этой таблице](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#objects_vs._maps).
-
-Какой подход лучше? Все зависит от контекста. В одном конкретном случае будет предпочтительно
-использовать коллекцию
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), в
-другом — объект типа `Object`, да и на вкус и цвет, как говорится.
-
-## Массивы в value.js
-
-Итак, когда мы разобрались с массивами в `JavaScript`, введем понятие массива в **value.js**.
-
-**Массив в value.js** — это и объект типа `Object` (ассоциативный массив), прототипом которого
-является `Object.prototype`, и объект типа `Array`, позволяющие хранить набор из нескольких
-элементов под одним именем переменной.
-
-```js
-const list = [1, 2, 3];
-const assoc = {
-    key1: 'value1',
-    key2: 'value2',
-    key3: 'value3',
-};
-
-is_array(list); // true
-is_array(assoc); // true
-
-gettype(list); // "array"
-gettype(assoc); // "array"
-```
-
-Как видно из примера функция [is_array](../helpers/is_array.md) рассматривает оба массива как
-равноценные по типу. Также для обоих массивов функция `gettype` возвращает одинаковые значения.
-
-При этом коллекция
-[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), как и
-другие коллекции, считается экземпляром класса.
-
-```js
-const map = new Map();
-const set = new Set();
-
-is_array(map); // false
-is_array(set); // false
-
-gettype(map); // "object"
-gettype(set); // "object"
-```
-
-### Проверка типа
-
-Проверить, что переменная является массивом, можно с помощью функции
-[is_array](../helpers/is_array.md).
-
-```js
-const array = { foo: 'bar' };
-
-is_array(array); // true
-```
-
-### Привидение к типу
-
-Привести к массиву можно с помощью функции `to_array`.
-
-```js
-to_array(123); // [123]
-```
-
-### Примеры использования массивов в value.js
-
-#### Создание и использование списков
-
-```js
-const list = [1, 2, 3, 4, 5];
-console.log(list); // [1, 2, 3, 4, 5]
-console.log(list.length); // 5
-console.log(list[0]); // 1
-console.log(list[list.length - 1]); // 5
-```
-
-#### Создание и использование ассоциативных массивов
-
-```js
-const assoc = {
-    name: 'John',
-    age: 30,
-    city: 'New York',
-};
-console.log(assoc); // { name: 'John', age: 30, city: 'New York' }
-console.log(assoc.name); // John
-console.log(assoc['age']); // 30
-```
-
-#### Преобразование массивов в коллекции и обратно
-
-```js
-const array = { a: 1, b: 2, c: 3 };
-const entries = Object.entries(array);
-const map = new Map(entries);
-console.log(map); // Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }
-
-const newArray = Object.fromEntries(map);
-console.log(newArray); // { a: 1, b: 2, c: 3 }
-```
-
-#### Проверка типа массива
-
-```js
-const list = [1, 2, 3];
-const assoc = { key1: 'value1', key2: 'value2', key3: 'value3' };
-
-console.log(is_array(list)); // true
-console.log(is_array(assoc)); // true
-console.log(is_array(new Map())); // false
-console.log(is_array(new Set())); // false
-```
-
-#### Получение типа переменной
-
-```js
-const list = [1, 2, 3];
-const assoc = { key1: 'value1', key2: 'value2', key3: 'value3' };
-
-console.log(gettype(list)); // "array"
-console.log(gettype(assoc)); // "array"
-console.log(gettype(new Map())); // "object"
-console.log(gettype(new Set())); // "object"
-```
+[Главная](../../README.md) / [Типы данных](../types.md) / Массивы
+
+---
+
+# Массивы
+
+## Массивы в JavaScript
+
+**Массив в JavaScript** — объект типа `Array`, позволяющий хранить набор из нескольких
+элементов под одним именем переменной.
+[Подробнее.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+
+Для массива `Array` оператор
+[typeof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/typeof) возвращает
+`"object"`.
+
+```js
+const array = [1, 2, 3];
+Array.isArray(array); // true
+typeof array; // "object"
+```
+
+Данные массивы являются списками, а значит имеют индексные ключи (`0, 1, 2, ...`). Если вам нужен
+ассоциативный массив (массив пар ключ-значение, где ключи являются строками), то можно использовать
+объекты (`Object`).
+
+```js
+const array = {
+    key1: 'value1',
+    key2: 'value2',
+    key3: 'value3',
+};
+Array.isArray(array); // false
+typeof array; // "object"
+```
+
+Как видно из примера, оператор
+[typeof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/typeof) для
+ассоциативного массива также возвращает `"object"`. Это правильно с точки зрения **JavaScript**, но
+нам бы хотелось, как-то различать массивы и объекты. Да, списки мы можем отличить от объекта с
+помощью метода `Array.isArray` или с помощью оператора `instanceof`, а как отличить ассоциативный
+массив от экземпляра класса **ES6**?
+
+### Задача
+
+Отличить ассоциативный массив от экземпляра класса.
+
+#### Решение 1
+
+Можно использовать встроенную коллекцию
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
+добавленную в **ES6**.
+
+```js
+const map = new Map();
+map.set('key1', 'value1');
+map.set('key2', 'value2');
+map.set('key3', 'value3');
+console.log(map); // Map(3) {key1: "value1", key2: "value2", key...}
+```
+
+Передавать ключи и значения в метод `set` не всегда удобно. Можно передавать список ключей и
+значений в конструктор.
+
+```js
+const data = {
+    key1: 'value1',
+    key2: 'value2',
+    key3: 'value3',
+};
+const entries = Object.entries(data);
+const map = new Map(entries);
+console.log(map); // Map(3) {key1: "value1", key2: "value2", key...}
+```
+
+Передать объект `data` напрямую без преобразования в `entries` не получится.
+
+```js
+const data = {
+    key1: 'value1',
+    key2: 'value2',
+    key3: 'value3',
+};
+const map = new Map(data); // TypeError: object is not iterable (cannot read property Symbol(Symbol.iterator))
+```
+
+Отличить экземпляр
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) от
+экземпляра класса мы можем с помощью оператора `instanceof`.
+
+```js
+const map = new Map();
+map instanceof Map; // true
+```
+
+#### Решение 2
+
+Отличить ассоциативный массив от экземпляра класса можно проверкой его прототипа.
+
+```js
+const array = {
+    key1: 'value1',
+    key2: 'value2',
+    key3: 'value3',
+};
+Object.getPrototypeOf(array) === Object.prototype; // true
+
+const list = [1, 2, 3];
+Object.getPrototypeOf(list) === Object.prototype; // false
+
+const map = new Map();
+Object.getPrototypeOf(map) === Object.prototype; // false
+```
+
+Если прототипом является `Object.prototype`, значит это ассоциативный массив, иначе это экземпляр
+класса.
+
+#### Итог
+
+Подведем итог из приведенных выше решений:
+
+В качестве ассоциативных массивов в первом решении мы использовали экземпляры встроенной коллекции
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), а во
+втором решении обычные объекты типа `Object`. У обоих подходов есть свои плюсы и минусы. Сравнение
+обоих подходов приведено в
+[этой таблице](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#objects_vs._maps).
+
+Какой подход лучше? Все зависит от контекста. В одном конкретном случае будет предпочтительно
+использовать коллекцию
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), в
+другом — объект типа `Object`, да и на вкус и цвет, как говорится.
+
+## Массивы в value.js
+
+Итак, когда мы разобрались с массивами в `JavaScript`, введем понятие массива в **value.js**.
+
+**Массив в value.js** — это и объект типа `Object` (ассоциативный массив), прототипом которого
+является `Object.prototype`, и объект типа `Array`, позволяющие хранить набор из нескольких
+элементов под одним именем переменной.
+
+```js
+const list = [1, 2, 3];
+const assoc = {
+    key1: 'value1',
+    key2: 'value2',
+    key3: 'value3',
+};
+
+is_array(list); // true
+is_array(assoc); // true
+
+gettype(list); // "array"
+gettype(assoc); // "array"
+```
+
+Как видно из примера функция [is_array](../helpers/is_array.md) рассматривает оба массива как
+равноценные по типу. Также для обоих массивов функция `gettype` возвращает одинаковые значения.
+
+При этом коллекция
+[Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), как и
+другие коллекции, считается экземпляром класса.
+
+```js
+const map = new Map();
+const set = new Set();
+
+is_array(map); // false
+is_array(set); // false
+
+gettype(map); // "object"
+gettype(set); // "object"
+```
+
+### Проверка типа
+
+Проверить, что переменная является массивом, можно с помощью функции
+[is_array](../helpers/is_array.md).
+
+```js
+const array = { foo: 'bar' };
+
+is_array(array); // true
+```
+
+### Привидение к типу
+
+Привести к массиву можно с помощью функции `to_array`.
+
+```js
+to_array(123); // [123]
+```
+
+### Примеры использования массивов в value.js
+
+#### Создание и использование списков
+
+```js
+const list = [1, 2, 3, 4, 5];
+console.log(list); // [1, 2, 3, 4, 5]
+console.log(list.length); // 5
+console.log(list[0]); // 1
+console.log(list[list.length - 1]); // 5
+```
+
+#### Создание и использование ассоциативных массивов
+
+```js
+const assoc = {
+    name: 'John',
+    age: 30,
+    city: 'New York',
+};
+console.log(assoc); // { name: 'John', age: 30, city: 'New York' }
+console.log(assoc.name); // John
+console.log(assoc['age']); // 30
+```
+
+#### Преобразование массивов в коллекции и обратно
+
+```js
+const array = { a: 1, b: 2, c: 3 };
+const entries = Object.entries(array);
+const map = new Map(entries);
+console.log(map); // Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }
+
+const newArray = Object.fromEntries(map);
+console.log(newArray); // { a: 1, b: 2, c: 3 }
+```
+
+#### Проверка типа массива
+
+```js
+const list = [1, 2, 3];
+const assoc = { key1: 'value1', key2: 'value2', key3: 'value3' };
+
+console.log(is_array(list)); // true
+console.log(is_array(assoc)); // true
+console.log(is_array(new Map())); // false
+console.log(is_array(new Set())); // false
+```
+
+#### Получение типа переменной
+
+```js
+const list = [1, 2, 3];
+const assoc = { key1: 'value1', key2: 'value2', key3: 'value3' };
+
+console.log(gettype(list)); // "array"
+console.log(gettype(assoc)); // "array"
+console.log(gettype(new Map())); // "object"
+console.log(gettype(new Set())); // "object"
+```

package/docs/types/bigint.md

@@ -1,34 +1,34 @@
-[Главная](../../README.md) / [Типы данных](../types.md) / Большое целое число
-
-# Большое целое число
-
-## Большое целое число в JavaScript
-
-`BigInt` – это специальный числовой тип, который предоставляет возможность работать с целыми числами
-произвольной длины.
-
-[Подробнее...](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
-
-## Большое целое число в value.js
-
-Библиотека не вносит ни каких изменений в определение большого целого числа.
-
-### Проверка типа
-
-Проверить, является ли значение большим целым числом, можно с помощью функции
-[is_bigint](../helpers/is_bigint.md).
-
-```js
-is_bigint(10n); // true
-is_bigint(10); // false
-
-gettype(10n); // "bigint"
-```
-
-### Привидение к типу
-
-Привести к большому целому числу можно с помощью функции `to_bigint`.
-
-```js
-to_bigint(10); // 10n
-```
+[Главная](../../README.md) / [Типы данных](../types.md) / Большое целое число
+
+# Большое целое число
+
+## Большое целое число в JavaScript
+
+`BigInt` – это специальный числовой тип, который предоставляет возможность работать с целыми числами
+произвольной длины.
+
+[Подробнее...](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
+
+## Большое целое число в value.js
+
+Библиотека не вносит ни каких изменений в определение большого целого числа.
+
+### Проверка типа
+
+Проверить, является ли значение большим целым числом, можно с помощью функции
+[is_bigint](../helpers/is_bigint.md).
+
+```js
+is_bigint(10n); // true
+is_bigint(10); // false
+
+gettype(10n); // "bigint"
+```
+
+### Привидение к типу
+
+Привести к большому целому числу можно с помощью функции `to_bigint`.
+
+```js
+to_bigint(10); // 10n
+```