Regex, чтобы проверить, содержит ли строка только числа

hash = window.location.hash.substr(1);
var reg = new RegExp('^[0-9]$');
console.log(reg.test(hash));

Я "123f" как на "123" и на "123f". Я хотел бы проверить, содержит ли хэш только числа. Я что-то пропустил?

ОТВЕТЫ

Ответ 1

var reg = /^\d+$/;

должен это сделать. Оригинал сопоставляет все, что состоит из ровно одной цифры.

Ответ 2

Как вы сказали, вы хотите, чтобы хэш содержал только числа.

var reg = new RegExp('^[0-9]+$');

или

var reg = new RegExp('^\\d+$');

\d и [0-9] означают одно и то же. Используемый + означает, что поиск одного или нескольких событий происходит из [0-9].

Ответ 3

Это позволит также для подписанных и плавающих чисел или пустой строки:

var reg = /^-?\d*\.?\d*$/

Если вы не хотите разрешать пустую строку, используйте следующую команду:

var reg = /^-?\d+\.?\d*$/

Ответ 4

var validation = {
    isEmailAddress:function(str) {
        var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
        return pattern.test(str);  // returns a boolean
    },
    isNotEmpty:function (str) {
        var pattern =/\S+/;
        return pattern.test(str);  // returns a boolean
    },
    isNumber:function(str) {
        var pattern = /^\d+$/;
        return pattern.test(str);  // returns a boolean
    },
    isSame:function(str1,str2){
        return str1 === str2;
    }
};   

alert(validation.isNotEmpty("dff"));
alert(validation.isNumber(44));
alert(validation.isEmailAddress("[email protected]"));
alert(validation.isSame("sf","sf"));

Ответ 5

Это крайний перебор для вашей цели, но вот что я использую:

var numberReSnippet = "(?:NaN|-?(?:(?:\\d+|\\d*\\.\\d+)(?:[E|e][+|-]?\\d+)?|Infinity))";
var matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$");

Насколько мне известно, это соответствует всем вариациям номеров, которые Java и JavaScript будут когда-либо бросать на вас, включая "-Infinity", "1e-24" и "NaN". Он также соответствует номерам, которые вы можете ввести, например, "-5".

Как указано, reSnippet предназначен для удаления в другие регулярные выражения, поэтому вы можете извлекать (или избегать) числа. Несмотря на все круглые скобки, он не содержит групп захвата. Таким образом, matchOnlyNumberRe соответствует только строкам, которые являются числами, и имеет группу захвата для всей строки.

Вот тесты Jasmine, поэтому вы можете видеть, что он делает и не обрабатывает:

describe("Number Regex", function() {
    var re = new RegExp("^("+ numberReSnippet + ")$");
    it("Matches Java and JavaScript numbers", function() {
        expect(re.test(         "1")).toBe(true);
        expect(re.test(       "0.2")).toBe(true);
        expect(re.test(     "0.4E4")).toBe(true);  // Java-style
        expect(re.test(       "-55")).toBe(true);
        expect(re.test(      "-0.6")).toBe(true);
        expect(re.test(  "-0.77E77")).toBe(true);
        expect(re.test(      "88E8")).toBe(true);
        expect(re.test(       "NaN")).toBe(true);
        expect(re.test(  "Infinity")).toBe(true);
        expect(re.test( "-Infinity")).toBe(true);
        expect(re.test(     "1e+24")).toBe(true);  // JavaScript-style
    });
    it("Matches fractions with a leading decimal point", function() {
        expect(re.test(        ".3")).toBe(true);
        expect(re.test(       "-.3")).toBe(true);
        expect(re.test(     ".3e-4")).toBe(true);
    });
    it("Doesn't match non-numbers", function() {
        expect(re.test(         ".")).toBe(false);
        expect(re.test(        "9.")).toBe(false);
        expect(re.test(          "")).toBe(false);
        expect(re.test(         "E")).toBe(false);
        expect(re.test(       "e24")).toBe(false);
        expect(re.test(   "1e+24.5")).toBe(false);
        expect(re.test("-.Infinity")).toBe(false);
    });
});

Ответ 6

^[0-9]$

... является регулярным выражением, соответствующим любой отдельной цифре, поэтому 1 вернет true, но 123 вернет false.

Если вы добавите квантификатор *,

^[0-9]*$

выражение будет соответствовать строкам произвольной длины цифр, а 123 вернет true. (123f все равно вернет false).

Помните, что технически пустая строка представляет собой строку цифр длиной 0 строк, и поэтому она вернет true, используя ^ [0-9] * $Если вы хотите принимать только строки, содержащие 1 или более цифр, используйте + вместо of *

^[0-9]+$

Как указывали многие другие, есть несколько способов достичь этого, но я чувствовал, что было бы целесообразно указать, что код в исходном вопросе требует только одного дополнительного символа для работы по назначению.

Ответ 7

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

Это тест, который можно использовать для ввода формы HTML, например.

Он обходит весь JS-фольклор, например, tipeof (NaN) = число, parseint ('1 Kg') = 1, булевы, закодированные в числа, и тому подобное.

Он делает это, передавая аргумент как строку и проверяя эту строку на регулярное выражение, как на @codename, но разрешая записи типа 5. и .5

function isANumber( n ) {
    var numStr = /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/;
    return numStr.test( n.toString() );
}

not numeric:
Logger.log( 'isANumber( "aaa" ): ' + isANumber( 'aaa' ) );
Logger.log( 'isANumber( "" ): ' + isANumber( '' ) );
Logger.log( 'isANumber( "lkjh" ): ' + isANumber( 'lkjh' ) );
Logger.log( 'isANumber( 0/0 ): ' + isANumber( 0 / 0 ) );
Logger.log( 'isANumber( 1/0 ): ' + isANumber( 1 / 0 ) );
Logger.log( 'isANumber( "1Kg" ): ' + isANumber( '1Kg' ) );
Logger.log( 'isANumber( "1 Kg" ): ' + isANumber( '1 Kg' ) );
Logger.log( 'isANumber( false ): ' + isANumber( false ) );
Logger.log( 'isANumber( true ): ' + isANumber( true ) );

numeric:
Logger.log( 'isANumber( "0" ): ' + isANumber( '0' ) );
Logger.log( 'isANumber( "12.5" ): ' + isANumber( '12.5' ) );
Logger.log( 'isANumber( ".5" ): ' + isANumber( '.5' ) );
Logger.log( 'isANumber( "5." ): ' + isANumber( '5.' ) );
Logger.log( 'isANumber( "-5" ): ' + isANumber( '-5' ) );
Logger.log( 'isANumber( "-5." ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "-.5" ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "1234567890" ): ' + isANumber( '1234567890' ));

Объяснение регулярного выражения:

/^-?(\d+\.?\d*)$|(\d*\.?\d+)$/

Начальный "^" и окончательный "$" соответствуют началу и концу строки, чтобы гарантировать, что проверка охватывает всю строку. "-?" часть - знак минуса с символом "?" множитель, который допускает нуль или один экземпляр.

Тогда есть две одинаковые группы, ограниченные скобками. Строка должна соответствовать любой из этих групп. Первые совпадающие числа, такие как 5. и вторая .5

Первая группа

\d+\.?\d*

"\ d +" соответствует цифре (\ d) один или несколько раз.
"\.?" - это десятичная точка (экранированная "\", чтобы лишить ее магии), ноль или один раз.

Последняя часть "\ d *" снова представляет собой цифру, ноль или более раз.
Все части являются необязательными, но первая цифра, поэтому эта группа соответствует номерам типа 5., а не .5, которые совпадают с другой половиной.

Ответ 8

Почему не используйте что-то вроде:

$.isNumeric($(input).val())

Проверен ли jquery и проверен наиболее распространенный случай

Ответ 9

Если вам нужны только положительные целые числа и не нужны начальные нули (например, "0001234" или "00" ):

var reg = /^(?:[1-9]\d*|\d)$/;

Ответ 10

Вам нужен *, поэтому он говорит "ноль или более предыдущего символа", и это должно сделать это:

var reg = new RegExp('^\\d*$');

Ответ 11

Если числа не должны быть абсурдно огромными, возможно, используйте:

new RegExp(
    '^' +                           // No leading content.
    '[-+]?' +                       // Optional sign.
    '(?:[0-9]{0,30}\\.)?' +         // Optionally 0-30 decimal digits of mantissa.
    '[0-9]{1,30}' +                 // 1-30 decimal digits of integer or fraction.
    '(?:[Ee][-+]?[1-2]?[0-9])?' +   // Optional exponent 0-29 for scientific notation.
    '$'                             // No trailing content.
)

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

  • Переполнение любых буферов, к которым может быть передана исходная строка.
  • Медлительность или странности, вызванные денормальными номерами, такими как 1E-323.
  • Передача Infinity, когда ожидается конечное число (попробуйте 1E309 или -1E309).

Ответ 12

\ d не будет соответствовать десятичной запятой. Используйте следующее для десятичной дроби.

const re = /^[0-9.]+$/
'123'.match(re)       // true
'123.3'.match(re)     // true
'123!3'.match(re)     // false

Ответ 13

Возможно, это работает:

let a = "1234"
parseInt(a) == a // true
let b = "1234abc"
parseInt(b) == b // false

Ответ 14

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

    var yourInput = jQuery('#input-field');
    yourInput.keyup(function() {
        yourInput.val((yourInput.val().replace(/[^\d]/g,'')))
    })

Ответ 15

Простой Regex Javascript

var cnpj = "12.32.432/1-22".replace(/\D/gm,"");
console.log(cnpj);

* Результат:

1232432122

Проверяет только номера:

if(cnpj.length === cnpj){
   return true;
}

Простой пример

if("12.32.432/1-22".replace(/\D/gm,"").length > 0){
   console.log("Ok.");
}

Ответ 16

Вы также можете использовать следующие методы, но знать их внутреннюю реализацию и/или возвращаемые значения.

1A isNaN(+'13761123123123'); // returns true
1B isNaN(+'13761123123ABC'); // returns false

2A ~~'1.23'; // returns 1
2B ~~'1.2A'; // returns 0

Для 1A & 1B строка - это первый тип, принудительно используемый с помощью оператора + перед передачей функции isNaN(). Это работает, потому что числовые типы, которые включают нечисловые значения, возвращают NaN. Существуют соображения с isNaN()'s реализации isNaN()'s которые описаны здесь. Одно соображение заключается в том, что, если логическое значение передается как isNaN(+false|true), принуждаются к их числовым эквивалентам, и поэтому возвращается false но можно ожидать, что функция вернет true поскольку логическое значение не является числовым в смысле что мы тестируем.

Для 2A и 2B стоит отметить, что для нахождения дополнения к числу требуется, чтобы данное значение находилось в пределах диапазона значений знакового 32-битного целого числа, на которое можно ссылаться в спецификации.

Мои личные предпочтения, хотя можно утверждать, что они менее читаемы, поскольку они включают унарный оператор, составляют 1A & 1B из-за скорости и лаконичности.

Perf https://jsperf.com/numeric-string-test-regexvsisnan/1

Ответ 17

Я вижу, что вы уже получили много ответов, но если вы ищете регулярное выражение, которое может соответствовать целым числам и номерам с плавающей запятой, это будет работать для вас:

var reg = /^-?\d*\.?\d+$/;

Ответ 18

var reg = new RegExp('^[0-9]+$');

вы просто пропустили + в своей попытке

Ответ 19

Если вы хотите совместить числа со знаками со знаком, вы можете использовать:

var reg = new RegExp('^(\-?|\+?)\d*$');

Он будет проверять номера формата: +1, -1, 1.

Ответ 20

/^[\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?$/

Ответ 21

Использовать этот:

const pattern = new RegExp(/^[+-]?\d+(\.\d+)?([Ee][+-]?\d+)?$/g);

Ответ 22

Число только регулярное выражение (обновлено)

 var reg = new RegExp('[^0-9]','g');

Ответ 23

var pattern = /[0-9!"£$%^&*()_+-=]/;

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

Переполнение любых буферов, к которым может быть передана исходная строка. Медлительность или странности, вызванные денормальными номерами, такими как 1E-323. Передача бесконечности, когда ожидается конечное число (попробуйте 1E309 или -1E309).