validation online - Una regex completa per la convalida del numero di telefono



civico espressione (25)

Ho risposto a questa domanda su un'altra domanda SO prima di decidere di includere anche la mia risposta come risposta su questo thread, perché nessuno stava affrontando come richiedere / non richiedere elementi, semplicemente distribuendo regex : Regex funziona male, abbinando cose inaspettate

Dal mio post su quel sito, ho creato una guida rapida per aiutare chiunque a creare la propria espressione regolare per il proprio formato di numero di telefono desiderato, il che avverrà (come ho fatto sull'altro sito) che se si è troppo restrittivi, potresti non ottenere i risultati desiderati e non esiste una soluzione "taglia unica" per accettare tutti i numeri di telefono possibili nel mondo - solo ciò che decidi di accettare come formato di scelta. Utilizzare a proprio rischio.

Cheat sheet rapido

  • Inizia l'espressione: /^
  • Se vuoi richiedere uno spazio, usa: [\s] o \s
  • Se si desidera richiedere una parentesi, utilizzare: [(] e [)] . Usare \( e \) è brutto e può rendere le cose confuse.
  • Se vuoi che qualcosa sia facoltativo, metti un ? dopo ciò
  • Se vuoi un trattino, scrivi solo - o [-] . Se non lo metti prima o l'ultimo in una serie di altri personaggi, però, potrebbe essere necessario sfuggirlo: \-
  • Se vuoi accettare diverse scelte in uno slot, metti tra parentesi le opzioni: [-.\s] richiederà un trattino, un punto o uno spazio. Un punto interrogativo dopo l'ultima parentesi renderà tutti quelli opzionali per quello slot.
  • \d{3} : richiede un numero a 3 cifre: 000-999. Abbreviazione di [0-9][0-9][0-9] .
  • [2-9] : richiede una cifra 2-9 per quello slot.
  • (\+|1\s)? : Accetta un "più" o un 1 e uno spazio (carattere pipe, | , è "o") e lo rende opzionale. Il segno "più" deve essere sfuggito.
  • Se si desidera che i numeri specifici corrispondano a uno slot, immetterli: [246] richiede un 2, 4 o 6. [77|78] richiede 77 o 78.
  • $/ : Termina l'espressione

Sto cercando di mettere insieme una regex completa per convalidare i numeri di telefono. Idealmente, gestirà i formati internazionali, ma dovrà gestire i formati statunitensi, inclusi i seguenti:

  • 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

Risponderò con il mio attuale tentativo, ma spero che qualcuno abbia qualcosa di meglio e / o più elegante.


Avrai difficoltà a gestire i numeri internazionali con una semplice / semplice regex, vedi questo post sulle difficoltà dei numeri di telefono internazionali (e anche nordamericani).

Dovrai analizzare le prime cifre per determinare qual è il codice del paese, quindi agire in modo diverso in base al Paese.

Oltre a questo - la lista che hai dato non include un altro formato comune negli Stati Uniti - lasciando fuori l'iniziale 1. La maggior parte dei telefoni cellulari negli Stati Uniti non lo richiedono, e comincerà a confondere le nuove generazioni a meno che non abbiano chiamato a livello internazionale.

Hai correttamente identificato che è un problema complicato ...

-Adamo


Lavoro per una società di ricerche di mercato e dobbiamo filtrare questi tipi di input tutto il tempo. Lo stai complicando troppo. Basta rimuovere i caratteri non alfanumerici e vedere se c'è un'estensione.

Per ulteriori analisi puoi iscriverti a uno dei tanti fornitori che ti daranno accesso a un database di numeri validi e dirti se sono fissi o mobili, scollegati, ecc. Costa denaro.


Il mio tentativo di una regex non restrittiva:

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

accetta:

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

rifiuta:

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

Spetta a te di disinfettarlo per la visualizzazione. Dopo averlo convalidato, potrebbe essere un numero.


Per chiunque sia interessato a fare qualcosa di simile con i numeri di cellulare irlandesi, ecco un modo semplice per realizzarlo:

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

C'è anche una soluzione JQuery su quel link.

MODIFICARE:

soluzione 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._-][email protected][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.log("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();
});


});

Source .


Probabilmente starai meglio usando un ingresso mascherato per questo. In questo modo gli utenti possono inserire SOLO numeri e puoi formattare come meglio credi. Non sono sicuro se questo è per un'applicazione web, ma se c'è un plugin jQuery molto cliccabile che offre alcune opzioni per farlo.

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

Esaminano persino come mascherare gli input del numero di telefono nel loro tutorial.


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

Questo corrisponde:

 - (+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

Su $ n, salva:

  1. Indicatore Paese
  2. Numero di telefono
  3. Estensione

Puoi testarlo su https://www.regexpal.com/?fam=99127


Stavo lottando con lo stesso problema, cercando di rendere la mia applicazione a prova di futuro, ma questi ragazzi mi hanno fatto andare nella giusta direzione. In realtà non sto controllando il numero stesso per vedere se funziona o no, sto solo cercando di assicurarmi che sia stata inserita una serie di numeri che potrebbero avere o meno un'estensione.

Nella peggiore delle ipotesi, se l'utente dovesse estrarre un numero non formattato dal file XML, avrebbe comunque digitato i numeri sul tastierino numerico del telefono 012345678x5, senza una vera ragione per mantenerlo carino. Quel tipo di RegEx sarebbe venuto fuori qualcosa del genere per me:

\d+ ?\w{0,9} ?\d+
  • 01234467 extension 123456
  • 01234567x123456
  • 01234567890

.*

Se l'utente vuole darti il ​​suo numero di telefono, allora fidati di lui per farlo bene. Se non vuole dartelo, costringilo a inserire un numero valido lo invierà al sito di un concorrente o gli farà inserire una stringa casuale adatta alla tua espressione regolare. Potrei anche essere tentato di cercare il numero di una linea di sesso a tariffa maggiorata e inserirla.

Prenderò in considerazione anche le seguenti voci valide in un sito Web:

"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"

Anche se la risposta per eliminare tutti gli spazi vuoti è pulita, in realtà non risolve il problema che si pone, ovvero trovare un'espressione regolare. Prendi, per esempio, il mio script di test che scarica una pagina web ed estrae tutti i numeri di telefono usando la regex. Dato che avresti comunque bisogno di un'espressione regolare, potresti anche fare in modo che la regex faccia tutto il lavoro. Mi sono inventato questo:

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

Ecco uno script perl per testarlo. Quando combini, $ 1 contiene il prefisso, $ 2 e $ 3 contengono il numero di telefono e $ 5 contiene l'estensione. Il mio script di test scarica un file da internet e stampa tutti i numeri di telefono in esso contenuti.

#!/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 [$1-$2-$3]\n" if not defined $4;
                print "match [$1-$2-$3 $5]\n" if defined $4;
        }
        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 $1 $2 $3\n";
        }
}

Modificare:

È possibile modificare \ W * in \ s * \ W? \ S * nella regex per renderlo un po 'più stretto. Non stavo pensando alla regex in termini di, per esempio, la convalida dell'input dell'utente su un modulo quando l'ho scritto, ma questo cambiamento rende possibile usare la regex per quello scopo.

'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*))?';

Questo è un semplice modello di espressione regolare per i numeri di cellulare filippino:

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

o

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

abbinerà questi:

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

Il primo corrisponderà a QUALSIASI codice paese a due cifre, mentre il secondo corrisponderà esclusivamente al codice paese filippino.

Provalo qui: http://refiddle.com/1ox


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

Deve finire con una cifra, può iniziare con (o + o una cifra e può contenere + - (o)


Ecco la mia prova migliore finora. Gestisce i formati precedenti, ma sono sicuro che mi mancano alcuni altri formati possibili.

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

Ho trovato questo qualcosa di interessante. Non l'ho provato ma sembra che funzioni

<?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.';
}
?>

Suggerirei anche di consultare la libphonenumber Google " libphonenumber ". So che non è regex ma fa esattamente quello che vuoi.

Ad esempio, riconoscerà che:

15555555555

è un numero possibile ma non un numero valido. Supporta anche paesi al di fuori degli Stati Uniti.

Aspetti salienti della funzionalità:

  • Analisi / formattazione / convalida dei numeri di telefono per tutti i paesi / regioni del mondo.
  • getNumberType : ottiene il tipo del numero in base al numero stesso; in grado di distinguere tra telefonia fissa, cellulare, numero verde, tariffa premium, costo condiviso, VoIP e numeri personali (ove possibile).
  • isNumberMatch : ottiene un livello di confidenza sul fatto che due numeri possano essere uguali.
  • getExampleNumber / getExampleNumberByType : fornisce numeri di esempio validi per tutti i paesi / regioni, con la possibilità di specificare quale tipo di numero di telefono di esempio è necessario.
  • isPossibleNumber : indovinando rapidamente se un numero è un numero di isPossibleNumber possibile utilizzando solo le informazioni sulla lunghezza, molto più rapidamente di una convalida completa.
  • isValidNumber : convalida completa di un numero di telefono per un'area utilizzando la lunghezza e le informazioni del prefisso.
  • AsYouTypeFormatter - formatta i numeri di telefono al volo quando gli utenti inseriscono ciascuna cifra.
  • findNumbers : trova i numeri nell'input di testo.
  • PhoneNumberOfflineGeocoder : fornisce informazioni geografiche relative a un numero di telefono.

Esempi

Il più grande problema con la convalida del numero di telefono è che è molto culturalmente dipendente.

  • America
    • (408) 974–2042 è un numero statunitense valido
    • (999) 974–2042 non è un numero USA valido
  • Australia
    • 0404 999 999 è un numero australiano valido
    • (02) 9999 9999 è anche un numero australiano valido
    • (09) 9999 9999 non è un numero australiano valido

Un'espressione regolare va bene per verificare il formato di un numero di telefono, ma in realtà non sarà in grado di verificare la validità di un numero di telefono.

Ti suggerirei di saltare una semplice espressione regolare per testare il tuo numero di telefono e utilizzare una libreria come il libphonenumber di Google libphonenumber .

Presentazione di libphonenumber!

Usando uno dei tuoi esempi più complessi, 1-234-567-8901 x1234 , ottieni i seguenti dati da libphonenumber (link alla demo online) :

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

Quindi, non solo impari se il numero di telefono è valido (che è), ma ottieni anche una formattazione del numero di telefono coerente nella tua lingua.

Come bonus, libphonenumber ha un certo numero di set di dati per verificare la validità dei numeri di telefono, quindi controllare un numero come +61299999999 (la versione internazionale di (02) 9999 9999 ) restituisce un numero valido con la formattazione:

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 ti offre anche molti altri vantaggi, ad esempio l'acquisizione della posizione in cui il numero di telefono viene rilevato e anche il recupero delle informazioni sul fuso orario dal numero di telefono:

PhoneNumberOfflineGeocoder Results
Location        Australia

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

Ma il numero di telefono australiano non valido ( (09) 9999 9999 ) restituisce che non è un numero di telefono valido.

Validation Results

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

La versione di Google ha il codice per Java e Javascript, ma le persone hanno anche implementato librerie per altre lingue che utilizzano il set di dati del numero di telefono di i18n di Google:

A meno che non si sia certi che si accetteranno sempre numeri da una locale, e saranno sempre in un unico formato, suggerirei fortemente di non scrivere il proprio codice per questo e di usare libphonenumber per convalidare e visualizzare i numeri di telefono.


Hai dato un'occhiata a RegExLib ?

L'inserimento del numero di telefono americano ha riportato un bel elenco di possibilità.


Ecco uno che funziona bene in JavaScript. È in una stringa perché è quello che si aspettava il widget Dojo.

Corrisponde a un numero NANP Nord America a 10 cifre con estensione opzionale. Spazi, trattini e periodi sono delimitati accettati.

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

Ho trovato che funziona abbastanza bene:

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

Funziona con questi formati numerici:

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

Assicurati di utilizzare flag globali AND multiline per essere sicuro.

Link: http://www.regexr.com/3bp4b


Ecco uno schema meraviglioso che si avvicinava di più alla convalida che avevo bisogno di raggiungere. Non sono l'autore originale, ma penso che valga la pena condividere perché ho trovato questo problema molto complesso e senza una risposta concisa o ampiamente utile.

La seguente espressione regolare acquisirà le combinazioni numeriche e di caratteri ampiamente utilizzate in una varietà di formati di numeri telefonici globali:

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

Positivo:
+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

Negativo:
926 3 4
8 800 600-APPLE

Fonte originale: http://www.regexr.com/38pvb


Il mio istinto è rafforzato dalla quantità di risposte a questo argomento - che esiste un numero praticamente infinito di soluzioni a questo problema, nessuna delle quali sarà elegante.

Onestamente, ti consiglierei di non provare a convalidare i numeri di telefono. Anche se si potesse scrivere un validatore grande e peloso che consentisse tutti i diversi formati legittimi, finirà per consentire praticamente qualsiasi cosa che assomigli a un numero di telefono in remoto.

A mio parere, la soluzione più elegante è quella di convalidare una lunghezza minima, niente di più.


Credo che il Number::Phone::US e Regexp::Common (in particolare l'origine dei moduli Perl Regexp::Common::URI::RFC2806 ) potrebbe aiutare.

La domanda dovrebbe probabilmente essere specificata in modo un po 'più dettagliato per spiegare lo scopo della convalida dei numeri. Ad esempio, 911 è un numero valido negli Stati Uniti, ma 911x non ha alcun valore di x. È così che la compagnia telefonica può calcolare quando hai terminato la composizione. Ci sono diverse varianti su questo problema. Ma il tuo regex non controlla la porzione di codice area, quindi non sembra essere un problema.

Come la convalida degli indirizzi email, anche se hai un risultato valido non puoi sapere se è assegnato a qualcuno finché non lo provi.

Se stai provando a convalidare l'input dell'utente, perché non normalizzare il risultato e farlo con esso? Se l'utente inserisce un numero che non è possibile riconoscere come numero valido, salvarlo come immesso o rimuovere i caratteri non disponibili. Il modulo Number::Phone::Normalize Perl potrebbe essere una fonte di ispirazione.


Nota che i caratteri stripping () non funzionano per uno stile di scrittura dei numeri del Regno Unito che è comune: +44 (0) 1234 567890 che significa comporre il numero internazionale:
+441234567890
o nel Regno Unito componi lo 01234567890


Ho scritto più semplice (anche se non avevo bisogno di punti in esso).

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

Come accennato in seguito, controlla solo i caratteri, non la sua struttura / ordine


Si scopre che c'è qualcosa di spec. Per questo, almeno per il Nord America, chiamato NANP .

Devi specificare esattamente quello che vuoi. Quali sono i delimitatori legali? Spazi, trattini e periodi? Nessun delimitatore è permesso? Si possono combinare i delimitatori (ad es. + 0,111-222,3333)? Come vanno gestite le estensioni (ad es. 111-222-3333 x 44444)? E i numeri speciali, come il 911? Il codice area sarà opzionale o obbligatorio?

Ecco un'espressione regolare per un numero di 7 o 10 cifre, con le estensioni consentite, i delimitatori sono spazi, trattini o punti:

^(?:(?:\+?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+))?$

Provate con il codice qui sotto.

static void Main(string[] args)
    {
        string _wildCardPattern = "*.txt";

        List<string> _fileNames = new List<string>();
        _fileNames.Add("text_file.txt");
        _fileNames.Add("csv_file.csv");

        Console.WriteLine("\nFilenames that matches [{0}] pattern are : ", _wildCardPattern);
        foreach (string _fileName in _fileNames)
        {
            CustomWildCardPattern _patetrn = new CustomWildCardPattern(_wildCardPattern);
            if (_patetrn.IsMatch(_fileName))
            {
                Console.WriteLine("{0}", _fileName);
            }
        }

    }

public class CustomWildCardPattern : Regex
{
    public CustomWildCardPattern(string wildCardPattern)
        : base(WildcardPatternToRegex(wildCardPattern))
    {
    }

    public CustomWildCardPattern(string wildcardPattern, RegexOptions regexOptions)
        : base(WildcardPatternToRegex(wildcardPattern), regexOptions)
    {
    }

    private static string WildcardPatternToRegex(string wildcardPattern)
    {
        string patternWithWildcards = "^" + Regex.Escape(wildcardPattern).Replace("\\*", ".*");
        patternWithWildcards = patternWithWildcards.Replace("\\?", ".") + "$";
        return patternWithWildcards;
    }
}




regex validation phone-number