Regulärer Ausdruck für übereinstimmende Breiten- / Längenkoordinaten?

Ich versuche, einen regulären Ausdruck für übereinstimmende Längen- / Breitenkoordinaten zu erstellen. Um eine doppelte Genauigkeitszahl zu finden, habe ich (\-?\d+(\.\d+)?) Verwendet und versucht, diese zu einem einzigen Ausdruck zu kombinieren:

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

Ich habe erwartet, dass dies einem Doppel, einem Komma, vielleicht etwas Platz und einem weiteren Doppel entspricht, aber es scheint nicht zu funktionieren. Insbesondere funktioniert es nur, wenn KEINE Leerzeichen vorhanden sind, nicht ein oder mehrere. Was habe ich falsch gemacht?

   

Whitespace ist \ s, nicht \ w

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

Sehen Sie, ob das funktioniert

Dieser Wert stimmt genau mit den Breiten- und Längenwerten überein, die in den richtigen Bereich fallen:

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

Streichhölzer

  • +90,0, -127,554334
  • 45, 180
  • -90, -180
  • -90.000, -180.0000
  • +90, +180
  • 47.1231231, 179.99999999

Stimmt nicht überein

  • -90., -180.
  • +90,1, -100,111
  • -91, 123,456
  • 045, 180

Ich benutze diese (Dezimalformat mit 6 Dezimalziffern):

Breite

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

Latitude Regulärer Ausdruck Visualisierung

Längengrad

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

Längengrad Regulärer Ausdruck Visualisierung


Hier ist ein core, der beide, hier berichtet, ebenfalls auf leichten Zugriff testet. Es ist ein Java TestNG Test. Sie benötigen Slf4j, Hamcrest und Lombok, um es auszuführen:

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

Eigentlich ist Alix Axel, oberhalb von Regex, in der geographischen Breite, Längengrad Sicht falsch.

Latitude Messungen reichen von -90 ° bis + 90 ° Longitude Messungen reichen von -180 ° bis + 180 °

Die unten angegebene Regex validiert genauer.
Meines Erachtens sollte niemand den Dezimalpunkt in Längen- und Breitengraden einschränken.

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

ODER für Ziel C

 ^([-+]?\\d{1,2}([.]\\d+)?),\\s*([-+]?\\d{1,3}([.]\\d+)?)$ 
 ^-?[0-9]{1,3}(?:\.[0-9]{1,10})?$ 

Regex-Aufteilung:

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

-? # Akzeptiere negative Werte

^ # Beginn der Zeichenfolge

[0-9]{1,3} # Übereinstimmung mit 1-3 Ziffern (dh 0-999)

(?: # Versuchen Sie es mit …

\. # ein Dezimalpunkt

[0-9]{1,10} # gefolgt von 1 bis 10 Ziffern (dh 0-9999999999)

)? # … optional

$ # Ende der Zeichenfolge

Versuche dies:

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

Schau es dir an:

http://regexpal.com/

Füge den Ausdruck in die obere Box ein und lege dann solche Dinge in die untere Box:

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

Regex-Aufteilung:

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

Nun, was dies NICHT tut, beschränkt sich auf diesen Bereich:

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

Stattdessen beschränkt es sich einfach auf diesen Bereich:

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

Aber es geht hauptsächlich darum, jedes Stück des Ausdrucks zu durchbrechen.

Hier ist eine strengere Version:

 ^([-+]?\d{1,2}[.]\d+),\s*([-+]?\d{1,3}[.]\d+)$ 
  • Breitengrad = -90+90
  • +180 = -180+180

Python:

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

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

Latitude sollte im Beispiel fehlschlagen.

Ich glaube, Sie verwenden \ w (Wortzeichen), wo Sie \ s (Leerzeichen) verwenden sollten. Word-Zeichen bestehen normalerweise aus [A-Za-z0-9_], so dass Ihr Leerzeichen ausgeschlossen wird, das dann nicht mit dem optionalen Minuszeichen oder einer Ziffer übereinstimmt.

das würde für ein Format wie folgt funktionieren: 31 ÷ 37.4 ‘E

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

@ Macro-Ferrari Ich habe einen Weg gefunden, um es zu verkürzen, und ohne Blick nach vorne im Lichte aller jüngsten Gespräche über Regex-Motoren

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

Bildbeschreibung hier eingeben

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

Bildbeschreibung hier eingeben

Ruby

Längengrad -179.99999999..180

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

Breitengrad -89.99999999..90

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

Sie können dies versuchen:

 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})?$/; 

Versuche dies:

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

Versuche dies:

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