Вот моя лучшая попытка. Он поддерживает форматы, указанные выше, но я уверен, что мне не хватает других возможных форматов.

^\d?(?:(?:[\+]?(?:[\d]{1,3}(?:[ ]+|[\-.])))?[(]?(?:[\d]{3})[\-/)]?(?:[ ]+)?)?(?:[a-zA-Z2-9][a-zA-Z0-9 \-.]{6,})(?:(?:[ ]+|[xX]|(i:ext[\.]?)){1,2}(?:[\d]{1,5}))?$

Вы видели RegExLib?

Ввод номера телефона в США вернул целый список возможностей.

Оказывается, для этого есть что-то вроде спецификации, по крайней мере для Северной Америки, которая называется NANP.

Вам нужно указать именно то, что вы хотите. Что такое юридические разделители? Пробелы, тире и точки? Без разделителя? Можно ли смешивать разделители (например, + 0.111-222.3333)? Как будут обрабатываться расширения (например, 111-222-3333 x 44444)? А как насчет специальных номеров, например 911? Будет ли код города быть необязательным или обязательным?

Вот регулярное выражение для 7- или 10-значного числа с разрешенными расширениями, разделителями являются пробелы, тире или точки:

^(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?$

Лучший вариант ... просто удалите все нецифровые символы при вводе (кроме знаков 'x' и ведущих '+'), заботясь о британской тенденции писать числа в нестандартной форме +44 (0) ..., когда их просят использовать международный префикс (в этом конкретном случае вы должны полностью отказаться от (0)).

Тогда вы получите такие значения, как:

 12345678901
 12345678901x1234
 345678901x1234
 12344678901
 12345678901
 12345678901
 12345678901
 +4112345678
 +441234567890

Затем, когда вы отображаете, переформатируйте, как вам нравится. например

  1 (234) 567-8901
  1 (234) 567-8901 x1234

Я работаю в компании по исследованию рынка, и нам приходится фильтровать эти типы входных данных все время. Вы слишком усложняете это. Просто удалите не буквенно-цифровые символы и посмотрите, есть ли расширение.

Для дальнейшего анализа вы можете подписаться на одного из многих провайдеров, который предоставит вам доступ к базе данных действительных номеров, а также сообщит вам, стационарные они или мобильные, отключены и т. д. Это стоит денег.

Если это вообще возможно, я бы рекомендовал иметь четыре отдельных поля - код города, 3-значный префикс, 4-значная часть, расширение - чтобы пользователь мог вводить каждую часть адреса отдельно, и вы могли проверить каждую часть индивидуально. Таким образом, вы можете не только упростить проверку, но и сохранить свои номера телефонов в базе данных в более согласованном формате.

Вам будет сложно работать с международными номерами с помощью одного / простого регулярного выражения, см. эта почта о трудностях международных (и даже североамериканских) телефонных номеров.

Вам нужно проанализировать первые несколько цифр, чтобы определить код страны, а затем действовать по-разному в зависимости от страны.

Помимо этого - список, который вы предоставили, не включает другой распространенный в США формат - исключая начальную цифру 1. Большинство сотовых телефонов в США не требуют этого, и это начнет сбивать с толку молодое поколение, если они не наберут номер на международном уровне.

Вы правильно определили, что это сложная проблема ...

-Адам

Я считаю, что модули Perl Номер :: Телефон :: США и Regexp :: Common (особенно источник Regexp :: Common :: URI :: RFC2806) могут помочь.

Вопрос, вероятно, следует задать более подробно, чтобы объяснить цель проверки чисел. Например, 911 - допустимый номер в США, но 911x не для любого значения x. Это необходимо для того, чтобы телефонная компания могла рассчитать, когда вы закончите набор номера. Есть несколько вариантов этого вопроса. Но ваше регулярное выражение не проверяет часть кода области, так что это не вызывает беспокойства.

Как и при проверке адресов электронной почты, даже если у вас есть действительный результат, вы не можете узнать, назначен ли он кому-то, пока не попробуете.

Если вы пытаетесь проверить вводимые пользователем данные, почему бы не нормализовать результат и не покончить с этим? Если пользователь вводит число, которое вы не можете распознать как действительное, либо сохраните его как введенное, либо удалите недопустимые символы. Модуль Номер :: Телефон :: Нормализовать Perl может стать источником вдохновения.

Хотя ответ на удаление всех пробелов прост, на самом деле он не решает поставленную проблему, а именно найти регулярное выражение. Возьмем, к примеру, мой тестовый скрипт, который загружает веб-страницу и извлекает все номера телефонов с помощью регулярного выражения. Поскольку вам в любом случае понадобится регулярное выражение, вы также можете заставить регулярное выражение делать всю работу. Я придумал это:

1?\W*([2-9][0-8][0-9])\W*([2-9][0-9]{2})\W*([0-9]{4})(\se?x?t?(\d*))?

Вот скрипт на Perl для его проверки. При совпадении $ 1 содержит код города, $ 2 и $ 3 - номер телефона, а $ 5 - расширение. Мой тестовый сценарий загружает файл из Интернета и печатает в нем все телефонные номера.

#!/usr/bin/perl

my $us_phone_regex =
        '1?\W*([2-9][0-8][0-9])\W*([2-9][0-9]{2})\W*([0-9]{4})(\se?x?t?(\d*))?';


my @tests =
(
"1-234-567-8901",
"1-234-567-8901 x1234",
"1-234-567-8901 ext1234",
"1 (234) 567-8901",
"1.234.567.8901",
"1/234/567/8901",
"12345678901",
"not a phone number"
);

foreach my $num (@tests)
{
        if ( $num =~ m/$us_phone_regex/ )
        {
                print "match [--]\n" if not defined ;
                print "match [-- ]\n" if defined ;
        }
        else
        {
                print "no match [$num]\n";
        }
}

#
# Extract all phone numbers from an arbitrary file.
#
my $external_filename =
        'http://web.textfiles.com/ezines/PHREAKSANDGEEKS/PnG-spring05.txt';
my @external_file = `curl $external_filename`;
foreach my $line (@external_file)
{
        if ( $line =~ m/$us_phone_regex/ )
        {
                print "match   \n";
        }
}

Редактировать:

Вы можете изменить \ W * на \ s * \ W? \ S * в регулярном выражении, чтобы немного его сжать. Я не думал о регулярном выражении с точки зрения, скажем, проверки пользовательского ввода в форме, когда я его писал, но это изменение позволяет использовать регулярное выражение для этой цели.

'1?\s*\W?\s*([2-9][0-8][0-9])\s*\W?\s*([2-9][0-9]{2})\s*\W?\s*([0-9]{4})(\se?x?t?(\d*))?';

Я склонен согласиться с тем, что убирать нецифровые числа и просто принимать то, что там лучше. Может быть, чтобы убедиться, что присутствует хотя бы пара цифр, хотя это запрещает что-то вроде буквенного телефонного номера, например, «ASK-JAKE».

Вот пара простых выражений Perl:

@f = /(\d+)/g;
tr/0-9//dc;

Используйте первый, чтобы держать группы цифр вместе, что может дать подсказки форматирования. Используйте второй, чтобы тривиально отбросить все нецифровые.

Беспокоит ли это, что может потребоваться пауза, а затем ввести еще несколько ключей? Или что-то вроде 555-1212 (ждите гудка) 123?

Если вы говорите о проверке формы, регулярное выражение для проверки правильного значения, а также правильных данных будет чрезвычайно сложным из-за различных стандартов страны и поставщиков. Также будет сложно идти в ногу со временем.

Я интерпретирую вопрос как поиск в целом допустимого шаблона, который может быть внутренне непротиворечивым - например, имеющий действительный набор чисел, но не подтверждающий, что магистральная линия, обмен и т. д. Соответствует действительному шаблону для префикса кода страны .

Северная Америка проста, и для международного общения я предпочитаю использовать «идиоматический» шаблон, который охватывает способы, которыми люди указывают и запоминают свои номера:

^((((\(\d{3}\))|(\d{3}-))\d{3}-\d{4})|(\+?\d{2}((-| )\d{1,8}){1,5}))(( x| ext)\d{1,5}){0,1}$

Североамериканский паттерн гарантирует, что при включении одной круглой скобки будут включены обе. Для международных счетов необязательный начальный знак "+" и код страны. После этого вы в идиоме. Допустимые совпадения:

• (xxx)xxx-xxxx
• (xxx)-xxx-xxxx
• (xxx)xxx-xxxx x123
• 12 1234 123 1 x1111
• 12 12 12 12 12
• 12 1 1234 123456 x12345
• +12 1234 1234
• +12 12 12 1234
• +12 1234 5678
• +12 12345678

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

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

В худшем случае, если бы пользователю приходилось извлекать неформатированный номер из XML-файла, он все равно просто вводил бы цифры в цифровую клавиатуру телефона 012345678x5, и это не было реальной причиной для того, чтобы сохранять его красивым. Такой тип RegEx выйдет для меня примерно так:

\d+ ?\w{0,9} ?\d+

• 01234467 extension 123456
• 01234567x123456
• 01234567890

Замените символы форматирования, затем проверьте оставшиеся на соответствие телефону. В PHP

 $replace = array( ' ', '-', '/', '(', ')', ',', '.' ); //etc; as needed
 preg_match( '/1?[0-9]{10}((ext|x)[0-9]{1,4})?/i', str_replace( $replace, '', $phone_num );

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

.*

Если пользователи хотят дать вам свои номера телефонов, доверьте им это правильно. Если они не хотят отдавать его вам, то принуждение их к вводу действительного числа либо отправит их на сайт конкурента, либо заставит их ввести случайную строку, которая соответствует вашему регулярному выражению. У меня даже может возникнуть соблазн поискать номер горячей линии по гороскопам премиум-класса и вместо этого ввести его.

Я также считаю, что любая из следующих записей на веб-сайте является допустимой:

"123 456 7890 until 6pm, then 098 765 4321"  
"123 456 7890 or try my mobile on 098 765 4321"  
"ex-directory - mind your own business"

Я писал проще всего (хотя точки мне в нем не понадобились).

^([0-9\(\)/\+ \-]*)$

Как упоминалось ниже, он проверяет только символы, а не их структуру / порядок.

Обратите внимание, что удаление символов () не работает для стандартного стиля написания британских номеров: +44 (0) 1234 567890, что означает набор международного номера:
. +441234567890
или в Великобритании наберите 01234567890

Я нашел это кое-что интересным. Я не тестировал, но похоже, что это сработает

<?php
/*
string validate_telephone_number (string $number, array $formats)
*/

function validate_telephone_number($number, $formats)
{
$format = trim(ereg_replace("[0-9]", "#", $number));

return (in_array($format, $formats)) ? true : false;
}

/* Usage Examples */

// List of possible formats: You can add new formats or modify the existing ones

$formats = array('###-###-####', '####-###-###',
                 '(###) ###-###', '####-####-####',
                 '##-###-####-####', '####-####', '###-###-###',
                 '#####-###-###', '##########');

$number = '08008-555-555';

if (validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '123-555-555';

if (validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '1800-1234-5678';

if (validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '(800) 555-123';

if (validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}

echo "<br />";

$number = '1234567890';

if (validate_telephone_number($number, $formats))
{
echo $number.' is a valid phone number.';
}
?>

    pattern = "^[\d|\+|\(]+[\)|\d|\s|-]*[\d]$" 
    validateat = "onsubmit"

Должен заканчиваться цифрой, может начинаться с (или + или цифры, и может содержать + - (или)

Мое чутье подкрепляется количеством ответов на эту тему - что существует практически бесконечное количество решений этой проблемы, ни одно из которых не будет элегантным.

Честно говоря, я бы порекомендовал вам не пытаться проверять номера телефонов. Даже если бы вы могли написать большой и сложный валидатор, который разрешал бы все различные допустимые форматы, он в конечном итоге разрешил бы практически все, даже отдаленно напоминающее номер телефона.

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

Для всех, кто хочет сделать что-то подобное с ирландскими номерами мобильных телефонов, вот простой способ сделать это:

http://ilovenicii.com/?p=87

PHP

<?php
$pattern = "/^(083|086|085|086|087)\d{7}$/";
$phone = "087343266";

if (preg_match($pattern,$phone)) echo "Match";
else echo "Not match";

По этой ссылке также есть решение JQuery.

Обновлено:

Решение jQuery:

    $(function(){
    //original field values
    var field_values = {
            //id        :  value
            'url'       : 'url',
            'yourname'  : 'yourname',
            'email'     : 'email',
            'phone'     : 'phone'
    };

        var url =$("input#url").val();
        var yourname =$("input#yourname").val();
        var email =$("input#email").val();
        var phone =$("input#phone").val();


    //inputfocus
    $('input#url').inputfocus({ value: field_values['url'] });
    $('input#yourname').inputfocus({ value: field_values['yourname'] });
    $('input#email').inputfocus({ value: field_values['email'] }); 
    $('input#phone').inputfocus({ value: field_values['phone'] });



    //reset progress bar
    $('#progress').css('width','0');
    $('#progress_text').html('0% Complete');

    //first_step
    $('form').submit(function(){ return false; });
    $('#submit_first').click(function(){
        //remove classes
        $('#first_step input').removeClass('error').removeClass('valid');

        //ckeck if inputs aren't empty
        var fields = $('#first_step input[type=text]');
        var error = 0;
        fields.each(function(){
            var value = $(this).val();
            if ( value.length<12 || value==field_values[$(this).attr('id')] ) {
                $(this).addClass('error');
                $(this).effect("shake", { times:3 }, 50);

                error++;
            } else {
                $(this).addClass('valid');
            }
        });        

        if (!error) {
            if ( $('#password').val() != $('#cpassword').val() ) {
                    $('#first_step input[type=password]').each(function(){
                        $(this).removeClass('valid').addClass('error');
                        $(this).effect("shake", { times:3 }, 50);
                    });

                    return false;
            } else {   
                //update progress bar
                $('#progress_text').html('33% Complete');
                $('#progress').css('width','113px');

                //slide steps
                $('#first_step').slideUp();
                $('#second_step').slideDown();     
            }               
        } else return false;
    });

    //second section
    $('#submit_second').click(function(){
        //remove classes
        $('#second_step input').removeClass('error').removeClass('valid');

        var emailPattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;  
        var fields = $('#second_step input[type=text]');
        var error = 0;
        fields.each(function(){
            var value = $(this).val();
            if ( value.length<1 || value==field_values[$(this).attr('id')] || ( $(this).attr('id')=='email' && !emailPattern.test(value) ) ) {
                $(this).addClass('error');
                $(this).effect("shake", { times:3 }, 50);

                error++;
            } else {
                $(this).addClass('valid');
            }


        function validatePhone(phone) {
        var a = document.getElementById(phone).value;
        var filter = /^[0-9-+]+$/;
            if (filter.test(a)) {
                return true;
            }
            else {
                return false;
            }
        }

        $('#phone').blur(function(e) {
            if (validatePhone('txtPhone')) {
                $('#spnPhoneStatus').html('Valid');
                $('#spnPhoneStatus').css('color', 'green');
            }
            else {
                $('#spnPhoneStatus').html('Invalid');
            $('#spnPhoneStatus').css('color', 'red');
            }
        });

     });

        if (!error) {
                //update progress bar
                $('#progress_text').html('66% Complete');
                $('#progress').css('width','226px');

                //slide steps
                $('#second_step').slideUp();
                $('#fourth_step').slideDown();     
        } else return false;

    });


    $('#submit_second').click(function(){
        //update progress bar
        $('#progress_text').html('100% Complete');
        $('#progress').css('width','339px');

        //prepare the fourth step
        var fields = new Array(
            $('#url').val(),
            $('#yourname').val(),
            $('#email').val(),
            $('#phone').val()

        );
        var tr = $('#fourth_step tr');
        tr.each(function(){
            //alert( fields[$(this).index()] )
            $(this).children('td:nth-child(2)').html(fields[$(this).index()]);
        });

        //slide steps
        $('#third_step').slideUp();
        $('#fourth_step').slideDown();            
    });


    $('#submit_fourth').click(function(){

        url =$("input#url").val();
        yourname =$("input#yourname").val();
        email =$("input#email").val();
        phone =$("input#phone").val();

        //send information to server
        var dataString = 'url='+ url + '&yourname=' + yourname + '&email=' + email + '&phone=' + phone;  



        alert (dataString);//return false;  
            $.ajax({  
                type: "POST",  
                url: "http://clients.socialnetworkingsolutions.com/infobox/contact/",  
                data: "url = "+url+"&yourname = "+yourname+"&email = "+email+'&phone=' + phone,
                cache: false,
                success: function(data) {  
                    console.info("form submitted");
                    alert("success");
                }
                });  
        return false;

   });


    //back button
    $('.back').click(function(){
        var container = $(this).parent('div'),
        previous  = container.prev();

        switch(previous.attr('id')) {
            case 'first_step' : $('#progress_text').html('0% Complete');
                  $('#progress').css('width','0px');
                       break;
            case 'second_step': $('#progress_text').html('33% Complete');
                  $('#progress').css('width','113px');
                       break;

            case 'third_step' : $('#progress_text').html('66% Complete');
                  $('#progress').css('width','226px');
                       break;

        default: break;
    }

    $(container).slideUp();
    $(previous).slideDown();
});


});

Источник.

Вам, вероятно, будет лучше использовать для этого маскированный ввод. Таким образом, пользователи могут вводить ТОЛЬКО числа, а вы можете форматировать их так, как считаете нужным. Я не уверен, что это для веб-приложения, но если это так, есть плагин jQuery, который предлагает несколько вариантов для этого.

http://digitalbush.com/projects/masked-input-plugin/

В своем руководстве они даже рассказывают, как маскировать ввод номера телефона.

Это простой шаблон регулярного выражения для филиппинских номеров мобильных телефонов:

((\+[0-9]{2})|0)[.\- ]?9[0-9]{2}[.\- ]?[0-9]{3}[.\- ]?[0-9]{4}

или же

((\+63)|0)[.\- ]?9[0-9]{2}[.\- ]?[0-9]{3}[.\- ]?[0-9]{4}

будет соответствовать этим:

+63.917.123.4567  
+63-917-123-4567  
+63 917 123 4567  
+639171234567  
09171234567  

Первый будет соответствовать ЛЮБОМУ двузначному коду страны, а второй - исключительно коду страны Филиппин.

Протестируйте здесь: http://refiddle.com/1ox

Моя попытка неограниченного регулярного выражения:

/^[+#*\(\)\[\]]*([0-9][ ext+-pw#*\(\)\[\]]*){6,45}$/

Принимает:

+(01) 123 (456) 789 ext555
123456
*44 123-456-789 [321]
123456
123456789012345678901234567890123456789012345
*****++[](][((( 123456tteexxttppww

Отклоняет:

mob 07777 777777
1234 567 890 after 5pm
john smith
(empty)
1234567890123456789012345678901234567890123456
911

Вы должны очистить его для отображения. Однако после проверки мог будет числом.

Вот тот, который хорошо работает в JavaScript. Это строка, потому что это то, чего ожидал виджет Dojo.

Он соответствует 10-значному номеру NANP для Северной Америки с дополнительным расширением. В качестве разделителей принимаются пробелы, тире и точки.

"^(\(?\d\d\d\)?)( |-|\.)?\d\d\d( |-|\.)?\d{4,4}(( |-|\.)?[ext\.]+ ?\d+)?$"

Если вы просто хотите убедиться, что у вас нет случайного мусора в поле (то есть от спамеров форм), это регулярное выражение должно работать хорошо:

^[0-9+\(\)#\.\s/ext-]+$

Обратите внимание, что у него нет каких-либо специальных правил относительно того, сколько цифр или какие числа допустимы в этих цифрах, он просто проверяет, что только цифры, круглые скобки, тире, плюс, пробел, фунт, звездочка, точка, запятая или буквы e, x, t присутствуют.

Он должен быть совместим с международными номерами и форматами локализации. Предвидите ли вы необходимость разрешить использование квадратных, фигурных или угловых скобок для некоторых регионов? (в настоящее время они не включены).

Если вы хотите поддерживать правила для каждой цифры (например, в кодах регионов США и префиксах (коды обмена) должны находиться в диапазоне 200-999), удачи вам. Поддерживать сложный набор правил, который в любой момент в будущем может устареть в любой стране мира, не звучит весело.

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

Я бы не рекомендовал использовать для этого регулярное выражение.

Как и в верхнем ответе, удалите все безобразия из номера телефона, чтобы у вас осталась строка числовых символов с 'x', если есть расширения.

В Python:

Примечание. BAD_AREA_CODES поступает от текстовый файл, который вы можете получить в Интернете.

BAD_AREA_CODES = open('badareacodes.txt', 'r').read().split('\n')

def is_valid_phone(phone_number, country_code='US'):
    """for now, only US codes are handled"""
    if country_code:
        country_code = country_code.upper()

    #drop everything except 0-9 and 'x'
    phone_number = filter(lambda n: n.isdigit() or n == 'x', phone_number)

    ext = None
    check_ext = phone_number.split('x')
    if len(check_ext) > 1:
        #there's an extension. Check for errors.
        if len(check_ext) > 2:
            return False
        phone_number, ext = check_ext

    #we only accept 10 digit phone numbers.
    if len(phone_number) == 11 and phone_number[0] == '1':
        #international code
        phone_number = phone_number[1:]
    if len(phone_number) != 10:
        return False

    #area_code: XXXxxxxxxx 
    #head:      xxxXXXxxxx
    #tail:      xxxxxxXXXX
    area_code = phone_number[ :3]
    head      = phone_number[3:6]
    tail      = phone_number[6: ]

    if area_code in BAD_AREA_CODES:
        return False
    if head[0] == '1':
        return False
    if head[1:] == '11':
        return False

    #any other ideas?
    return True

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

Я также предлагаю взглянуть на библиотеку Google "libphonenumber". Я знаю, что это не регулярное выражение, но оно делает именно то, что вы хотите.

Например, он распознает, что:

15555555555

- возможное число, но не действительное. Он также поддерживает страны за пределами США.

Основные функциональные возможности:

• Разбор / форматирование / проверка телефонных номеров для всех стран / регионов мира.
• getNumberType - получает тип номера исходя из самого номера; возможность различать фиксированные, мобильные, бесплатные, платные, общие, VoIP и личные номера (когда это возможно).
• isNumberMatch - получает уровень уверенности в том, могут ли два числа быть одинаковыми.
• getExampleNumber / getExampleNumberByType - предоставляет действительные примеры номеров для всех стран / регионов с возможностью указания типа необходимого примера телефонного номера.
• isPossibleNumber - быстрое угадывание того, является ли номер возможным телефонным номером, используя только информацию о длине, намного быстрее, чем полная проверка.
• isValidNumber - полная проверка телефонного номера для региона с использованием информации о длине и префиксе.
• AsYouTypeFormatter - форматирует телефонные номера на лету, когда пользователи вводят каждую цифру.
• findNumbers - находит числа при вводе текста.
• PhoneNumberOfflineGeocoder - предоставляет географическую информацию, относящуюся к номеру телефона.

Примеры

Самая большая проблема с подтверждением номера телефона - это культурная зависимость.

• Америка
  • (408) 974–2042 - это номер действительный в США.
  • (999) 974–2042 - это номер не действительный в США.
• Австралия
  • 0404 999 999 - австралийский номер действительный.
  • (02) 9999 9999 также является австралийским номером действительный.
  • (09) 9999 9999 - австралийский номер не действительный.

Регулярное выражение подходит для проверки формата номера телефона, но на самом деле оно не сможет проверить период действия номера телефона.

Я бы посоветовал пропустить простое регулярное выражение для проверки вашего номера телефона и использовать такую ​​библиотеку, как Google libphonenumber (ссылка на проект GitHub).

Представляем libphonenumber!

Используя один из ваших более сложных примеров, 1-234-567-8901 x1234, вы получите следующие данные из libphonenumber (ссылка на онлайн-демонстрацию):

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     true

Formatting Results:

E164 format                    +12345678901
Original format                (234) 567-8901 ext. 123
National format                (234) 567-8901 ext. 123
International format           +1 234-567-8901 ext. 123
Out-of-country format from US  1 (234) 567-8901 ext. 123
Out-of-country format from CH  00 1 234-567-8901 ext. 123

Таким образом, вы не только узнаете, действителен ли номер телефона (что он есть), но и получите согласованное форматирование номера телефона в вашем регионе.

В качестве бонуса libphonenumber также имеет ряд наборов данных для проверки действительности телефонных номеров, поэтому проверка номера, такого как +61299999999 (международная версия (02) 9999 9999), возвращается как действительное число с форматированием:

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     true

Formatting Results

E164 format                    +61299999999
Original format                61 2 9999 9999
National format                (02) 9999 9999
International format           +61 2 9999 9999
Out-of-country format from US  011 61 2 9999 9999
Out-of-country format from CH  00 61 2 9999 9999

libphonenumber также дает вам много дополнительных преимуществ, таких как захват местоположения, в котором определен номер телефона, а также получение информации о часовом поясе из номера телефона:

PhoneNumberOfflineGeocoder Results
Location        Australia

PhoneNumberToTimeZonesMapper Results
Time zone(s)    [Australia/Sydney]

Но неверный австралийский номер телефона ((09) 9999 9999) возвращает, что это не действительный номер телефона.

Validation Results

Result from isPossibleNumber()  true
Result from isValidNumber()     false

В версии Google есть код для Java и Javascript, но люди также внедрили библиотеки для других языков, которые используют набор данных телефонных номеров Google i18n:

• PHP: https://github.com/giggsey/libphonenumber-for-php
• Python: https://github.com/daviddrysdale/python-phonenumbers
• Рубин: https://github.com/sstephenson/global_phone
• C#: https://github.com/twcclegg/libphonenumber-csharp
• Цель-C: https://github.com/iziz/libPhoneNumber-iOS
• JavaScript: https://github.com/ruimarinho/google-libphonenumber
• Эликсир: https://github.com/socialpaymentsbv/ex_phone_number

Если вы не уверены, что всегда будете принимать номера из одной локали, и они всегда будут в одном формате, я настоятельно рекомендую не писать для этого свой собственный код и использовать libphonenumber для проверки и отображения номеров телефонов.

/^(?:(?:\(?(?:00|\+)([1-4]\d\d|[1-9]\d?)\)?)?[\-\.\ \/]?)?((?:\(?\d{1,}\)?[\-\.\ \/]?){0,})(?:[\-\.\ \/]?(?:#|ext\.?|extension|x)[\-\.\ \/]?(\d+))?$/i

Это соответствует:

 - (+351) 282 43 50 50
 - 90191919908
 - 555-8909
 - 001 6867684
 - 001 6867684x1
 - 1 (234) 567-8901
 - 1-234-567-8901 x1234
 - 1-234-567-8901 ext1234
 - 1-234 567.89/01 ext.1234
 - 1(234)5678901x1234
 - (123)8575973
 - (0055)(123)8575973

На $ n экономится:

1. Индикатор страны
2. Номер телефона
3. Расширение

Можете протестировать на https://www.regexpal.com/?fam=99127

Рабочий пример для Турции, просто измените

d{9}

в соответствии с вашими потребностями и начните его использовать.

function validateMobile($phone)
{
    $pattern = "/^(05)\d{9}$/";
    if (!preg_match($pattern, $phone))
    {
        return false;
    }
    return true;
}

$phone = "0532486061";

if (!validateMobile($phone))
{
    echo 'Incorrect Mobile Number!';
}

$phone = "05324860614";
if (validateMobile($phone))
{
    echo 'Correct Mobile Number!';
}

Прочитав эти ответы, похоже, что не было простого регулярного выражения, которое могло бы анализировать кучу текста и извлекать телефонные номера в любом формате (включая международный со знаком плюс и без него).

Вот что я недавно использовал для клиентского проекта, где нам пришлось преобразовать все номера телефонов в любом формате в ссылки tel :.

До сих пор он работал со всем, что они ему бросили, но если возникнут ошибки, я обновлю этот ответ.

Регулярное выражение:

/(\+*\d{1,})*([ |\(])*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4})/

Функция PHP для замены всех телефонных номеров ссылками tel: (на случай, если кому-то интересно):

function phoneToTel($number) {
    $return = preg_replace('/(\+*\d{1,})*([ |\(])*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4})/', '<a href = "tel:"> () -</a>', $number); // includes international
    return $return;
}

Я ответил на этот вопрос по другому вопросу SO, прежде чем решил также включить свой ответ в качестве ответа на эту тему, потому что никто не обращался к тому, как требовать / не требовать элементы, просто раздавая регулярные выражения: Регулярное выражение работает неправильно, сопоставляет неожиданные вещи

Из моего сообщения на этом сайте я создал краткое руководство, чтобы помочь любому создать собственное регулярное выражение для своего желаемого формата номера телефона, о котором я предупреждаю (как и на другом сайте), что если вы слишком ограничиваете, вы можете не получить желаемых результатов, и не существует универсального решения для приема всех возможных телефонных номеров в мире - только то, что вы решите принять в качестве выбранного вами формата. Используйте на свой риск.

Краткая шпаргалка

• Начните выражение: /^
• Если вам нужно место, используйте: [\s] или \s.
• Если вы хотите требовать скобки, используйте: [(] и [)]. Использование \( и \) некрасиво и может сбивать с толку.
• Если вы хотите, чтобы что-то было необязательным, поставьте после него ?.
• Если вам нужен дефис, просто введите - или [-]. Однако, если вы не поместите его первым или последним в ряду других символов, вам может потребоваться экранировать его: \-
• Если вы хотите использовать различные варианты в слоте, заключите их в скобки: [-.\s] потребует дефиса, точки или пробела. Знак вопроса после последней скобки сделает все это необязательными для этого слота.
• \d{3}: требуется трехзначный номер: 000-999. Сокращение для [0-9][0-9][0-9].
• [2-9]: для этого слота требуется цифра 2-9.
• (\+|1\s)?: примите «плюс» или 1 и пробел (вертикальная черта, |, это «или») и сделайте это необязательным. Знак «плюс» должен быть экранирован.
• Если вы хотите, чтобы определенные числа соответствовали слоту, введите их: [246] потребует 2, 4 или 6. (?:77|78) или [77|78] потребует 77 или 78.
• $/: Завершить выражение

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

Следующее регулярное выражение будет улавливать широко используемые комбинации цифр и символов в различных форматах глобальных телефонных номеров:

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

Положительные:
+42 555.123.4567
+ 1- (800) -123-4567
+7 555 1234567
+7 (926) 1234567
(926) 1234567
+ 79261234567
926 1234567
9261234567
1234567
123-4567
123-89-01
495 1234567
469 123 45 67
89261234567
8 (926) 1234567
926.123.4567
415-555-1234
650-555-2345
(416) 555-3456
202 555 4567
4035555678
1 416 555 9292

Отрицательный:
926 3 4
8 800 600-ЯБЛОКО

Первоисточник: http://www.regexr.com/38pvb

/\b(\d{3}[^\d]{0,2}\d{3}[^\d]{0,2}\d{4})\b/

Я обнаружил, что это работает довольно хорошо:

^\(*\+*[1-9]{0,3}\)*-*[1-9]{0,3}[-. /]*\(*[2-9]\d{2}\)*[-. /]*\d{3}[-. /]*\d{4} *e*x*t*\.* *\d{0,4}$

Он работает для следующих числовых форматов:

1-234-567-8901
1-234-567-8901 x1234
1-234-567-8901 ext1234
1 (234) 567-8901
1.234.567.8901
1/234/567/8901
12345678901
1-234-567-8901 ext. 1234
(+351) 282 433 5050

Обязательно используйте глобальные И многострочные флаги, чтобы убедиться.

Ссылка: http://www.regexr.com/3bp4b

Практически невозможно обрабатывать всевозможные международные телефонные номера с помощью простого регулярного выражения.

Вам было бы лучше использовать такую ​​службу, как numverify.com, они предлагают бесплатный JSON API для проверки международного номера телефона, плюс вы получите полезную информацию о стране, местоположении, операторе связи и типе линии с каждым запросом.

Найдите String regex = "^\+(?:[0-9] ?){6,14}[0-9]$";

полезно для международных номеров.

Примечание Он принимает в качестве входных данных номер мобильного телефона в США в любом формате и дополнительно принимает второй параметр - установите значение true, если вы хотите, чтобы выходной номер мобильного телефона выглядел красиво. Если предоставленный номер не является номером мобильного телефона, он просто возвращает false. Если номер мобильного телефона обнаружен, он возвращает весь очищенный номер вместо истины.

    function isValidMobile(num,format) {
        if (!format) format=false
        var m1 = /^(\W|^)[(]{0,1}\d{3}[)]{0,1}[.]{0,1}[\s-]{0,1}\d{3}[\s-]{0,1}[\s.]{0,1}\d{4}(\W|$)/
        if (!m1.test(num)) {
           return false
        }
        num = num.replace(/ /g,'').replace(/\./g,'').replace(/-/g,'').replace(/\(/g,'').replace(/\)/g,'').replace(/\[/g,'').replace(/\]/g,'').replace(/\+/g,'').replace(/\~/g,'').replace(/\{/g,'').replace(/\*/g,'').replace(/\}/g,'')
        if ((num.length < 10) || (num.length > 11) || (num.substring(0,1)=='0') || (num.substring(1,1)=='0') || ((num.length==10)&&(num.substring(0,1)=='1'))||((num.length==11)&&(num.substring(0,1)!='1'))) return false;
        num = (num.length == 11) ? num : ('1' + num);   
        if ((num.length == 11) && (num.substring(0,1) == "1")) {
            if (format===true) {
               return '(' + num.substr(1,3) + ') ' + num.substr(4,3) + '-' + num.substr(7,4)
            } else {
               return num
            }
        } else {
            return false;
        }
    }

Попробуйте это (это для проверки номера мобильного телефона в Индии):

if (!phoneNumber.matches("^[6-9]\d{9}$")) {
  return false;
} else {
  return true;
}

Поскольку в этом посте нет языкового тега, я дам решение regex, используемое в python.

Само выражение:

1[\s./-]?\(?[\d]+\)?[\s./-]?[\d]+[-/.]?[\d]+\s?[\d]+

При использовании в Python:

import re

phonelist  = "1-234-567-8901,1-234-567-8901 1234,1-234-567-8901 1234,1 (234) 567-8901,1.234.567.8901,1/234/567/8901,12345678901"

phonenumber = '\n'.join([phone for phone in re.findall(r'1[\s./-]?\(?[\d]+\)?[\s./-]?[\d]+[-/.]?[\d]+\s?[\d]+' ,phonelist)])
print(phonenumber)

Выход:

1-234-567-8901
1-234-567-8901 1234
1-234-567-8901 1234
1 (234) 567-8901
1.234.567.8901
1/234/567/8901
12345678901

Вот что я использую

function isValidTel ($tel) {
    preg_match('/^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im', $tel, $matches);
    return !! $matches;
}

Проверьте это в этом тестере регулярных выражений https://www.phpliveregex.com/p/uld

поскольку есть так много возможностей написать номер телефона, можно просто проверить, достаточно ли в нем цифр, как бы они ни были разделены. Я обнаружил, что для меня работают от 9 до 14 цифр:

^\D*(\d\D*){9,14}$

истинный:

• 123456789
• 1234567890123
• +123 (456) 78,90-98,76

ложный:

• 123
• (1234) 1234
• 9007199254740991
• 123 не буду делать то, что ты мне говоришь
• +123 (456) 78.90-98.76 # 543 доб 210> 2> 5> 3
• (123) 456-7890 утром (987) 54-3210 после 18:00 и спросить Ширли

если вы используете хочу для поддержки этих двух последних примеров - просто удалите верхний предел:

(\d\D*){9,}

(^$ не нужен, если нет верхнего предела)

Java генерирует REGEX для действительных номеров телефонов

Другая альтернатива - позволить Java генерировать REGEX, который отображает все варианты телефонных номеров, считываемых из списка. Это означает, что список с именем validPhoneNumbersFormat, показанный ниже в контексте кода, определяет, какой формат номера телефона является допустимым.

Примечание. Этот тип алгоритма будет работать для любого языка, обрабатывающего регулярные выражения.

Фрагмент кода, который генерирует REGEX:

Set<String> regexSet = uniqueValidPhoneNumbersFormats.stream()
        .map(s -> s.replaceAll("\+", "\\+"))
        .map(s -> s.replaceAll("\d", "\\d"))
        .map(s -> s.replaceAll("\.", "\\."))
        .map(s -> s.replaceAll("([\(\)])", "\\"))
        .collect(Collectors.toSet());

String regex = String.join("|", regexSet);

Фрагмент кода в контексте:

public class TestBench {

    public static void main(String[] args) {
        List<String> validPhoneNumbersFormat = Arrays.asList(
                "1-234-567-8901",
                "1-234-567-8901 x1234",
                "1-234-567-8901 ext1234",
                "1 (234) 567-8901",
                "1.234.567.8901",
                "1/234/567/8901",
                "12345678901",
                "+12345678901",
                "(234) 567-8901 ext. 123",
                "+1 234-567-8901 ext. 123",
                "1 (234) 567-8901 ext. 123",
                "00 1 234-567-8901 ext. 123",
                "+210-998-234-01234",
                "210-998-234-01234",
                "+21099823401234",
                "+210-(998)-(234)-(01234)",
                "(+351) 282 43 50 50",
                "90191919908",
                "555-8909",
                "001 6867684",
                "001 6867684x1",
                "1 (234) 567-8901",
                "1-234-567-8901 x1234",
                "1-234-567-8901 ext1234",
                "1-234 567.89/01 ext.1234",
                "1(234)5678901x1234",
                "(123)8575973",
                "(0055)(123)8575973"
        );

        Set<String> uniqueValidPhoneNumbersFormats = new LinkedHashSet<>(validPhoneNumbersFormat);

        List<String> invalidPhoneNumbers = Arrays.asList(
                "+210-99A-234-01234",       // FAIL
                "+210-999-234-0\"\"234",    // FAIL
                "+210-999-234-02;4",        // FAIL
                "-210+998-234-01234",       // FAIL
                "+210-998)-(234-(01234"     // FAIL
        );
        List<String> invalidAndValidPhoneNumbers = new ArrayList<>();
        invalidAndValidPhoneNumbers.addAll(invalidPhoneNumbers);
        invalidAndValidPhoneNumbers.addAll(uniqueValidPhoneNumbersFormats);

        Set<String> regexSet = uniqueValidPhoneNumbersFormats.stream()
                .map(s -> s.replaceAll("\+", "\\+"))
                .map(s -> s.replaceAll("\d", "\\d"))
                .map(s -> s.replaceAll("\.", "\\."))
                .map(s -> s.replaceAll("([\(\)])", "\\"))
                .collect(Collectors.toSet());

        String regex = String.join("|", regexSet);

        List<String> result = new ArrayList<>();
        Pattern pattern = Pattern.compile(regex);
        for (String phoneNumber : invalidAndValidPhoneNumbers) {
            Matcher matcher = pattern.matcher(phoneNumber);
            if (matcher.matches()) {
                result.add(matcher.group());
            }
        }

        // Output:
        if (uniqueValidPhoneNumbersFormats.size() == result.size()) {
            System.out.println("All valid numbers was matched!\n");
        }    
        result.forEach(System.out::println); 
    }

}

Выход:

All valid numbers was matched!

1-234-567-8901
1-234-567-8901 x1234
1-234-567-8901 ext1234
...
...
...

Хотя это не регулярное выражение, вы можете использовать функцию validate_phone() из библиотеки Python DataPrep для проверки телефонных номеров в США. Установите его с помощью pip install dataprep.

>>> from dataprep.clean import validate_phone
>>> df = pd.DataFrame({'phone': ['1-234-567-8901', '1-234-567-8901 x1234', 
         '1-234-567-8901 ext1234', '1 (234) 567-8901', '1.234.567.8901',
         '1/234/567/8901', 12345678901, '12345678', '123-456-78987']})
>>> validate_phone(df['phone'])
0     True
1     True
2     True
3     True
4     True
5     True
6     True
7    False
8    False
Name: phone, dtype: bool