Sto cercando di mettere insieme una regex completa per convalidare i numeri di telefono. Idealmente dovrebbe gestire i formati internazionali, ma deve 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.

Opzione migliore ... basta rimuovere tutti i caratteri non digitati sull'input (tranne i segni "x" e "+" iniziali), prestando attenzione a causa della tendenza britannica a scrivere numeri in formato non standard +44 (0) ...quando viene chiesto di utilizzare il prefisso internazionale (in quel caso specifico, dovresti scartare del (0)tutto).

Quindi, finisci con valori come:

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

Quindi quando visualizzi, riformatta il contenuto del tuo cuore. per esempio

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

Si scopre che esiste qualcosa di specifico per questo, almeno per il Nord America, chiamato NANP .

Devi specificare esattamente quello che vuoi. Cosa sono i delimitatori legali? Spazi, trattini e punti? Nessun delimitatore consentito? Si possono mescolare delimitatori (ad es. + 0,111-222,3333)? Come verranno gestite le estensioni (ad es. 111-222-3333 x 44444)? E i numeri speciali, come il 911? Il prefisso sarà facoltativo o obbligatorio?

Ecco una regex per un numero di 7 o 10 cifre, con 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+))?$

.*

Se gli utenti vogliono darti i loro numeri di telefono, fidati di loro per farlo bene. Se non vogliono dartelo, costringendoli a inserire un numero valido li invieranno al sito di un concorrente o li faranno inserire una stringa casuale adatta al tuo regex. Potrei anche essere tentato di cercare il numero di una linea diretta per oroscopo a tariffa premium e inserirla invece.

Vorrei anche considerare una delle seguenti voci valide su 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"

Vorrei anche suggerire di guardare la libreria di 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.

Punti salienti della funzionalità:

• Analisi / formattazione / convalida dei numeri di telefono per tutti i paesi / regioni del mondo.
• getNumberType- ottiene il tipo di numero in base al numero stesso; in grado di distinguere numeri fissi, mobili, numeri verdi, tariffe premium, costi condivisi, VoIP e numeri personali (ove possibile).
• isNumberMatch - ottiene un livello di confidenza se due numeri potrebbero 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 - indovinare rapidamente se un numero è un numero di telefono possibile utilizzando solo le informazioni sulla lunghezza, molto più velocemente di una convalida completa.
• isValidNumber - convalida completa di un numero di telefono per una regione utilizzando informazioni su lunghezza e prefisso.
• AsYouTypeFormatter - formatta i numeri di telefono al volo quando gli utenti inseriscono ciascuna cifra.
• findNumbers - trova numeri nell'inserimento di testo.
• PhoneNumberOfflineGeocoder - fornisce informazioni geografiche relative a un numero di telefono.

Esempi

Il problema più grande con la convalida del numero di telefono è che dipende molto dalla cultura.

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

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

Suggerirei di saltare una semplice espressione regolare per testare il tuo numero di telefono e di utilizzare una libreria come quella di Google libphonenumber(link al progetto GitHub) .

Presentazione di libphonenumber!

Utilizzando uno dei tuoi esempi più complessi, 1-234-567-8901 x1234ottieni 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 (quale è), ma ottieni anche una formattazione coerente del numero di telefono nella tua lingua.

Come bonus, libphonenumberha un numero di set di dati per verificare la validità dei numeri di telefono, quindi controllando un numero come +61299999999(la versione internazionale di (02) 9999 9999) si restituisce un numero valido con 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, come la presa della posizione in cui viene rilevato il numero di telefono e anche ottenere le 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 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 Google i18n:

• PHP : https://github.com/giggsey/libphonenumber-for-php
• Python : https://github.com/daviddrysdale/python-phonenumbers
• Ruby : https://github.com/sstephenson/global_phone
• C # : https://github.com/twcclegg/libphonenumber-csharp
• Obiettivo-C : https://github.com/iziz/libPhoneNumber-iOS
• JavaScript : https://github.com/ruimarinho/google-libphonenumber
• Elisir : https://github.com/socialpaymentsbv/ex_phone_number

A meno che non si sia certi di accettare sempre numeri da una locale e che siano sempre in un formato, suggerirei vivamente di non scrivere il proprio codice per questo e di utilizzare libphonenumber per convalidare e visualizzare i numeri di telefono.

/^(?:(?:\(?(?: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 del paese
2. Numero di telefono
3. Estensione

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

Sebbene la risposta per eliminare tutti gli spazi bianchi sia chiara, in realtà non risolve il problema che si pone, ovvero trovare una regex. Prendi, ad esempio, il mio script di test che scarica una pagina Web ed estrae tutti i numeri di telefono usando regex. Dato che avresti bisogno comunque di una regex, potresti anche fare in modo che la regex faccia tutto il lavoro. Ho pensato a 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 abbini, $ 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 al suo interno.

#!/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:

Puoi cambiare \ W * in \ s * \ W? \ S * nella regex per stringere un po '. Non pensavo alla regex in termini, per esempio, di convalida dell'input dell'utente su un modulo quando l'ho scritto, ma questa modifica rende possibile usare la regex a tale 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*))?';

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 si stava rivolgendo a come richiedere / non richiedere elementi, distribuendo solo regex : Regex funzionava male, abbina cose inaspettate

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

Cheat sheet veloce

• Inizia l'espressione: /^
• Se si desidera richiedere uno spazio, utilizzare: [\s]o\s
• Se si desidera richiedere la parentesi, utilizzare: [(]e [)]. utilizzando\( e \)è brutto e può creare confusione.
• Se vuoi che qualcosa sia facoltativo, inserisci a ? dopo
• Se vuoi un trattino, digita -o[-] . Se non lo metti per primo o per ultimo in una serie di altri personaggi, potresti dover scappare: \-
• Se vuoi accettare diverse scelte in uno slot, metti le parentesi attorno alle opzioni: [-.\s] richiederà un trattino, un punto o uno spazio. Un punto interrogativo dopo l'ultima parentesi renderà tutte quelle opzionali per quello slot.
• \d{3}: Richiede un numero di 3 cifre: 000-999. Stenografia per [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 rendilo facoltativo. Il segno "più" deve essere sfuggito.
• Se si desidera che numeri specifici corrispondano a uno slot, inserirli: [246]richiederà un 2, 4 o 6. [77|78]richiederà 77 o 78.
• $/ : Termina l'espressione

Ho scritto più semplice (anche se non avevo bisogno di un punto).

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

Come menzionato di seguito, controlla solo i caratteri, non la sua struttura / ordine

Se vuoi solo verificare di non avere immondizia casuale nel campo (ad esempio, dagli spammer dei moduli), questa regex dovrebbe fare bene:

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

Nota che non ha regole speciali per quante cifre o quali numeri sono validi in quelle cifre, verifica solo che solo cifre, parentesi, trattini, più, spazio, cancelletto, asterisco, punto, virgola o lettere e, x, tsono presenti.

Dovrebbe essere compatibile con numeri internazionali e formati di localizzazione. Prevedi la necessità di consentire parentesi quadre, ricci o inclinate per alcune regioni? (al momento non sono inclusi).

Se vuoi mantenere le regole per cifra (come nei prefissi e prefissi statunitensi (codici di scambio) deve rientrare nell'intervallo 200-999), buona fortuna a te. Mantenere un complesso insieme di regole che potrebbe essere superato in qualsiasi momento in futuro da qualsiasi paese del mondo non sembra divertente.

E mentre lo stripping di tutti / la maggior parte dei caratteri non numerici può funzionare bene sul lato server (specialmente se stai pianificando di passare questi valori a un dialer), potresti non voler bloccare l'input dell'utente durante la convalida, in particolare se lo desideri apportare correzioni in un altro campo.

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

Hai dato un'occhiata a RegExLib ?

L'immissione del numero di telefono negli Stati Uniti ha riportato un bel elenco di possibilità.

Il mio tentativo di regex senza restrizioni:

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

accetta:

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

Rejects:

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

Sta a te disinfettarlo per la visualizzazione. Dopo la convalida potrebbe essere un numero però.

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 usare flag globali E multilinea per assicurarti.

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

Se stai parlando della convalida del modulo, la regexp per convalidare il significato corretto così come i dati corretti sarà estremamente complessa a causa delle diverse norme nazionali e dei fornitori. Sarà anche difficile tenersi aggiornati.

Interpreto la domanda come alla ricerca di un modello ampiamente valido, che potrebbe non essere coerente internamente - ad esempio avere un set di numeri valido, ma non convalidare che la linea principale, lo scambio, ecc. Al modello valido per il prefisso del prefisso del paese .

Il Nord America è semplice e per gli internazionali preferisco usare un modello "idiomatico" che copre i modi in cui le persone specificano e ricordano i loro numeri:

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

Il modello nordamericano si assicura che se una parentesi è inclusa entrambe sono. I conti internazionali per un '+' iniziale opzionale e il prefisso internazionale. Dopo quello, sei nel linguaggio. Le corrispondenze valide sarebbero:

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

Ciò può essere di parte poiché la mia esperienza è limitata al Nord America, all'Europa e ad un po 'di Asia.

Ecco un modello meraviglioso che si avvicinava di più alla convalida che dovevo raggiungere. Non sono l'autore originale, ma penso che valga la pena condividerlo poiché ho riscontrato che questo problema è molto complesso e senza una risposta concisa o ampiamente utile.

Il seguente regex rileverà combinazioni di numeri e caratteri ampiamente utilizzate in una varietà di formati di numeri di telefono 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: esiste un numero praticamente infinito di soluzioni a questo problema, nessuna delle quali sarà elegante.

Onestamente, consiglierei di non provare a convalidare i numeri di telefono. Anche se potessi scrivere un validatore grande e peloso che consentirebbe tutti i diversi formati legittimi, finirebbe per consentire praticamente qualsiasi cosa che assomigli in remoto a un numero di telefono, in primo luogo.

Secondo me, la soluzione più elegante è quella di convalidare una lunghezza minima, niente di più.

Questo è un semplice schema di espressioni regolari per i numeri di telefono filippini:

((\+[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}

corrisponderà a 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

Ecco il mio miglior tentativo finora. Gestisce i formati sopra, 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}))?$

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

Ti consigliamo di analizzare le prime cifre per determinare qual è il codice paese, quindi agire in modo diverso in base al paese.

Oltre a ciò - l'elenco che hai fornito non include un altro formato statunitense comune - tralasciando l'iniziale 1. La maggior parte dei telefoni cellulari negli Stati Uniti non lo richiede e inizierà a confondere le generazioni più giovani a meno che non abbiano composto un numero internazionale.

Hai correttamente identificato che si tratta di un problema difficile ...

-Adamo

Dopo aver letto queste risposte, sembra che non ci sia un'espressione regolare semplice che può analizzare un mucchio di testo ed estrarre numeri di telefono in qualsiasi formato (incluso quello internazionale con e senza il segno più).

Ecco cosa ho usato di recente per un progetto client, in cui abbiamo dovuto convertire tutti i numeri di telefono in qualsiasi formato in tel: links.

Finora, ha funzionato con tutto ciò che ci hanno lanciato, ma se si verificano errori, aggiornerò questa risposta.

regex:

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

Funzione PHP per sostituire tutti i numeri di telefono con tel: links (nel caso qualcuno fosse curioso):

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

Credo che i moduli Perl di Number :: Phone :: US e Regexp :: Common (in particolare la fonte di Regexp :: Common :: URI :: RFC2806 ) possano aiutare.

La domanda dovrebbe probabilmente essere specificata in modo un po 'più dettagliato per spiegare lo scopo della validazione dei numeri. Ad esempio, 911 è un numero valido negli Stati Uniti, ma 911x non è per alcun valore di x. Questo è così che la compagnia telefonica può calcolare quando hai finito di chiamare. Esistono diverse varianti su questo problema. Ma il tuo regex non controlla la parte del prefisso, quindi non sembra essere un problema.

Come la convalida degli indirizzi e-mail, anche se hai un risultato valido non puoi sapere se è stato assegnato a qualcuno fino a quando 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 un numero valido, salvarlo come immesso o eliminare i caratteri non disponibili. Il modulo Number :: Phone :: Normalize Perl potrebbe essere fonte di ispirazione.

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

Per ulteriori analisi è possibile abbonarsi a uno dei numerosi provider che ti darà accesso a un database di numeri validi e ti dirà se sono fissi o mobili, disconnessi, ecc. Costa denaro.

Sostituisci i caratteri di formattazione, quindi controlla la validità del telefono rimanente. In PHP,

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

Rompere una regexp complessa come questa può essere altrettanto efficace, ma molto più semplice.

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

Probabilmente sarebbe meglio usare un input mascherato per questo. In questo modo gli utenti possono inserire SOLO numeri e formattare come meglio credi. Non sono sicuro se questo sia per un'applicazione web, ma se lo è c'è un plugin jQuery molto click che offre alcune opzioni per farlo.

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

Esaminano anche come mascherare gli input dei numeri di telefono nel loro tutorial.

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

Corrisponde a un numero NANP del Nord America a 10 cifre con estensione opzionale. Spazi, trattini e punti sono delimitatori accettati.

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

Stavo lottando con lo stesso problema, cercando di rendere la mia candidatura a prova di futuro, ma questi ragazzi mi hanno portato 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.

Nel peggiore dei casi, se l'utente dovesse estrarre un numero non formattato dal file XML, digiterebbe comunque i numeri nel tastierino numerico del telefono 012345678x5, senza una vera ragione per mantenerlo carino. Quel tipo di RegEx sarebbe uscito qualcosa di simile per me:

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

• 01234467 extension 123456
• 01234567x123456
• 01234567890

La mia inclinazione è quella di concordare sul fatto che spogliarsi senza cifre e accettare semplicemente ciò che c'è di meglio. Forse per assicurare che siano presenti almeno un paio di cifre, sebbene ciò proibisca qualcosa come un numero di telefono alfabetico "ASK-JAKE" per esempio.

Un paio di semplici espressioni perl potrebbero essere:

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

Usa il primo per tenere uniti i gruppi di cifre, il che potrebbe fornire indizi di formattazione. Usa il secondo per lanciare banalmente tutte le non cifre.

È preoccupante che potrebbe essere necessario fare una pausa e inserire più chiavi? O qualcosa del tipo 555-1212 (attendere il segnale acustico) 123?

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

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

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._-]+@[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();
});


});

Fonte .