Number Validation Regular Expressions

Numbers can be validated in various formats including integers, decimals, and floating-point numbers. These regex patterns provide validation for common number formats, supporting both positive and negative values.

Integer Numbers

Validates whole numbers, both positive and negative, without decimal points.

^-?\d+$

Explanation

^ - Start of the string.
-? - Optional minus sign for negative numbers.
\d+ - One or more digits.
$ - End of the string.

Implementation

const integerRegex = /^-?\d+$/;
const isValidInteger = (number) => integerRegex.test(number);

import re

def is_valid_integer(number):
  integerRegex = r"^-?\d+$"
  return re.match(integerRegex, number) is not None

use regex::Regex;

fn is_valid_integer(number: &str) -> bool {
  let integerRegex = Regex::new("^-?\d+$")
    .expect("Could not parse integer validation regex");
  integerRegex.is_match(number)
}

package main

import (
  "fmt"
  "regexp"
)

func isValidInteger(number string) bool {
  integerRegex := "^-?\d+$"
  re := regexp.MustCompile(integerRegex)
  return re.MatchString(number)
}

import Foundation

func isValidInteger(_ number: String) -> Bool {
  let integerRegex = "^-?\d+$"
  return NSPredicate(format: "SELF MATCHES %@", integerRegex).evaluate(with: number)
}

using System;
using System.Text.RegularExpressions;

class Application {
  static bool IsValidInteger(string number) {
    string integerRegex = "^-?\d+$";
    return Regex.IsMatch(number, integerRegex);
  }
}

import java.util.regex.*;

public class Application {
  public static boolean isValidInteger(String number) {
    String integerRegex = "^-?\d+$";
    Pattern pattern = Pattern.compile(integerRegex);
    Matcher matcher = pattern.matcher(number);
    return matcher.matches();
  }
}

<?php
function isValidInteger($number) {
  $integerRegex = "^-?\d+$";
  return (bool) preg_match("/" . $integerRegex . "/", $number);
}
?>

Test Cases

Number	Valid
123
-456
0
-0
1000000
12.34
12.0
abc
12a
(empty string)
+123
1,234
1 234
--123

Decimal Numbers

Validates decimal numbers with optional fractional parts, both positive and negative.

^-?\d+(\.\d+)?$

Explanation

^ - Start of the string.
-? - Optional minus sign for negative numbers.
\d+ - One or more digits before the decimal point.
(\.\d+)? - Optional decimal part: a dot followed by one or more digits.
$ - End of the string.

Implementation

const decimalRegex = /^-?\d+(\.\d+)?$/;
const isValidDecimal = (number) => decimalRegex.test(number);

import re

def is_valid_decimal(number):
  decimalRegex = r"^-?\d+(\.\d+)?$"
  return re.match(decimalRegex, number) is not None

use regex::Regex;

fn is_valid_decimal(number: &str) -> bool {
  let decimalRegex = Regex::new("^-?\d+(\.\d+)?$")
    .expect("Could not parse decimal validation regex");
  decimalRegex.is_match(number)
}

package main

import (
  "fmt"
  "regexp"
)

func isValidDecimal(number string) bool {
  decimalRegex := "^-?\d+(\.\d+)?$"
  re := regexp.MustCompile(decimalRegex)
  return re.MatchString(number)
}

import Foundation

func isValidDecimal(_ number: String) -> Bool {
  let decimalRegex = "^-?\d+(\.\d+)?$"
  return NSPredicate(format: "SELF MATCHES %@", decimalRegex).evaluate(with: number)
}

using System;
using System.Text.RegularExpressions;

class Application {
  static bool IsValidDecimal(string number) {
    string decimalRegex = "^-?\d+(\.\d+)?$";
    return Regex.IsMatch(number, decimalRegex);
  }
}

import java.util.regex.*;

public class Application {
  public static boolean isValidDecimal(String number) {
    String decimalRegex = "^-?\d+(\.\d+)?$";
    Pattern pattern = Pattern.compile(decimalRegex);
    Matcher matcher = pattern.matcher(number);
    return matcher.matches();
  }
}

<?php
function isValidDecimal($number) {
  $decimalRegex = "^-?\d+(\.\d+)?$";
  return (bool) preg_match("/" . $decimalRegex . "/", $number);
}
?>

Test Cases

Number	Valid
123
123.45
-456
-456.78
0
0.0
-0.5
1000000.999
abc
12a
(empty string)
+123.45
1,234.56
1 234.56
.5
123.
12.34.56

Notes

These patterns do not accept numbers with leading plus signs (+). Modify the pattern to ^[+-]?\\d+$ to allow both + and −.
Leading zeros are allowed (e.g., "0123" is valid). To disallow leading zeros, use a more complex pattern.
These patterns do not support scientific notation (e.g., 1.23e10). Use a different pattern for that format.
Thousands separators (commas, spaces) are not supported. Preprocess input to remove them if needed.
For positive-only numbers, use ^\\d+$ (integers) or ^\\d+(\\.\\d+)?$ (decimals).
These regex patterns validate format only. For range validation, use additional logic after regex matching.
For specialized number patterns, see: phone numbers, credit card numbers, social security numbers, ISBN, and ZIP codes.