Validation du numéro de téléphone américain avec php / regex

EDIT: j'ai mélangé et modifié deux des réponses données ci-dessous à la forme de la fonction complète qui maintenant fait ce que je voulais et puis un peu... Alors j'ai pensé à la poster ici au cas où quelqu'un d'autre vient à la recherche de cette même chose.

/*
 * Function to analyze string against many popular formatting styles of phone numbers
 * Also breaks phone number into it's respective components
 * 3-digit area code, 3-digit exchange code, 4-digit subscriber number
 * After which it validates the 10 digit US number against NANPA guidelines
*/
function validPhone($phone) {

  $format_pattern = '/^(?:(?:\((?=\d{3}\)))?(\d{3})(?:(?<=\(\d{3})\))?[\s.\/-]?)?(\d{3})[\s\.\/-]?(\d{4})\s?(?:(?:(?:(?:e|x|ex|ext)\.?\:?|extension\:?)\s?)(?=\d+)(\d+))?$/';
  $nanpa_pattern = '/^(?:1)?(?(?!(37|96))[2-9][0-8][0-9](?<!(11)))?[2-9][0-9]{2}(?<!(11))[0-9]{4}(?<!(555(01([0-9][0-9])|1212)))$/';

  //Set array of variables to false initially
  $valid = array(
    'format' => false,
    'nanpa' => false,
    'ext' => false,
    'all' => false
  );

  //Check data against the format analyzer
  if(preg_match($format_pattern, $phone, $matchset)) {
    $valid['format'] = true;    
  }

  //If formatted properly, continue
  if($valid['format']) {

    //Set array of new components
    $components = array(
      'ac' => $matchset[1], //area code
      'xc' => $matchset[2], //exchange code
      'sn' => $matchset[3], //subscriber number
      'xn' => $matchset[4], //extension number
    );

    //Set array of number variants
    $numbers = array(
      'original' => $matchset[0],
      'stripped' => substr(preg_replace('[\D]', '', $matchset[0]), 0, 10)
    );

    //Now let's check the first ten digits against NANPA standards
    if(preg_match($nanpa_pattern, $numbers['stripped'])) {
      $valid['nanpa'] = true;
    }

    //If the NANPA guidelines have been met, continue
    if($valid['nanpa']) {
      if(!empty($components['xn'])) {
        if(preg_match('/^[\d]{1,6}$/', $components['xn'])) {
          $valid['ext'] = true;
        }
      }
      else {
        $valid['ext'] = true;
      }
    }

    //If the extension number is valid or non-existent, continue
    if($valid['ext']) {
      $valid['all'] = true;
    }
  }
  return $valid['all'];
}

source d'informationauteur Josh

  1. 4

    L'actuel REGEX

    /^[\(]?(\d{0,3})[\)]?[\.]?[\/]?[\s]?[\-]?(\d{3})[\s]?[\.]?[\/]?[\-]?(\d{4})[\s]?[x]?(\d*)$/

    a beaucoup de problèmes, résultant en elle de répondre à l'ensemble des éléments suivants, entre autres:

    (0./-000 ./-0000 x00000000000000000000000)

    ()./1234567890123456789012345678901234567890

    \)\-555/1212 x

    Je pense que cette expression est à rapprocher de ce que vous êtes à la recherche pour:

    /^(?:(?:(?:1[.\/\s-]?)(?!\())?(?:\((?=\d{3}\)))?((?(?!(37|96))[2-9][0-8][0-9](?<!(11)))?[2-9])(?:\((?<=\(\d{3}))?)?[.\/\s-]?([0-9]{2}(?<!(11)))[.\/\s-]?([0-9]{4}(?<!(555(01([0-9][0-9])|1212))))(?:[\s]*(?:(?:x|ext|extn|ex)[.:]*|extension[:]?)?[\s]*(\d+))?$/

    ou, a explosé:

    <?
    $pattern = 
    '/^                                                     #  Matches from beginning of string

        (?:                                                 #  Country /Area Code Wrapper [not captured]
            (?:                                             #  Country Code Wrapper [not captured]
                (?:                                         #  Country Code Inner Wrapper [not captured]
                    1                                       #  1 - CC for United States and Canada
                    [.\/\s-]?                               #  Character Class ('.', '/', '-' or whitespace) for allowed (optional, single) delimiter between Country Code and Area Code
                )                                           #  End of Country Code
                (?!\()                                      #  Lookahead, only allowed if not followed by an open parenthesis
            )?                                              #  Country Code Optional
            (?:                                             #  Opening Parenthesis Wrapper [not captured]
                \(                                          #  Opening parenthesis
                (?=\d{3}\))                                 #  Lookahead, only allowed if followed by 3 digits and closing parenthesis [lookahead never captured]
            )?                                              #  Parentheses Optional
            ((?(?!(37|96))[2-9][0-8][0-9](?<!(11)))?[2-9])  #  3-digit NANPA-valid Area Code [captured]
            (?:                                             #  Closing Parenthesis Wrapper [not captured]
                \(                                          #  Closing parenthesis
                (?<=\(\d{3})                                #  Lookbehind, only allowed if preceded by 3 digits and opening parenthesis [lookbehind never captured]
            )?                                              #  Parentheses Optional
        )?                                                  #  Country /Area Code Optional

        [.\/\s-]?                                           #  Character Class ('.', '/', '-' or whitespace) for allowed (optional, single) delimiter between Area Code and Central-office Code

        ([0-9]{2}(?<!(11)))                                 #  3-digit NANPA-valid Central-office Code [captured]

        [.\/\s-]?                                           #  Character Class ('.', '/', '-' or whitespace) for allowed (optional, single) delimiter between Central-office Code and Subscriber number

        ([0-9]{4}(?<!(555(01([0-9][0-9])|1212))))           #  4-digit NANPA-valid Subscriber Number [captured]

        (?:                                                 #  Extension Wrapper [not captured]
            [\s]*                                           #  Character Class for allowed delimiters (optional, multiple) between phone number and extension
            (?:                                             #  Wrapper for extension description text [not captured]
                (?:x|ext|extn|ex)[.:]*                      #  Abbreviated extensions with character class for terminator (optional, multiple) [not captured]
              |                                             #  OR
                extension[:]?                               #  The entire word extension with character class for optional terminator
            )?                                              #  Marker for Extension optional
            [\s]*                                           #  Character Class for allowed delimiters (optional, multiple) between extension description text and actual extension
            (\d+)                                           #  Extension [captured if present], required for extension wrapper to match
        )?                                                  #  Entire extension optional

    $                                                       #  Matches to end of string
    /x';                                                    ///x modifier allows the expanded and commented regex

?>

    Cette modification apporte plusieurs améliorations.

    1. Il crée un configurable groupe d'éléments qui peuvent correspondre à l'extension. Vous pouvez ajouter d'autres séparateurs pour l'extension. C'était la demande initiale. L'extension permet également de deux points après l'extension delimter.
    2. Il convertit la séquence de 4 séparateurs en option (point, espace, barre oblique ou un tiret dans une classe de caractère qui ne correspond qu'à un seul.
    3. Il regroupe les éléments de manière appropriée. Dans l'exemple donné, vous pouvez avoir l'ouverture des parenthèses sans un code de zone, entre eux, et vous pouvez avoir l'extension de marque (espace-x) sans extension. Cette autre expression régulière nécessite soit une zone de code ou de aucun et une extension complète ou aucun.
    4. Les 4 composantes du numéro (indicatif de zone, le bureau central de code, numéro de téléphone et l'extension) sont l'arrière-référencé d'éléments qui alimentent $matches dans preg_match().
    5. Utilise anticipation/lookbehind d'exiger appariés entre parenthèses dans la zone de code.
    6. Permet un 1 - à être utilisé avant le numéro. (Ce qui suppose que tous les numéros sont les usa ou le Canada numéros, ce qui semble raisonnable, puisque le match est finalement rendu à l'encontre de NANPA restrictions. Également interdit mélange de préfixe code pays et l'indicatif régional, enveloppé dans des parenthèses.
    7. Il se fond dans la NANPA règles pour éliminer les non-cessible numéros de téléphone.
      1. Il élimine les codes sous la forme 0xx, 1xx 37x, 96x, x9x et x11 qui ne sont pas valides NANPA zone codes.
      2. Il élimine les codes de centraux dans la forme 0xx et 1xx (invalides NANPA des codes de centraux).
      3. Il élimine les nombres de la forme 555-0.1.xx (non-cessible de NANPA).

    Il a quelques limitations mineures. Ils sont probablement peu d'importance, mais sont en train d'être noté ici.

    1. Il n'y a rien en place pour exiger que le même séparateur est utilisé à plusieurs reprises, permettant de nombres comme 800-555.1212, 800/555 1212, 800 555.1212 etc.
    2. Il n'y a rien en place pour limiter le délimiteur d'après un code de zone avec des parenthèses, ce qui permet pour de tels chiffres (800)-555-1212 ou (800)/5551212.

    La NANPA règles sont adaptées à la REGEX suivante, trouvée ici: http://blogchuck.com/2010/01/php-regex-for-validating-phone-numbers/

    /^(?:1)?(?(?!(37|96))[2-9][0-8][0-9](?<!(11)))?[2-9][0-9]{2}(?<!(11))[0-9]{4}(?<!(555(01([0-9][0-9])|1212)))$/
  2. 3

    Pourquoi ne pas convertir toute une série de lettres à "x". Puis de cette façon, vous avez toutes les possibilités convertis à "x".

    OU

    Vérifier 3digits, 3digits, 4digits, 1orMoreDigits et le mépris des autres caractères entre

    Regex:
    ([0-9]{3}).*?([0-9]{3}).*?([0-9]{4}).+?([0-9]{1,})

  3. 3

    Sinon, vous pouvez utiliser certains assez simple et directe JavaScript pour forcer l'utilisateur à entrer dans une beaucoup plus de format spécifié. Le Masked Entrée Plugin ( http://digitalbush.com/projects/masked-input-plugin/ ) pour jQuery vous permet de masque HTML entrée comme un numéro de téléphone, en ne permettant à la personne d'entrer un nombre dans le format xxx-xxx-xxxx. Il ne résout pas votre extension de questions, mais il ne fournir pour un beaucoup plus propre expérience de l'utilisateur.

  4. 0

    Eh bien, vous pourriez modifier la regex, mais il ne sera pas très agréable, devraient vous permettre de "pst"? Comment à propos de "extentn"? Comment au sujet de "et ensuite, vous devez composer le"?

    Je pense que la "bonne" façon de le faire est d'ajouter un séparé, numérique, formulaire d'extension de zone.

    Mais si vous voulez vraiment les regex, je pense que j'ai fixée. Astuce: vous n'avez pas besoin [x] pour un seul caractère, x fera.

    /^\(?(\d{0,3})\)?(\.|\/)|\s|\-)?(\d{3})(\.|\/)|\s|\-)?(\d{4})\s?(x|ext)?(\d*)$/

    Vous avez permis à un point, une barre oblique, un tableau de bord, et un caractère d'espacement. Vous devrait permettre un seul de ces options. Vous aurez besoin de mettre à jour les références à $matches; la durée de groupes sont maintenant 0, 2, et 4.

    P. S. Ce n'est pas testé, car je n'ai pas de référence implémentation de PHP en cours d'exécution. Toutes mes excuses pour les fautes, s'il vous plaît laissez-moi savoir si vous trouvez tout et je vais essayer de les réparer.

    Modifier

    Cela se résume bien mieux que je peux ici.