Expresión regular de número decimal, donde el dígito después del decimal es opcional

Necesito una expresión regular que valide un número, pero no requiere un dígito después del decimal. es decir.

123
123.
123.4

todo sería válido

123..

sería inválido

¡Cualquiera sería muy apreciado!

Utilice lo siguiente:

/^\d*\.?\d*$/

• ^ - Comienzo de la línea;
• \d* - 0 o más dígitos;
• \.?- Un punto opcional (escapado, porque en regex, .es un carácter especial);
• \d* - 0 o más dígitos (la parte decimal);
• $ - Final de la línea.

Esto permite 0.5 decimal en lugar de requerir el cero inicial, como 0.5

/\d+\.?\d*/

Uno o más dígitos ( \d+), punto opcional ( \.?), cero o más dígitos ( \d*).

Dependiendo de su uso o motor de expresiones regulares, es posible que deba agregar anclajes de línea de inicio / fin:

/^\d+\.?\d*$/

Demostración de Debuggex

Necesita una expresión regular como la siguiente para hacerlo correctamente:

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

La misma expresión con espacios en blanco, usando el modificador extendido (compatible con Perl):

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

o con comentarios:

/^           # Beginning of string
 [+-]?       # Optional plus or minus character
 (           # Followed by either:
   (           #   Start of first option
     \d+       #   One or more digits
     (\.\d*)?  #   Optionally followed by: one decimal point and zero or more digits
   )           #   End of first option
   |           # or
   (\.\d+)     #   One decimal point followed by one or more digits
 )           # End of grouping of the OR options
 $           # End of string (i.e. no extra characters remaining)
 /x          # Extended modifier (allows whitespace & comments in regular expression)

Por ejemplo, coincidirá con:

• 123
• 23.45
• 34.
• .45
• -123
• -273,15
• -42.
• -.45
• +516
• +9,8
• +2.
• +.5

Y rechazará estos no números:

• . (punto decimal único)
• -. (punto decimal negativo)
• +. (más el punto decimal)
• (cuerda vacía)

Las soluciones más simples pueden rechazar incorrectamente números válidos o hacer coincidir estos no números.

Prueba esta expresión regular:

\d+\.?\d*

\ d + dígitos antes del decimal opcional
.? decimal opcional (opcional debido al cuantificador?)
\ d * dígitos opcionales después del decimal

Creo que este es el mejor porque cumple con todos los requisitos:

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

Terminé usando lo siguiente:

^\d*\.?\d+$

Esto invalida lo siguiente:

.
3.

puedes usar esto:

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

partidos:
11
11,1
0,2

no coincide:
.2
2.
2.6.9

¿Que lenguaje? En estilo Perl:^\d+(\.\d*)?$

Esto es lo que hice. Es más estricto que cualquiera de los anteriores (y más correcto que algunos):

^0$|^[1-9]\d*$|^\.\d+$|^0\.\d*$|^[1-9]\d*\.\d*$

Cuerdas que pasa:

0
0.
1
123
123.
123.4
.0
.0123
.123
0.123
1.234
12.34

Cuerdas que falla:

.
00000
01
.0.
..
00.123
02.134

^[+-]?(([1-9][0-9]*)?[0-9](\.[0-9]*)?|\.[0-9]+)$

debe reflejar lo que la gente suele considerar un número decimal bien formado.

Los dígitos antes del punto decimal pueden ser de un solo dígito, en cuyo caso puede ser de 0 a 9, o más de un dígito, en cuyo caso no puede comenzar con un 0.

Si hay dígitos antes del signo decimal, entonces el decimal y los dígitos siguientes son opcionales. De lo contrario, debe haber un decimal seguido de al menos un dígito. Tenga en cuenta que se permiten varios ceros finales después del punto decimal.

grep -E '^[+-]?(([1-9][0-9]*)?[0-9](\.[0-9]*)?|\.[0-9]+)$'

coincide correctamente con lo siguiente:

9
0
10
10.
0.
0.0
0.100
0.10
0.01
10.0
10.10
.0
.1
.00
.100
.001

así como sus equivalentes firmados, mientras que rechaza lo siguiente:

.
00
01
00.0
01.3

y sus equivalentes firmados, así como la cadena vacía.

(?<![^d])\d+(?:\.\d+)?(?![^d])

limpio y sencillo.

Esto utiliza características RegEx de sufijo y prefijo.

Devuelve directamente verdadero - falso para la condición IsMatch

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

Se me ocurrió esto. Permite tanto números enteros como decimales, pero fuerza un decimal completo (números iniciales y finales) si decide ingresar un decimal.

Lo que preguntaste ya está respondido, por lo que esta es solo una información adicional para aquellos que desean solo 2 dígitos decimales si se ingresa un punto decimal opcional:

^\d+(\.\d{2})?$

^: inicio de la cadena
\ d: un dígito (igual a [0-9])
+: uno y tiempos ilimitados

¿Grupo de captura (. \ D {2})?
? : cero y uno veces. : personaje .
\ d: un dígito (igual a [0-9])
{2}: exactamente 2 veces
$: final de la cadena

1: coincidencia
123: coincidencia
123.00: coincidencia
123.: no coincide
123 ...: no coincide
123.0: no coincide
123.000: no coincide
123.00.00: no coincide

En Perl, use Regexp :: Common que le permitirá ensamblar una expresión regular finamente ajustada para su formato de número particular. Si no está utilizando Perl, la expresión regular generada todavía puede ser utilizada por otros lenguajes.

Imprimir el resultado de generar las expresiones regulares de ejemplo en Regexp :: Common :: Number:

$ perl -MRegexp::Common=number -E 'say $RE{num}{int}'
(?:(?:[-+]?)(?:[0123456789]+))

$ perl -MRegexp::Common=number -E 'say $RE{num}{real}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789])(?:[0123456789]*)(?:(?:[.])(?:[0123456789]{0,}))?)(?:(?:[E])(?:(?:[-+]?)(?:[0123456789]+))|))

$ perl -MRegexp::Common=number -E 'say $RE{num}{real}{-base=>16}'
(?:(?i)(?:[-+]?)(?:(?=[.]?[0123456789ABCDEF])(?:[0123456789ABCDEF]*)(?:(?:[.])(?:[0123456789ABCDEF]{0,}))?)(?:(?:[G])(?:(?:[-+]?)(?:[0123456789ABCDEF]+))|))

prueba esto. ^[0-9]\d{0,9}(\.\d{1,3})?%?$está probado y funcionó para mí.