regex - test - validar expresiones regulares javascript

¿Expresión regular para coincidir coordenadas de latitud/longitud?

Question

Intento crear una expresión regular para unir coordenadas de latitud / longitud. Para hacer coincidir un número de precisión doble que he usado (/-?/d+(/./d+)?) , (/-?/d+(/./d+)?) intenté combinar eso en una sola expresión:

^(/-?/d+(/./d+)?),/w*(/-?/d+(/./d+)?)$

Esperaba que esto coincidiera con un doble, una coma, quizás un poco de espacio, y otro doble, pero parece que no funciona. Específicamente, solo funciona si no hay espacio, ni uno ni más. ¿Qué he hecho mal?

Answer 1

Éste ajustará estrictamente los valores de latitud y longitud que se encuentren dentro del rango correcto:

^[-+]?([1-8]?/d(/./d+)?|90(/.0+)?),/s*[-+]?(180(/.0+)?|((1[0-7]/d)|([1-9]?/d))(/./d+)?)$

Partidos

• +90.0, -127.554334
• 45, 180
• -90, -180
• -90.000, -180.0000
• +90, +180
• 47.1231231, 179.99999999

No coincide

• -90., -180.
• +90.1, -100.111
• -91, 123.456
• 045, 180

Answer 2

Aquí hay una versión más estricta:

^([-+]?/d{1,2}[.]/d+),/s*([-+]?/d{1,3}[.]/d+)$

• Latitud = -90 - +90
• Longitud = -180 - +180

Answer 3

Creo que estás usando / w (carácter de palabra) donde deberías estar usando / s (espacio en blanco). Los caracteres de Word normalmente constan de [A-Za-z0-9_], por lo que excluye su espacio, que luego no puede coincidir en el signo menos o un dígito opcional.

Answer 4

El espacio en blanco es / s, no / w

^(/-?/d+(/./d+)?),/s*(/-?/d+(/./d+)?)$

Mira si esto funciona

Answer 5

En realidad, Alix Axel, por encima de la expresión regular, está mal en el punto de vista de la latitud y la longitud.

Las mediciones de latitud oscilan entre -90 ° y + 90 ° Las mediciones de longitud oscilan entre -180 ° y + 180 °

Por lo tanto, la expresión regular dada a continuación valida con mayor precisión.
Además, según mi pensamiento, nadie debería restringir el punto decimal en latitud / longitud.

^([-+]?/d{1,2}([.]/d+)?),/s*([-+]?/d{1,3}([.]/d+)?)$

O para el objetivo C

^([-+]?//d{1,2}([.]//d+)?),//s*([-+]?//d{1,3}([.]//d+)?)$

Answer 6

Encontré una manera de acortarlo, y sin mirar a la luz de todas las conversaciones recientes sobre los motores de regex

const LAT_RE = /^[+-]?(([1-8]?[0-9])(/.[0-9]{1,6})?|90(/.0{1,6})?)$/;

const LONG_RE = /^[+-]?((([1-9]?[0-9]|1[0-7][0-9])(/.[0-9]{1,6})?)|180(/.0{1,6})?)$/;

Answer 7

Estoy usando estos (formato decimal, con 6 dígitos decimales):

Latitud

^(/+|-)?(?:90(?:(?:/.0{1,6})?)|(?:[0-9]|[1-8][0-9])(?:(?:/.[0-9]{1,6})?))$

Longitud

^(/+|-)?(?:180(?:(?:/.0{1,6})?)|(?:[0-9]|[1-9][0-9]|1[0-7][0-9])(?:(?:/.[0-9]{1,6})?))$

Here hay una esencia que prueba ambos, informados aquí también, para facilitar el acceso. Es una prueba Java TestNG. Necesita Slf4j, Hamcrest y Lombok para ejecutarlo:

import static org.hamcrest.Matchers.*;
import static org.hamcrest.MatcherAssert.*;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import lombok.extern.slf4j.Slf4j;
import org.testng.annotations.Test;
@Slf4j
public class LatLongValidationTest {
protected static final String LATITUDE_PATTERN="^(//+|-)?(?:90(?:(?://.0{1,6})?)|(?:[0-9]|[1-8][0-9])(?:(?://.[0-9]{1,6})?))$";
protected static final String LONGITUDE_PATTERN="^(//+|-)?(?:180(?:(?://.0{1,6})?)|(?:[0-9]|[1-9][0-9]|1[0-7][0-9])(?:(?://.[0-9]{1,6})?))$";
@Test
public void latitudeTest(){
DecimalFormat df = new DecimalFormat("#.######");
df.setRoundingMode(RoundingMode.UP);
double step = 0.01;
Double latitudeToTest = -90.0;
while(latitudeToTest <= 90.0){
boolean result = df.format(latitudeToTest).matches(LATITUDE_PATTERN);
log.info("Latitude: tested {}. Result (matches regex): {}", df.format(latitudeToTest), result);
assertThat(result, is(true));
latitudeToTest += step;
}
latitudeToTest = -90.1;
while(latitudeToTest >= -200.0){
boolean result = df.format(latitudeToTest).matches(LATITUDE_PATTERN);
log.info("Latitude: tested {}. Result (matches regex): {}", df.format(latitudeToTest), result);
assertThat(result, is(false));
latitudeToTest -= step;
}
latitudeToTest = 90.01;
while(latitudeToTest <= 200.0){
boolean result = df.format(latitudeToTest).matches(LATITUDE_PATTERN);
log.info("Latitude: tested {}. Result (matches regex): {}", df.format(latitudeToTest), result);
assertThat(result, is(false));
latitudeToTest += step;
}
}
@Test
public void longitudeTest(){
DecimalFormat df = new DecimalFormat("#.######");
df.setRoundingMode(RoundingMode.UP);
double step = 0.01;
Double longitudeToTest = -180.0;
while(longitudeToTest <= 180.0){
boolean result = df.format(longitudeToTest).matches(LONGITUDE_PATTERN);
log.info("Longitude: tested {}. Result (matches regex): {}", df.format(longitudeToTest), result);
assertThat(result, is(true));
longitudeToTest += step;
}
longitudeToTest = -180.01;
while(longitudeToTest >= -300.0){
boolean result = df.format(longitudeToTest).matches(LONGITUDE_PATTERN);
log.info("Longitude: tested {}. Result (matches regex): {}", df.format(longitudeToTest), result);
assertThat(result, is(false));
longitudeToTest -= step;
}
longitudeToTest = 180.01;
while(longitudeToTest <= 300.0){
boolean result = df.format(longitudeToTest).matches(LONGITUDE_PATTERN);
log.info("Longitude: tested {}. Result (matches regex): {}", df.format(longitudeToTest), result);
assertThat(result, is(false));
longitudeToTest += step;
}
}
}

Answer 8

Pitón:

Latitude: result = re.match("^[+-]?((90/.?0*$)|(([0-8]?[0-9])/.?[0-9]*$))", ''-90.00001'')

Longitud: result = re.match("^[+-]?((180/.?0*$)|(((1[0-7][0-9])|([0-9]{0,2}))/.?[0-9]*$))", ''-0.0000'')

Latitude debe fallar en el ejemplo.

Answer 9

Prueba esto:

(?<!/d)([-+]?(?:[1-8]?/d(?:/./d+)?|90(?:/.0+)?)),/s*([-+]?(?:180(?:/.0+)?|(?:(?:1[0-7]/d)|(?:[1-9]?/d))(?:/./d+)?))(?!/d)`

Answer 10

Prueba esto:

^(/()([-+]?)([/d]{1,2})(((/.)(/d+)(,)))(/s*)(([-+]?)([/d]{1,3})((/.)(/d+))?(/)))$

Compruébalo en:

http://regexpal.com/

Pegue la expresión en el cuadro superior, luego coloque cosas como esta en el cuadro inferior:

(80.0123, -34.034)
(80.0123)
(80.a)
(980.13, 40)
(99.000, 122.000)

Desglose de Regex:

^ # The string must start this way (there can''t be anything before).
(/() # An opening parentheses (escaped with a backslash).
([-+]?) # An optional minus, or an optional plus.
([/d]{1,2}) # 1 or 2 digits (0-9).
( # Start of a sub-pattern.
( # Start of a sub-pattern.
(/.) # A dot (escaped with a backslash).
(/d+) # One or more digits (0-9).
(,) # A comma.
) # End of a sub-pattern.
) # End of a sub-pattern.
(/s*) # Zero or more spaces.
( # Start of a sub-pattern.
([-+]?) # An optional minus, or an optional plus.
([/d]{1,3}) # 1 to 3 digits (0-9).
( # Start of a pattern.
(/.) # A dot (escaped with a backslash).
(/d+) # One or more digits (0-9).
)? # End of an optional pattern.
(/)) # A closing parenthesis (escaped with a backkslash).
) # End of a pattern
$ # The string must end this way (there can''t be anything after).

Ahora, lo que NO hace es restringirse a este rango:

(-90 to +90, and -180 to +180)

En cambio, simple se restringe a este rango:

(-99 to +99, -199 to +199)

Pero el objetivo principal es simplemente desglosar cada parte de la expresión.

Answer 11

Prueba esto:

^[-+]?(([0-8]//d|//d)(//.//d+)?|90(//.0+)?)$,/s*^[-+]?((1[0-7]//d(//.//d+)?)|(180(//.0+)?)|(//d//d(//.//d+)?)|(//d(//.//d+)?))$

Answer 12

Puedes intentar esto:

var latExp = /^(?=.)-?((8[0-5]?)|([0-7]?[0-9]))?(?:/.[0-9]{1,20})?$/;
var lngExp = /^(?=.)-?((0?[8-9][0-9])|180|([0-1]?[0-7]?[0-9]))?(?:/.[0-9]{1,20})?$/;

Answer 13

esto funcionaría para un formato como este: 31 ͦ 37.4 ''E

^ [-]? / d {1,2} [] ͦ [] / d {1,2}.? / d {1,2} [] / x27 [] / w $

Answer 14

Rubí

Longitud -179.99999999..180

/^(-?(?:1[0-7]|[1-9])?/d(?:/./d{1,8})?|180(?:/.0{1,8})?)$/ === longitude.to_s

Latitude -89.99999999..90

/^(-?[1-8]?/d(?:/./d{1,8})?|90(?:/.0{1,8})?)$/ === latitude.to_s

Answer 15

/(-?/d{1,2}[.]/d+)(?U:.*)(-?1?[0-8]?/d[.]/d+)/

Answer 16

^-?[0-9]{1,3}(?:/.[0-9]{1,10})?$

Desglose de Regex:

^-?[0-9]{1,3}(?:/.[0-9]{1,10})?$

-? # aceptar valores negativos

^ # Inicio de cadena

[0-9]{1,3} # Coincide con 1-3 dígitos (es decir, 0-999)

(?: # Intenta hacer coincidir ...

/. # un punto decimal

[0-9]{1,10} # seguido de uno a 10 dígitos (es decir, 0-9999999999)

)? # ... opcionalmente

$ # Fin de la cadena