Методы toInt и toFloat

В библиотеке validator.js методы toInt и toFloat используются для преобразования строковых значений в числовые типы Integer и Float. Эти функции решают задачу нормализации входных данных, когда пользовательские значения поступают в виде строк, но в дальнейшем должны обрабатываться как числа.

Особенность подхода validator.js заключается в том, что преобразование выполняется с учётом строгой валидации входных данных: некорректные строки не приводятся к числам автоматически в «размытом» виде, а либо очищаются по правилам, либо возвращают ожидаемые крайние значения.

Метод toInt(value, radix) преобразует строковое представление числа в целое число. В основе используется поведение, близкое к parseInt, но с дополнительной нормализацией входа.

Сигнатура

toInt(value, radix)
  • value — значение, которое требуется преобразовать (обычно строка)
  • radix — основание системы счисления (по умолчанию 10)

Основные особенности

Метод предварительно приводит значение к строке, что позволяет обрабатывать числа, переданные в разных типах:

import { toInt } from 'validator';

toInt('42');        // 42
toInt('  42 ');     // 42
toInt(42);          // 42
toInt('0042');      // 42

Если строка содержит недопустимые символы, они игнорируются после первого некорректного участка:

toInt('42px');      // 42
toInt('px42');      // NaN

Важное поведение связано с обработкой отрицательных чисел:

toInt('-42');       // -42
toInt('-42px');     // -42

Radix и системы счисления

Параметр radix задаёт систему счисления:

toInt('1010', 2);   // 10 (двоичная система)
toInt('A', 16);     // 10 (шестнадцатеричная система)

При отсутствии явного указания radix используется десятичная система.

Обработка некорректных значений

Если вход не может быть интерпретирован как число, результатом становится NaN:

toInt('abc');       // NaN
toInt('');          // NaN
toInt(null);        // NaN

При этом поведение остаётся предсказуемым и не приводит к неявным преобразованиям в 0, как это происходит в некоторых встроенных JavaScript-операциях.

toFloat: преобразование в число с плавающей точкой

Метод toFloat(value) преобразует входное значение в число с плавающей точкой. Внутренне используется логика, аналогичная parseFloat, но с унифицированной обработкой строк и типов данных.

Сигнатура

toFloat(value)
  • value — значение для преобразования

Базовое поведение

Метод извлекает числовую часть строки, начиная с первого допустимого символа:

import { toFloat } from 'validator';

toFloat('3.14');        // 3.14
toFloat('  3.14  ');    // 3.14
toFloat(3.14);          // 3.14

Поддерживаются дробные значения:

toFloat('10.5');        // 10.5
toFloat('-10.5');       // -10.5

Обработка строк с дополнительными символами

Как и в случае с toInt, символы после валидной числовой части игнорируются:

toFloat('3.14px');      // 3.14
toFloat('2.71e10');     // 27100000000

Если строка начинается с некорректного символа, преобразование невозможно:

toFloat('px3.14');      // NaN
toFloat('abc');         // NaN

Особенности работы с экспоненциальной записью

Метод корректно обрабатывает научную нотацию:

toFloat('1e3');         // 1000
toFloat('2.5e2');       // 250
toFloat('-1e-2');       // -0.01

Это делает toFloat удобным инструментом при работе с числовыми значениями из API, где часто используется экспоненциальная форма записи.

Отличия toInt и toFloat

Несмотря на схожесть поведения, методы решают разные задачи:

  • toInt ориентирован на целые числа и обрезает дробную часть
  • toFloat сохраняет точность дробных значений

Примеры различий:

toInt('3.99');      // 3
toFloat('3.99');    // 3.99

При этом оба метода не выполняют округление в математическом смысле — дробная часть в toInt просто игнорируется.

Особенности обработки типов данных

Оба метода приводят вход к строковому виду перед обработкой. Это обеспечивает единообразие поведения:

toInt(true);        // NaN
toFloat(true);      // NaN

toInt(false);       // NaN
toFloat(false);     // NaN

Объекты также не приводятся к числам автоматически:

toInt({});          // NaN
toFloat({});        // NaN

Массивы интерпретируются как строки:

toInt(['42']);      // 42
toFloat(['3.14']);  // 3.14

Практическое применение валидации чисел

Использование toInt и toFloat в validator.js позволяет стандартизировать входные данные перед дальнейшей обработкой, например при работе с формами или API:

const age = toInt(req.body.age);
const price = toFloat(req.body.price);

Такой подход снижает риск некорректных преобразований, характерных для нестрогих операций приведения типов в JavaScript.

Поведение NaN и проверка результата

Оба метода могут возвращать NaN, что требует последующей проверки:

const value = toInt('abc');

if (Number.isNaN(value)) {
    // обработка некорректного значения
}

В validator.js отсутствует скрытая подмена NaN на другие значения, что делает поведение предсказуемым при обработке ошибок ввода.

Оглавление