Регулярное выражение, чтобы проверить, содержит ли строка только числа

Question

Регулярное выражение, чтобы проверить, содержит ли строка только числа

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

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

179

javascript regex

автор: Xufox

21 ответов

автор: Mike Samuel · Accepted Answer · 2012-01-25 22:46:42

var reg = /^\d+$/;

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

автор: Abhijeet Rastogi · Accepted Answer · 2012-01-25 22:45:20

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

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

или

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

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

автор: codename- · Accepted Answer · 2013-06-05 23:36:34

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

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

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

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

автор: Dastagir · Accepted Answer · 2015-12-09 16:13:18

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("mf@tl.ff"));
alert(validation.isSame("sf","sf"));

автор: David Leppik · Accepted Answer · 2015-06-22 18:21:31

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

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);
    });
});

автор: user1299656 · Accepted Answer · 2016-05-11 20:39:33

^[0-9]$

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

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

^[0-9]*$

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

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

^[0-9]+$

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

автор: Juan Lanus · Accepted Answer · 2015-12-09 16:29:23

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

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

он обходит весь JS-фольклор, например tipeof (NaN) = number, 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, которая соответствует другой половине.

автор: Andrej · Accepted Answer · 2016-08-02 10:35:14

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

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

автор: Relic · Accepted Answer · 2012-01-25 23:54:44

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

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

автор: leonardo rey · Accepted Answer · 2017-11-14 11:54:46

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

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

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

автор: jjrv · Accepted Answer · 2017-03-09 17:11:33

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

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).

автор: Peter Graham · Accepted Answer · 2015-05-11 15:50:50

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

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

автор: Progo · Accepted Answer · 2014-06-28 02:44:23

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

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

автор: Renato burton · Accepted Answer · 2018-06-03 00:06:10

простое регулярное выражение javascript

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

*результат:

1232432122

проверяет только цифры:

if(cnpj.length > 0){
   return true;
}

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

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

автор: swallace · Accepted Answer · 2018-08-07 19:29:31

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

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

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

для 1A & 1B строка первого типа принуждается с помощью + оператор перед передачей

автор: LPOPYui · Accepted Answer · 2018-10-03 00:36:29

может быть, это работает:

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

автор: Richeve Bebedor · Accepted Answer · 2017-02-04 23:20:08

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

-1

автор: Richeve Bebedor

автор: shasi kanth · Accepted Answer · 2017-06-23 00:39:03

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

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

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

автор: Neutral Unit · Accepted Answer · 2018-02-24 23:27:14

используйте этот:

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

-2

автор: Neutral Unit

автор: ozgur · Accepted Answer · 2017-04-14 14:10:07

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

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

автор: andre123 · Accepted Answer · 2017-06-23 01:01:35

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

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

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