Регулярное выражение для соответствия координат широты/долготы?

Я пытаюсь создать регулярное выражение для соответствия координат широты/долготы. Для сопоставления числа с двойной точностью я использовал (\-?\d+(\.\d+)?) и попытался объединить это в одно выражение:

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

Я ожидал, что это будет соответствовать двойной, запятой, возможно, некоторым пространством и еще одним двойником, но, похоже, это не работает. В частности, он работает только в том случае, если нет места, а не одного или более. Что я сделал неправильно?

Ответ 1

Пробел -\s, не \w

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

Посмотрите, работает ли это

Ответ 2

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

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

соответствий

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

Не соответствует

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

Ответ 3

Я использую эти (десятичный формат с шестью десятичными цифрами):

Широта

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

Долгота

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

Здесь - это суть, которая также проверяет и то, и другое, для удобства доступа. Это тест Java TestNG. Вам нужны Slf4j, Hamcrest и Lombok для запуска:

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

Ответ 4

На самом деле Аликс Аксель, выше регулярного выражения, ошибочен в широте, долготе диапазонов точки зрения.

Измерения широты варьируются от -90 ° до + 90 ° Измерения долготы варьируются от -180 ° до + 180 °

Итак, приведенное ниже регулярное выражение проверяет более точно.
Кроме того, согласно моей мысли, никто не должен ограничивать десятичную точку в широте/долготе.

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

ИЛИ для Objective C

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

Ответ 5

Вот более строгая версия:

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

Широта = -90 - +90
Долгота = -180 - +180

Ответ 6

Попробуйте следующее:

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

Проверьте это:

http://regexpal.com/

Вставьте выражение в верхнем поле, затем в нижнем поле введите такие вещи:

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

Распределение регулярных выражений:

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

Теперь, что это НЕ делает, ограничивается этим диапазоном:

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

Вместо этого он просто ограничивается этим диапазоном:

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

Но точка в основном состоит только в том, чтобы разбить каждую часть выражения.

Ответ 7

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

Распределение регулярных выражений:

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

-? # принимать отрицательные значения

^ # Начало строки

[0-9]{1,3} # Сопоставление 1-3 цифр (например, 0-999)

(?: # Попробуйте сопоставить...

\. # десятичная точка

[0-9]{1,10} #, за которым следует от 1 до 10 цифр (например, 0-9999999999)

)? #... дополнительно

$ # Конец строки

Ответ 8

Python:

Широта: result = re.match("^[+-]?((90\.?0*$)|(([0-8]?[0-9])\.?[0-9]*$))", '-90.00001')

Долгота: result = re.match("^[+-]?((180\.?0*$)|(((1[0-7][0-9])|([0-9]{0,2}))\.?[0-9]*$))", '-0.0000')

Локатор в этом случае не работает.

Ответ 9

Я считаю, что вы используете \w (символ слова), где вы должны использовать \s (пробелы). Символы Word обычно состоят из [A-Za-z0-9_], поэтому исключает ваше пространство, которое затем не может совпадать с необязательным знаком "минус" или цифрой.

Ответ 10

это будет работать в таком формате: 31 ͦ 37.4 'E

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

Ответ 11

рубин

Долгота -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

Ответ 12

Вы можете попробовать следующее:

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

Ответ 13

Попробуйте следующее:

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

Ответ 14

Попробуйте следующее:

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

Ответ 15

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