@rogolev/value 0.0.1 → 0.0.2

package/docs/classes/Convert/toString.md

@@ -0,0 +1,125 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Convert](../Convert.md) / toString
+
+[Исходный код](../../../src/classes/Convert.mjs)
+
+# Convert.toString
+
+`Convert.toString` — Преобразует значение в строку.
+
+## Сигнатура метода
+
+```ts
+static toString(value: any): string;
+```
+
+## Описание
+
+Метод `Convert.toString` используется для преобразования различных типов данных в строку. Он
+обрабатывает массивы, объекты, классы, функции, символы и другие типы данных, возвращая их строковое
+представление.
+
+## Параметры
+
+- `value` (any)
+
+    Переменная, значение которой необходимо привести к строке.
+
+## Возвращаемое значение
+
+Возвращает строку, соответствующую переданному значению.
+
+## Примеры использования
+
+1. Преобразование строки:
+
+    ```js
+    const result = Convert.toString('example');
+    // Результат: 'example'
+    ```
+
+2. Преобразование числа:
+
+    ```js
+    const result = Convert.toString(123);
+    // Результат: '123'
+    ```
+
+3. Преобразование булевых значений:
+
+    ```js
+    const result1 = Convert.toString(true);
+    // Результат: 'true'
+
+    const result2 = Convert.toString(false);
+    // Результат: 'false'
+    ```
+
+4. Преобразование null и undefined:
+
+    ```js
+    const result1 = Convert.toString(null);
+    // Результат: 'null'
+
+    const result2 = Convert.toString(undefined);
+    // Результат: 'undefined'
+    ```
+
+5. Преобразование массива:
+
+    ```js
+    const arr = [1, 2, 3];
+    const result = Convert.toString(arr);
+    // Результат: '[\n    1,\n    2,\n    3,\n]'
+    ```
+
+6. Преобразование объекта:
+
+    ```js
+    const obj = { key: 'value' };
+    const result = Convert.toString(obj);
+    // Результат: '{\n    key: 'value',\n}'
+    ```
+
+7. Преобразование функции:
+
+    ```js
+    const func = function () {};
+    const result = Convert.toString(func);
+    // Результат: 'function func() {}'
+    ```
+
+8. Преобразование символа:
+
+    ```js
+    const symbol = Symbol('example');
+    const result = Convert.toString(symbol);
+    // Результат: 'Symbol(example)'
+    ```
+
+9. Преобразование BigInt:
+
+    ```js
+    const bigInt = BigInt(123);
+    const result = Convert.toString(bigInt);
+    // Результат: '123'
+    ```
+
+10. Преобразование класса:
+
+    ```js
+    class MyClass {
+        static test = 'test';
+    }
+    const result = Convert.toString(MyClass);
+    // Результат: 'class MyClass {}'
+    ```
+
+11. Преобразование экземпляра класса:
+
+    ```js
+    class MyClass {}
+    const instance = new MyClass();
+    const result = Convert.toString(instance);
+    // Результат: 'object MyClass'
+    ```
+

package/docs/classes/Convert.md

@@ -0,0 +1,44 @@
+[Главная](../../README.md) / [Классы](../classes.md) / Convert
+
+[Исходный код](../../src/classes/Convert.mjs)
+
+# Convert
+
+`Convert` — Класс, предоставляющий методы для преобразования различных типов данных в
+JavaScript.
+
+## Сигнатура класса
+
+```ts
+class Convert {
+    static toArray(value: any): Array<any>;
+    static toAssoc(value: any): Object;
+    static toBool(value: any): boolean;
+    static toBoolean(value: any): boolean;
+    static toFloat(value: any): number;
+    static toInt(value: any, base?: number): number;
+    static toInteger(value: any, base?: number): number;
+    static toList(value: any): Array<any>;
+    static toObject(value: any): Object;
+    static toString(value: any): string;
+}
+```
+
+## Описание
+
+Класс `Convert` включает в себя статические методы, которые позволяют преобразовывать значения
+различных типов данных в другие типы.
+
+### Методы
+
+- [toArray](./Convert/toArray.md) &mdash; Преобразует значение в массив.
+- [toAssoc](./Convert/toAssoc.md) &mdash; Преобразует значение в ассоциативный массив.
+- [toBool](./Convert/toBool.md) &mdash; Преобразует значение в логическое значение.
+- [toBoolean](./Convert/toBoolean.md) &mdash; Преобразует значение в логическое значение.
+- [toFloat](./Convert/toFloat.md) &mdash; Преобразует значение в число с плавающей точкой.
+- [toInt](./Convert/toInt.md) &mdash; Преобразует значение в целое число.
+- [toInteger](./Convert/toInteger.md) &mdash; Преобразует значение в целое число.
+- [toList](./Convert/toList.md) &mdash; Преобразует значение в список.
+- [toObject](./Convert/toObject.md) &mdash; Преобразует значение в объект.
+- [toString](./Convert/toString.md) &mdash; Преобразует значение в строку.
+

package/docs/classes/Type/isArray.md

@@ -0,0 +1,106 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isArray
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isArray
+
+`Type.isArray` — Проверяет, является ли переданное значение массивом или ассоциативным
+массивом (объектом с ключами и значениями).
+
+## Сигнатура метода
+
+```ts
+static isArray(value: any): boolean;
+```
+
+## Описание
+
+В JavaScript массивы и объекты имеют разные структуры и предназначения:
+
+- Массивы (`Array`) являются упорядоченными коллекциями элементов, которые могут быть индексированы.
+- Объекты (`Object`) содержат пары "ключ-значение", которые могут быть неупорядоченными.
+
+Этот метод проверяет, является ли переданное значение обычным массивом (например, `[1, 2, 3]`), либо
+ассоциативным массивом (объектом с парами "ключ-значение", например, `{foo: 'bar'}`).
+
+## Алгоритм работы метода
+
+1. Сначала проверяется, является ли переданное значение обычным массивом с помощью встроенного
+   метода `Array.isArray(value)`. Если это массив, метод сразу возвращает `true`.
+
+2. Если переменная не является массивом, то выполняются дополнительные проверки:
+
+    - Проверяется, что значение не равно `null` (так как `null` в JavaScript также является
+      объектом, но не является ни массивом, ни объектом с парами "ключ-значение").
+    - Проверяется, что значение является объектом JavaScript (с помощью
+      `typeof value === 'object'`).
+    - Проверяется, что прототип объекта совпадает с `Object.prototype` (это объект, от которого
+      наследуются все объекты в JavaScript) или является `null` (это означает, что объект был создан
+      с помощью `Object.create(null)` и не имеет прототипа).
+    - Исключаются массивоподобные объекты (например, `arguments`, `NodeList`), путем проверки, что
+      свойство `length` не является собственным свойством объекта.
+    - Дополнительно проверяется, что объект является простым (его конструктор равен `Object`), а
+      также исключаются встроенные объекты (`Math`, `JSON`, `Reflect`, `Intl`), для которых метод
+      возвращает `true`.
+
+## Параметры
+
+- `value` (any)
+
+    Проверяемая переменная.
+
+## Возвращаемое значение
+
+Возвращает `true`, если переменная является обычным массивом (`Array`), ассоциативным массивом
+(объектом с парами "ключ-значение"), ассоциативным массивом, созданным с помощью
+`Object.create(null)`. В остальных случаях метод возвращает `false`.
+
+## Примеры использования
+
+1. Простые массивы:
+
+    ```js
+    Type.isArray([1, 2, 3]); // true
+    Type.isArray([]); // true
+    ```
+
+2. Ассоциативные массивы (объекты с ключами и значениями):
+
+    ```js
+    Type.isArray({ foo: 'bar', baz: 42 }); // true
+    Type.isArray({ 0: 'a', 1: 'b' }); // true
+    ```
+
+3. Объекты, созданные без прототипа:
+
+    ```js
+    const noProtoObject = Object.create(null);
+    noProtoObject.foo = 'bar';
+    Type.isArray(noProtoObject); // true
+    ```
+
+4. Примитивы и невалидные значения:
+
+    ```js
+    Type.isArray(null); // false
+    Type.isArray(undefined); // false
+    Type.isArray(42); // false
+    Type.isArray('hello'); // false
+    ```
+
+5. Специальные объекты:
+
+    ```js
+    Type.isArray(new Map()); // false
+    Type.isArray(new Set()); // false
+    Type.isArray(() => {}); // false
+    ```
+
+6. Классы и их экземпляры:
+
+    ```js
+    class MyClass {}
+    const instance = new MyClass();
+    Type.isArray(instance); // false
+    ```
+

package/docs/classes/Type/isAssoc.md

@@ -0,0 +1,57 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isAssoc
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isAssoc
+
+`Type.isAssoc` — Проверяет, является ли значение ассоциативным массивом.
+
+## Сигнатура метода
+
+```ts
+static isAssoc(value: any): boolean;
+```
+
+## Описание
+
+Ассоциативные массивы в JavaScript представляют собой объекты с парами "ключ-значение". Этот метод
+проверяет, является ли переданное значение ассоциативным массивом.
+
+Метод использует функцию `is_array` для проверки значения и убеждается, что значение не является
+обычным массивом.
+
+## Параметры
+
+- `value` (any)
+
+    Значение, которое необходимо проверить.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является ассоциативным массивом, и `false` в противном случае.
+
+## Примеры использования
+
+1. Ассоциативные массивы:
+
+    ```js
+    Type.isAssoc({ foo: 'bar' }); // true
+    Type.isAssoc({}); // true
+    ```
+
+2. Обычные массивы:
+
+    ```js
+    Type.isAssoc([]); // false
+    Type.isAssoc([1, 2, 3]); // false
+    ```
+
+3. Значения других типов:
+
+    ```js
+    Type.isAssoc('string'); // false
+    Type.isAssoc(42); // false
+    Type.isAssoc(null); // false
+    Type.isAssoc(undefined); // false
+    ```
+

package/docs/classes/Type/isBigInt.md

@@ -0,0 +1,49 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isBigInt
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isBigInt
+
+`Type.isBigInt` — Проверяет, является ли значение типом `bigint`.
+
+## Сигнатура метода
+
+```ts
+static isBigInt(value: any): boolean;
+```
+
+## Описание
+
+Метод `Type.isBigInt` проверяет, является ли переданное значение типом `bigint`.
+
+## Параметры
+
+- `value` (any)
+
+    Значение, которое необходимо проверить.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является типом `bigint`, и `false` в противном случае.
+
+## Примеры использования
+
+1. Проверка значений типа bigint:
+
+    ```js
+    Type.isBigInt(BigInt(123456)); // true
+    Type.isBigInt(BigInt(-123456)); // true
+    ```
+
+2. Проверка значений других типов:
+
+    ```js
+    Type.isBigInt(42); // false (число)
+    Type.isBigInt('42'); // false (строка)
+    Type.isBigInt(true); // false (логическое значение)
+    Type.isBigInt(null); // false
+    Type.isBigInt(undefined); // false
+    Type.isBigInt({}); // false (объект)
+    Type.isBigInt([]); // false (массив)
+    ```
+

package/docs/classes/Type/isBool.md

@@ -0,0 +1,51 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isBool
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isBool
+
+`Type.isBool` — Проверяет, является ли переданное значение логическим типом (`boolean`).
+
+## Сигнатура метода
+
+```ts
+static isBool(value: any): boolean;
+```
+
+## Описание
+
+В JavaScript логическое значение может быть только двумя состояниями: `true` или `false`. Метод
+проверяет тип переданного значения с использованием оператора `typeof`. Если значение является
+примитивом типа `boolean`, метод возвращает `true`. Для всех других типов (включая объекты, строки,
+числа, `null`, `undefined` и другие) метод вернёт `false`.
+
+## Параметры
+
+- `value` (any)
+
+    Проверяемая переменная.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение `value` является логическим (`boolean`), иначе `false`.
+
+## Примеры использования
+
+1. Проверка логических значений:
+
+    ```js
+    Type.isBool(true); // true
+    Type.isBool(false); // true
+    ```
+
+2. Проверка значений других типов:
+
+    ```js
+    Type.isBool(0); // false
+    Type.isBool('true'); // false
+    Type.isBool(null); // false
+    Type.isBool([]); // false
+    Type.isBool({}); // false
+    Type.isBool(new Boolean(true)); // false
+    ```
+

package/docs/classes/Type/isBoolean.md

@@ -0,0 +1,51 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isBoolean
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isBoolean
+
+`Type.isBoolean` — Проверяет, является ли переданное значение логическим типом (`boolean`).
+
+## Сигнатура метода
+
+```ts
+static isBoolean(value: any): boolean;
+```
+
+## Описание
+
+В JavaScript логическое значение может быть только двумя состояниями: `true` или `false`. Метод
+проверяет тип переданного значения с использованием оператора `typeof`. Если значение является
+примитивом типа `boolean`, метод возвращает `true`. Для всех других типов (включая объекты, строки,
+числа, `null`, `undefined` и другие) метод вернёт `false`.
+
+## Параметры
+
+- `value` (any)
+
+    Проверяемая переменная.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение `value` является логическим (`boolean`), иначе `false`.
+
+## Примеры использования
+
+1. Проверка логических значений:
+
+    ```js
+    Type.isBoolean(true); // true
+    Type.isBoolean(false); // true
+    ```
+
+2. Проверка значений других типов:
+
+    ```js
+    Type.isBoolean(0); // false
+    Type.isBoolean('true'); // false
+    Type.isBoolean(null); // false
+    Type.isBoolean([]); // false
+    Type.isBoolean({}); // false
+    Type.isBoolean(new Boolean(true)); // false
+    ```
+

package/docs/classes/Type/isClass.md

@@ -0,0 +1,60 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isClass
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isClass
+
+`Type.isClass` — Проверяет, является ли переданная переменная классом.
+
+## Сигнатура метода
+
+```ts
+static isClass(value: any): boolean;
+```
+
+## Описание
+
+В JavaScript классы являются функциями, но с уникальным поведением.
+
+Для определения класса метод проверяет:
+
+1. Что переданная переменная является функцией.
+2. Что строковое представление функции начинается с `class `.
+
+Конструкторы функций, созданные с помощью `function`, не будут распознаны как классы.
+
+## Параметры
+
+- `value` (any)
+
+    Проверяемая переменная.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является классом, иначе `false`.
+
+## Примеры использования
+
+1. Классы:
+
+    ```js
+    class MyClass {}
+    Type.isClass(MyClass); // true
+    ```
+
+2. Функции-конструкторы:
+
+    ```js
+    function MyFunction() {}
+    Type.isClass(MyFunction); // false
+    ```
+
+3. Объекты и примитивы:
+
+    ```js
+    Type.isClass({}); // false
+    Type.isClass([]); // false
+    Type.isClass(null); // false
+    Type.isClass(42); // false
+    ```
+

package/docs/classes/Type/isEmpty.md

@@ -0,0 +1,53 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isEmpty
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isEmpty
+
+`Type.isEmpty` — Проверяет, является ли переменная пустой.
+
+## Сигнатура метода
+
+```ts
+static isEmpty(value: any): boolean;
+```
+
+## Описание
+
+Метод `Type.isEmpty` используется для проверки, является ли переменная пустой. Пустыми считаются
+значения `null`, `undefined`, пустая строка, `0`, `false`, пустой массив и пустой объект.
+
+## Параметры
+
+- `value` (any)
+
+    Переменная, которую необходимо проверить на пустоту.
+
+## Возвращаемое значение
+
+Возвращает `true`, если переменная пустая, и `false` в противном случае.
+
+## Примеры использования
+
+1. Проверка пустых значений:
+
+    ```js
+    Type.isEmpty(null); // true
+    Type.isEmpty(undefined); // true
+    Type.isEmpty(''); // true
+    Type.isEmpty(0); // true
+    Type.isEmpty(false); // true
+    Type.isEmpty([]); // true
+    Type.isEmpty({}); // true
+    ```
+
+2. Проверка непустых значений:
+
+    ```js
+    Type.isEmpty('example'); // false
+    Type.isEmpty(123); // false
+    Type.isEmpty(true); // false
+    Type.isEmpty([1, 2, 3]); // false
+    Type.isEmpty({ key: 'value' }); // false
+    ```
+

package/docs/classes/Type/isFloat.md

@@ -0,0 +1,77 @@
+[Главная](../../../README.md) / [Классы](../../classes.md) / [Type](../Type.md) / isFloat
+
+[Исходный код](../../../src/classes/Type.mjs)
+
+# Type.isFloat
+
+`Type.isFloat` — Проверяет, является ли значение числом с плавающей точкой.
+
+## Сигнатура метода
+
+```ts
+static isFloat(value: any): boolean;
+```
+
+## Описание
+
+Метод `Type.isFloat` проверяет, является ли переданное значение числом с дробной частью, которое
+отличается от целого числа.
+
+Он работает следующим образом:
+
+1. Проверяет, что значение имеет тип `number`.
+2. Исключает значения `NaN`, которые также относятся к типу `number`, но не считаются числовыми
+   значениями.
+3. Проверяет, что у числа есть дробная часть, проверяя остаток от деления на `1`
+   (`value % 1 !== 0`).
+
+Значения, которые не являются числами или числа без дробной части, не считаются числами с плавающей
+точкой.
+
+## Параметры
+
+- `value` (any)
+
+    Значение для проверки.
+
+## Возвращаемое значение
+
+Возвращает `true`, если значение является числом с плавающей точкой, иначе `false`.
+
+## Примеры использования
+
+1. Числа с плавающей точкой:
+
+    ```js
+    Type.isFloat(3.14); // true
+    Type.isFloat(-0.5); // true
+    Type.isFloat(0.1 + 0.2); // true
+    ```
+
+2. Целые числа:
+
+    ```js
+    Type.isFloat(0); // false
+    Type.isFloat(42); // false
+    Type.isFloat(-100); // false
+    ```
+
+3. Нечисловые значения:
+
+    ```js
+    Type.isFloat('3.14'); // false
+    Type.isFloat(NaN); // false
+    Type.isFloat(null); // false
+    Type.isFloat(undefined); // false
+    Type.isFloat(true); // false
+    Type.isFloat({}); // false
+    Type.isFloat([]); // false
+    ```
+
+4. Специальные значения:
+
+    ```js
+    Type.isFloat(Infinity); // false
+    Type.isFloat(-Infinity); // false
+    ```
+