Как узнать, что число есть float
или integer
?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
javascript
types
numbers
coure2011
источник
источник
<nit-pick>
JavaScript не имеет различных целочисленных и числовых типов с плавающей точкой. Каждое число в JavaScript это простоNumber
.</nit-pick>
Infinity
ли целое или нецелое значение для вас? Ответы здесь довольно равномерно распределены на этот счет.Infinity
их нельзя считать целым числом.Ответы:
проверить остаток при делении на 1:
Если вы не знаете, что аргумент является числом, вам нужно два теста:
Обновление 2019 Через 5 лет после написания этого ответа решение было стандартизировано в ECMA Script 2015. Это решение рассматривается в этом ответе .
источник
true
,false
,null
, пустой массив, массив , содержащий один целое число, массив , содержащий строку , представляющую собой целое число, а может быть больше.""
и1.0
isInt("");
&&isInt(1.0);
оба результата приводят кtrue
демонстрации jsbin.com/elohuq/1/editfunction last (array) { return array[array.length - 1]; }
, это «просто неправильно» или «Наихудший ответ на SO», потому что он не проверяет, является ли аргумент первым массивом? Да, хорошая практика проверять аргументы, но это ответственность разработчика. SO ответы должны быть короткими и отвечать на вопрос максимально четко.Попробуйте эти функции, чтобы проверить, является ли значение числовым примитивным значением, которое не имеет дробной части и находится в пределах размера того, что может быть представлено как точное целое число.
источник
n===+n
для проверки числовых,n|0
для округления), но со встроенными операторами. фанкиparseFloat()
сначала позвонить .|
(ИЛИ) работают только со знаком 32-битных целых чисел. OP не указывает, нужно ли проверять подписанные значения int32. Так что это не будет работать с номерами вне диапазона.isInteger(5000000000)
вернусь,false
что неправильно!Почему не как то так
источник
n
преобразуется в строку с помощьюparseInt
. Смотрите MDN . Но я буду использовать это решение. :)Существует метод с именем,
Number.isInteger()
который в настоящее время реализован во всем, кроме IE. MDN также предоставляет полифилл для других браузеров:Однако в большинстве случаев лучше использовать
Number.isSafeInteger
метод, который также проверяет, является ли значение настолько высоким / низким, что любые десятичные разряды в любом случае были бы потеряны. Для этого у MDN есть полифил. (Вам также понадобитсяisInteger
указатель выше)источник
12.0 ∈ ℤ
.Number.isInteger
. Тем не менее, это правильный polyfill дляNumber.isSafeInteger
.Number.isInteger
Не следует проверять, является ли число «безопасным целым числом». Смотрите на MDN: isInteger и isSafeInteger .Вы можете использовать простое регулярное выражение:
Или вы можете использовать следующие функции, в зависимости от ваших потребностей. Они разработаны проектом PHPJS .
is_int()
=> Проверить, является ли тип переменной целочисленным и имеет ли ее содержимое целое числоis_float()
=> Проверить, является ли тип переменной float и имеет ли она содержимое floatctype_digit()
=> Проверить, является ли тип переменной строковым и имеет ли ее содержимое только десятичные цифрыОбновление 1
Теперь он проверяет и отрицательные числа, спасибо за комментарий @ChrisBartley !
источник
/^[0-9]+$/.test(String(value))
/^[0-9]+$/.test(''+value)
return /^-?\d+$/.test(String(value));
Вот эффективные функции, которые проверяют, является ли значение числом или его можно безопасно преобразовать в число:
И для целых чисел (вернул бы false, если значение является плавающим):
Эффективность здесь заключается в том, что parseInt (или parseNumber) избегают, когда значение уже является числом. Обе функции синтаксического анализа всегда сначала преобразуются в строку, а затем пытаются проанализировать эту строку, что будет пустой тратой, если значение уже является числом.
Спасибо другим постам здесь за предоставление дальнейших идей для оптимизации!
источник
источник
1.2
. Всегда проверяйте числовые функции с 0,1 0,2 0,3работает для всех случаев.
источник
isInt('1')
возвращается,true
как ожидалось (по крайней мере, для меня). Weird достаточно, хотя, это возвращаетсяtrue
кisInt([5])
а. Не имеет значения для меня, но может для вас, так что позаботьтесь.Как уже упоминалось, у вас есть только двойники в JS. Итак, как вы определяете число, являющееся целым числом? Просто проверьте, равно ли округленное число себе:
источник
isFloat('abc')
возвращаетtrue
isFloat(NaN) // true
Как насчет этого?
источник
console.log(isFloat(1.0));
результаты ложные.Вот что я использую для целых чисел:
Короче, приятно :) Работает постоянно. Это то, что предлагает Дэвид Фланаган, если я не ошибаюсь.
источник
parseFloat
?Это действительно зависит от того, чего вы хотите достичь. Если вы хотите «подражать» языкам со строгой типизацией, я советую вам не пытаться. Как уже упоминалось, все числа имеют одинаковое представление (один и тот же тип).
Используя что-то вроде Клаудиу, при условии:
isInteger( 1.0 )
-> правдачто выглядит хорошо для здравого смысла, но в чем-то вроде C вы получите
false
источник
Любое число с плавающей точкой с нулевой десятичной частью (например, 1,0, 12,00, 0,0) неявно приводится к Integer, поэтому невозможно проверить, являются ли они Float или нет.
источник
источник
!!(24.0%1)
ложноЭто действительно не должно быть так сложно. Числовое значение целочисленных эквивалентов parseFloat () и parseInt () будет одинаковым. Таким образом, вы можете сделать так:
затем
Это также позволит проверять строки и, следовательно, не является строгим. Если вы хотите сильное решение типа (иначе не будем работать со строками):
источник
Не было случая, чтобы это не делало работу.
источник
2
является целым числом и23
считается вторым аргументом функции. В javascript десятичные дроби пишутся с использованием точки в качестве разделителя - так и должно быть2.23
.ЭТО ОКОНЧАТЕЛЬНЫЙ КОД ДЛЯ ПРОВЕРКИ ОБА И INT
ИЛИ
источник
источник
Это просто как:
Попробуйте это в консоли:
Это смущает многих людей. Всякий раз, когда что-то .0, это больше не плавание. Это целое число. Или вы можете просто назвать это «числовой вещью», потому что нет строгого различия, как тогда, в C. Старые добрые времена.
В общем, все, что вы можете сделать, это проверить целое число, принимая тот факт, что 1.000 является целым числом.
Интересная заметка
Был комментарий об огромных числах. Огромные цифры не означают никаких проблем для этого подхода; всякий раз, когда parseInt не может обработать число (потому что оно слишком большое), оно возвращает что-то другое, чем фактическое значение, поэтому тест возвращает FALSE. Это хорошо, потому что если вы рассматриваете что-то как «число», вы обычно ожидаете, что JS сможет рассчитать с ним - так что да, числа ограничены, и parseInt примет это во внимание , чтобы выразить это так.
Попробуй это:
В моем браузере (IE8) это возвращает "a в порядке; b терпит неудачу", что именно из-за огромного числа в b. Предел может варьироваться, но я думаю, что 20 цифр "должно быть достаточно для всех", чтобы процитировать классический :)
источник
Number.isInteger
работает предлагаемый .Number.isInteger
работает. Однострочный тест,n === (n | 0)
как показано в другом ответе.Это решение сработало для меня.
источник
Для целых чисел я использую это
источник
В java-скрипте все числа такие
internally 64 bit floating point
же, как в java двойные. В javascript нет различных типов, все они представлены типомnumber
. Следовательно, вы не сможетеinstanceof
проверить. Однако вы можете использовать приведенные выше решения, чтобы узнать, является ли оно дробным числом. дизайнеры java-скриптов сочли одним типом, что они могут избежать многочисленных ошибок приведения типов.источник
Иногда объекты Number не позволяют использовать прямой оператор мода (%), если вы сталкиваетесь с этим случаем, вы можете использовать это решение.
источник
Пробуя некоторые ответы здесь, я закончил тем, что написал это решение. Это работает также с числами внутри строки.
источник
Возможно, это не так эффективно, как% answer, что не позволяет вам сначала преобразовать строку, но я еще не видел, чтобы кто-нибудь опубликовал ее, так что вот еще один вариант, который должен работать нормально:
источник
Для тех, кто интересуется, используя Benchmark.js, я проверил ответы с наибольшим количеством голосов (и тот, который был опубликован сегодня) в этом посте, вот мои результаты:
источник
Вот мой код. Он проверяет, чтобы убедиться, что это не пустая строка (которая в противном случае пройдет), а затем преобразует ее в числовой формат. Теперь, в зависимости от того, хотите ли вы, чтобы значение 1.1 было равно 1.1, это может быть или не быть тем, что вы ищете.
источник
Мне нравится эта маленькая функция, которая будет возвращать true для положительных и отрицательных целых чисел:
Это работает, потому что 1 или «1» становится «1.0», который isNaN () возвращает «ложь» (который мы затем отменяем и возвращаем), но 1.0 или «1.0» становится «1.0.0», в то время как «строка» становится «строкой». 0 ", ни один из которых не является числом, поэтому isNaN () возвращает false (и, опять же, получает отрицание).
Если вы хотите только натуральные числа, есть такой вариант:
или, для отрицательных целых чисел:
isPositiveInt () работает, перемещая составную числовую строку перед проверяемым значением. Например, isPositiveInt (1) приводит к тому, что isNaN () оценивает «01», что оценивает false. Между тем, isPositiveInt (-1) приводит к тому, что isNaN () оценивает «0-1», что оценивает true. Мы отрицаем возвращаемое значение, и это дает нам то, что мы хотим. isNegativeInt () работает аналогично, но без отрицательного значения, возвращаемого isNaN ().
Редактировать:
Моя оригинальная реализация также возвращала бы true для массивов и пустых строк. Эта реализация не имеет такого недостатка. Он также имеет преимущество возврата рано, если val не является строкой или числом, или если это пустая строка, что делает его более быстрым в этих случаях. Вы можете дополнительно изменить его, заменив первые два предложения на
если вы хотите сопоставлять только буквенные числа (а не строки)
Редактировать:
Я пока не могу оставлять комментарии, поэтому добавляю это в свой ответ. Тест, опубликованный @Asok, очень информативен; однако самая быстрая функция не соответствует требованиям, поскольку она также возвращает TRUE для чисел с плавающей запятой, массивов, логических значений и пустых строк.
Я создал следующий набор тестов для тестирования каждой из функций, также добавив свой ответ в список (функция 8, которая анализирует строки, и функция 9, которая не выполняет):
Я также перезапустил тест с добавленной в список функцией # 8. Я не буду публиковать результаты, так как они немного смущают (например, эта функция НЕ быстрая) ...
Результаты (сокращенно - я удалил успешные тесты, так как вывод довольно длинный) следующие:
Я оставил ошибки, чтобы вы могли видеть, где происходит сбой каждой функции, и (#) проверяет, чтобы вы могли видеть, как каждая функция обрабатывает целочисленные и плавающие значения в строках, так как некоторые могут захотеть, чтобы они анализировались как числа, а некоторые может нет.
Из 10 протестированных функций те, которые действительно соответствуют требованиям OP, [1,3,5,6,8,9]
источник
Условие для плавающей проверки:
Условие для проверки целочисленных значений:
Надеюсь, это может быть полезно.
источник
Вы можете добавить,
typeof a === 'number'
если вы хотите исключить строки.источник