Je travaille sur une application SMS et je dois pouvoir convertir le numéro de téléphone de l'expéditeur de +11234567890 à 123-456-7890 afin qu'il puisse être comparé aux enregistrements dans une base de données MySQL .
Les numéros sont stockés dans ce dernier format pour une utilisation ailleurs sur le site et je préfère ne pas changer ce format car cela nécessiterait de modifier beaucoup de code.
Comment procéderais-je avec PHP?
Merci!
Réponses:
$data = '+11234567890';
if( preg_match( '/^\+\d(\d{3})(\d{3})(\d{4})$/', $data, $matches ) )
{
$result = $matches[1] . '-' .$matches[2] . '-' . $matches[3];
return $result;
}sprintfou `printf``? Quelqu'un, s'il vous plaît, expliquez-moi. Je travaille uniquement avec des numéros de téléphone américains et je ne pense pas que les exécuter via une fonction de sortie utilisant une sous-chaîne soit la meilleure méthode.
Il s'agit d'un formateur de téléphone américain qui fonctionne sur plus de versions de nombres que sur toutes les réponses actuelles.
$numbers = explode("\n", '(111) 222-3333
((111) 222-3333
1112223333
111 222-3333
111-222-3333
(111)2223333
+11234567890
1-8002353551
123-456-7890 -Hello!
+1 - 1234567890
');
foreach($numbers as $number)
{
print preg_replace('~.*(\d{3})[^\d]{0,7}(\d{3})[^\d]{0,7}(\d{4}).*~', '($1) $2-$3', $number). "\n";
}Et voici une ventilation de l'expression régulière:
Cell: +1 999-(555 0001)
.* zero or more of anything "Cell: +1 "
(\d{3}) three digits "999"
[^\d]{0,7} zero or up to 7 of something not a digit "-("
(\d{3}) three digits "555"
[^\d]{0,7} zero or up to 7 of something not a digit " "
(\d{4}) four digits "0001"
.* zero or more of anything ")"Mise à jour: 11 mars 2015 à utiliser à la {0,7}place de{,7}
~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4})(?:[ \D#\-]*(\d{3,6}))?.*~.
(\d{3}) // 3 digits [\d]// caractère qui n'est pas un chiffre
{,7}être mis à jour {0,7}. J'ai mis à jour le code.
Cette fonction formatera les numéros de téléphone internationaux (10+ chiffres), non internationaux (10 chiffres) ou old school (7 chiffres). Tous les nombres autres que 10+, 10 ou 7 chiffres resteront non formatés.
function formatPhoneNumber($phoneNumber) {
$phoneNumber = preg_replace('/[^0-9]/','',$phoneNumber);
if(strlen($phoneNumber) > 10) {
$countryCode = substr($phoneNumber, 0, strlen($phoneNumber)-10);
$areaCode = substr($phoneNumber, -10, 3);
$nextThree = substr($phoneNumber, -7, 3);
$lastFour = substr($phoneNumber, -4, 4);
$phoneNumber = '+'.$countryCode.' ('.$areaCode.') '.$nextThree.'-'.$lastFour;
}
else if(strlen($phoneNumber) == 10) {
$areaCode = substr($phoneNumber, 0, 3);
$nextThree = substr($phoneNumber, 3, 3);
$lastFour = substr($phoneNumber, 6, 4);
$phoneNumber = '('.$areaCode.') '.$nextThree.'-'.$lastFour;
}
else if(strlen($phoneNumber) == 7) {
$nextThree = substr($phoneNumber, 0, 3);
$lastFour = substr($phoneNumber, 3, 4);
$phoneNumber = $nextThree.'-'.$lastFour;
}
return $phoneNumber;
}En supposant que vos numéros de téléphone ont toujours ce format exact, vous pouvez utiliser cet extrait de code:
$from = "+11234567890";
$to = sprintf("%s-%s-%s",
substr($from, 2, 3),
substr($from, 5, 3),
substr($from, 8));Les numéros de téléphone sont difficiles. Pour une solution internationale plus robuste, je recommanderais ce port PHP bien entretenu de la bibliothèque libphonenumber de Google .
En l'utilisant comme ça,
use libphonenumber\NumberParseException;
use libphonenumber\PhoneNumber;
use libphonenumber\PhoneNumberFormat;
use libphonenumber\PhoneNumberUtil;
$phoneUtil = PhoneNumberUtil::getInstance();
$numberString = "+12123456789";
try {
$numberPrototype = $phoneUtil->parse($numberString, "US");
echo "Input: " . $numberString . "\n";
echo "isValid: " . ($phoneUtil->isValidNumber($numberPrototype) ? "true" : "false") . "\n";
echo "E164: " . $phoneUtil->format($numberPrototype, PhoneNumberFormat::E164) . "\n";
echo "National: " . $phoneUtil->format($numberPrototype, PhoneNumberFormat::NATIONAL) . "\n";
echo "International: " . $phoneUtil->format($numberPrototype, PhoneNumberFormat::INTERNATIONAL) . "\n";
} catch (NumberParseException $e) {
// handle any errors
}vous obtiendrez la sortie suivante:
Input: +12123456789
isValid: true
E164: +12123456789
National: (212) 345-6789
International: +1 212-345-6789Je recommanderais d'utiliser le E164format pour les chèques en double. Vous pouvez également vérifier si le numéro est réellement un numéro mobile ou non (en utilisant PhoneNumberUtil::getNumberType()), ou s'il s'agit même d'un numéro américain (en utilisant PhoneNumberUtil::getRegionCodeForNumber()).
En prime, la bibliothèque peut gérer à peu près n'importe quelle entrée. Si, par exemple, vous choisissez d'exécuter 1-800-JETBLUEle code ci-dessus, vous obtiendrez
Input: 1-800-JETBLUE
isValid: true
E164: +18005382583
National: (800) 538-2583
International: +1 800-538-2583Neato.
Cela fonctionne aussi bien pour les pays autres que les États-Unis. Utilisez simplement un autre code de pays ISO dans l' parse()argument.
number_formattedcolonne dans ma base de données et d'entrer manuellement les numéros formatés. Toujours utiliser libphonenumberlocalement pour générer les nombres formatés, mais inclure une bibliothèque aussi énorme pour mon petit projet est juste exagéré.
Voici ma solution réservée aux États-Unis, avec l'indicatif régional en tant que composant facultatif, le délimiteur requis pour l'extension et les commentaires regex:
function formatPhoneNumber($s) {
$rx = "/
(1)?\D* # optional country code
(\d{3})?\D* # optional area code
(\d{3})\D* # first three
(\d{4}) # last four
(?:\D+|$) # extension delimiter or EOL
(\d*) # optional extension
/x";
preg_match($rx, $s, $matches);
if(!isset($matches[0])) return false;
$country = $matches[1];
$area = $matches[2];
$three = $matches[3];
$four = $matches[4];
$ext = $matches[5];
$out = "$three-$four";
if(!empty($area)) $out = "$area-$out";
if(!empty($country)) $out = "+$country-$out";
if(!empty($ext)) $out .= "x$ext";
// check that no digits were truncated
// if (preg_replace('/\D/', '', $s) != preg_replace('/\D/', '', $out)) return false;
return $out;
}Et voici le script pour le tester:
$numbers = [
'3334444',
'2223334444',
'12223334444',
'12223334444x5555',
'333-4444',
'(222)333-4444',
'+1 222-333-4444',
'1-222-333-4444ext555',
'cell: (222) 333-4444',
'(222) 333-4444 (cell)',
];
foreach($numbers as $number) {
print(formatPhoneNumber($number)."<br>\r\n");
}Voici une fonction simple pour formater des numéros de téléphone de 7 à 10 chiffres d'une manière plus européenne (ou suédoise?):
function formatPhone($num) {
$num = preg_replace('/[^0-9]/', '', $num);
$len = strlen($num);
if($len == 7) $num = preg_replace('/([0-9]{2})([0-9]{2})([0-9]{3})/', '$1 $2 $3', $num);
elseif($len == 8) $num = preg_replace('/([0-9]{3})([0-9]{2})([0-9]{3})/', '$1 - $2 $3', $num);
elseif($len == 9) $num = preg_replace('/([0-9]{3})([0-9]{2})([0-9]{2})([0-9]{2})/', '$1 - $2 $3 $4', $num);
elseif($len == 10) $num = preg_replace('/([0-9]{3})([0-9]{2})([0-9]{2})([0-9]{3})/', '$1 - $2 $3 $4', $num);
return $num;
}Ne réinventez pas la roue! Importez cette incroyable bibliothèque:
https://github.com/giggsey/libphonenumber-for-php
$defaultCountry = 'SE'; // Based on the country of the user
$phoneUtil = PhoneNumberUtil::getInstance();
$swissNumberProto = $phoneUtil->parse($phoneNumber, $defaultCountry);
return $phoneUtil->format($swissNumberProto, PhoneNumberFormat::INTERNATIONAL);Il est basé sur la bibliothèque de Google pour l'analyse, le formatage et la validation des numéros de téléphone internationaux: https://github.com/google/libphonenumber
Je vois que cela est possible en utilisant soit une expression régulière, soit quelques appels de substr (en supposant que l'entrée est toujours de ce format, et ne change pas de longueur, etc.)
quelque chose comme
$in = "+11234567890"; $output = substr($in,2,3)."-".substr($in,6,3)."-".substr($in,10,4);devrait le faire.
C'est plus rapide que RegEx.
$input = "0987654321";
$output = substr($input, -10, -7) . "-" . substr($input, -7, -4) . "-" . substr($input, -4);
echo $output;Essayez quelque chose comme:
preg_replace('/\d{3}/', '$0-', str_replace('.', null, trim($number)), 2);cela prendrait un nombre de $ 8881112222et serait converti en 888-111-2222. J'espère que cela t'aides.
'.'doit également être mis à jour '-'ou supprimé. Il a été inclus en raison du cas d'utilisation particulier rencontré - avec très peu d'effort, vous auriez pu le convertir preg_replace('/\d{3}/', '$0-', substr($number, 2))et répondre directement à la question.
Une autre option - facilement mise à jour pour recevoir un format de la configuration.
$numbers = explode("\n", '(111) 222-3333
((111) 222-3333
1112223333
111 222-3333
111-222-3333
(111)2223333
+11234567890
1-8002353551
123-456-7890 -Hello!
+1 - 1234567890
');
foreach( $numbers AS $number ){
echo comMember_format::phoneNumber($number) . '<br>';
}
// ************************************************************************
// Format Phone Number
public function phoneNumber( $number ){
$txt = preg_replace('/[\s\-|\.|\(|\)]/','',$number);
$format = '[$1?$1 :][$2?($2):x][$3: ]$4[$5: ]$6[$7? $7:]';
if( preg_match('/^(.*)(\d{3})([^\d]*)(\d{3})([^\d]*)(\d{4})([^\d]{0,1}.*)$/', $txt, $matches) ){
$result = $format;
foreach( $matches AS $k => $v ){
$str = preg_match('/\[\$'.$k.'\?(.*?)\:(.*?)\]|\[\$'.$k.'\:(.*?)\]|(\$'.$k.'){1}/', $format, $filterMatch);
if( $filterMatch ){
$result = str_replace( $filterMatch[0], (!isset($filterMatch[3]) ? (strlen($v) ? str_replace( '$'.$k, $v, $filterMatch[1] ) : $filterMatch[2]) : (strlen($v) ? $v : (isset($filterMatch[4]) ? '' : (isset($filterMatch[3]) ? $filterMatch[3] : '')))), $result );
}
}
return $result;
}
return $number;
}Tout,
Je pense que je l'ai réparé. Travailler pour les fichiers d'entrée actuels et avoir les 2 fonctions suivantes pour y parvenir!
function format_phone_number:
function format_phone_number ( $mynum, $mask ) {
/*********************************************************************/
/* Purpose: Return either masked phone number or false */
/* Masks: Val=1 or xxx xxx xxxx */
/* Val=2 or xxx xxx.xxxx */
/* Val=3 or xxx.xxx.xxxx */
/* Val=4 or (xxx) xxx xxxx */
/* Val=5 or (xxx) xxx.xxxx */
/* Val=6 or (xxx).xxx.xxxx */
/* Val=7 or (xxx) xxx-xxxx */
/* Val=8 or (xxx)-xxx-xxxx */
/*********************************************************************/
$val_num = self::validate_phone_number ( $mynum );
if ( !$val_num && !is_string ( $mynum ) ) {
echo "Number $mynum is not a valid phone number! \n";
return false;
} // end if !$val_num
if ( ( $mask == 1 ) || ( $mask == 'xxx xxx xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'$1 $2 $3'." \n", $mynum);
return $phone;
} // end if $mask == 1
if ( ( $mask == 2 ) || ( $mask == 'xxx xxx.xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'$1 $2.$3'." \n", $mynum);
return $phone;
} // end if $mask == 2
if ( ( $mask == 3 ) || ( $mask == 'xxx.xxx.xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'$1.$2.$3'." \n", $mynum);
return $phone;
} // end if $mask == 3
if ( ( $mask == 4 ) || ( $mask == '(xxx) xxx xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'($1) $2 $3'." \n", $mynum);
return $phone;
} // end if $mask == 4
if ( ( $mask == 5 ) || ( $mask == '(xxx) xxx.xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'($1) $2.$3'." \n", $mynum);
return $phone;
} // end if $mask == 5
if ( ( $mask == 6 ) || ( $mask == '(xxx).xxx.xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'($1).$2.$3'." \n", $mynum);
return $phone;
} // end if $mask == 6
if ( ( $mask == 7 ) || ( $mask == '(xxx) xxx-xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'($1) $2-$3'." \n", $mynum);
return $phone;
} // end if $mask == 7
if ( ( $mask == 8 ) || ( $mask == '(xxx)-xxx-xxxx' ) ) {
$phone = preg_replace('~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4}).*~',
'($1)-$2-$3'." \n", $mynum);
return $phone;
} // end if $mask == 8
return false; // Returns false if no conditions meet or input
} // end function format_phone_numberfonction validate_phone_number:
function validate_phone_number ( $phone ) {
/*********************************************************************/
/* Purpose: To determine if the passed string is a valid phone */
/* number following one of the establish formatting */
/* styles for phone numbers. This function also breaks */
/* a valid number into it's respective components of: */
/* 3-digit area code, */
/* 3-digit exchange code, */
/* 4-digit subscriber number */
/* and validates the number against 10 digit US NANPA */
/* guidelines. */
/*********************************************************************/
$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)))$/';
// Init array of variables to false
$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']) {
if ( !$valid['format'] ) {
return false;
} else {
//Set array of new components
$components = array ( 'ac' => $matchset[1], //area code
'xc' => $matchset[2], //exchange code
'sn' => $matchset[3] //subscriber number
);
// $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;
} // end if if preg_match
} else {
$valid['ext'] = true;
} // end if if !empty
} // end if $valid nanpa
//If the extension number is valid or non-existent, continue
if ( $valid['ext'] ) {
$valid['all'] = true;
} // end if $valid ext
} // end if $valid
return $valid['all'];
} // end functon validate_phone_numberRemarquez que j'ai ceci dans une classe lib, donc l'appel "self :: validate_phone_number" de la première fonction / méthode.
Remarquez la ligne n ° 32 de la fonction "validate_phone_number" où j'ai ajouté:
if ( !$valid['format'] ) {
return false;
} else {pour me procurer le faux retour nécessaire si ce n'est pas un numéro de téléphone valide.
Encore faut-il tester cela avec plus de données, mais en travaillant sur les données actuelles, avec le format actuel et j'utilise le style '8' pour ce lot de données particulier.
J'ai également commenté la logique de "l'extension" car j'en recevais constamment des erreurs, car je n'ai aucune de ces informations dans mes données.
cela prend 7, 10 et 11 chiffres, supprime les caractères supplémentaires et ajoute des tirets en allant de droite à gauche dans la chaîne. changez le tiret en espace ou en point.
$raw_phone = preg_replace('/\D/', '', $raw_phone);
$temp = str_split($raw_phone);
$phone_number = "";
for ($x=count($temp)-1;$x>=0;$x--) {
if ($x === count($temp) - 5 || $x === count($temp) - 8 || $x === count($temp) - 11) {
$phone_number = "-" . $phone_number;
}
$phone_number = $temp[$x] . $phone_number;
}
echo $phone_number;Je sais que l'OP demande un format 123-456-7890, mais, sur la base de la réponse de John Dul , je l'ai modifié pour renvoyer le numéro de téléphone au format parenthèses, par exemple (123) 456-7890. Celui-ci ne gère que les nombres à 7 et 10 chiffres.
function format_phone_string( $raw_number ) {
// remove everything but numbers
$raw_number = preg_replace( '/\D/', '', $raw_number );
// split each number into an array
$arr_number = str_split($raw_number);
// add a dummy value to the beginning of the array
array_unshift( $arr_number, 'dummy' );
// remove the dummy value so now the array keys start at 1
unset($arr_number[0]);
// get the number of numbers in the number
$num_number = count($arr_number);
// loop through each number backward starting at the end
for ( $x = $num_number; $x >= 0; $x-- ) {
if ( $x === $num_number - 4 ) {
// before the fourth to last number
$phone_number = "-" . $phone_number;
}
else if ( $x === $num_number - 7 && $num_number > 7 ) {
// before the seventh to last number
// and only if the number is more than 7 digits
$phone_number = ") " . $phone_number;
}
else if ( $x === $num_number - 10 ) {
// before the tenth to last number
$phone_number = "(" . $phone_number;
}
// concatenate each number (possibly with modifications) back on
$phone_number = $arr_number[$x] . $phone_number;
}
return $phone_number;
}Voici ma prise:
$phone='+11234567890';
$parts=sscanf($phone,'%2c%3c%3c%4c');
print "$parts[1]-$parts[2]-$parts[3]";
// 123-456-7890La sscanffonction prend comme second paramètre une chaîne de format lui indiquant comment interpréter les caractères de la première chaîne. Dans ce cas, cela signifie 2 caractères (%2c ), 3 caractères, 3 caractères, 4 caractères.
Normalement, la sscanffonction comprend également des variables pour capturer les données extraites. Sinon, les données sont renvoyées dans un tableau que j'ai appelé $parts.
L' printinstruction génère la chaîne interpolée. $part[0]est ignoré.
J'ai utilisé une fonction similaire pour formater les numéros de téléphone australiens.
Notez que du point de vue du stockage du numéro de téléphone:
Formats de téléphone au Royaume-Uni
Pour l'application que j'ai développée, j'ai constaté que les gens entraient leur numéro de téléphone `` correctement '' à partir d'une forme lisible par l'homme, mais inséraient divers caractères aléatoires tels que `` - '' / `` +44 '', etc. Le problème était que l'application cloud qui il fallait parler était assez précis sur le format. Plutôt que d'utiliser une expression régulière (cela peut être frustrant pour l'utilisateur), j'ai créé une classe d'objets qui traite le numéro entré dans le format correct avant d'être traité par le module de persistance.
Le format de la sortie garantit que tout logiciel de réception interprète la sortie comme du texte plutôt que comme un entier (qui perdrait alors immédiatement le zéro de début) et le format est cohérent avec British Telecoms des directives sur le formatage des nombres - ce qui facilite également la mémorisation humaine en divisant un long nombre en petits groupes faciles à mémoriser.
+441234567890 produit (01234) 567890
02012345678 produit (020) 1234 5678
1923123456 produit (01923) 123456
01923123456 produit (01923) 123456
01923 bonjour ceci est text123456 produit (01923) 123456
L'importance du segment d'échange du numéro - entre parenthèses - est qu'au Royaume-Uni, et dans la plupart des autres pays, les appels entre les numéros d'un même central peuvent être effectués en omettant le segment d'échange. Cela ne s'applique cependant pas aux numéros de téléphone des séries 07, 08 et 09.
Je suis sûr qu'il existe des solutions plus efficaces, mais celle-ci s'est avérée extrêmement fiable. Plus de formats peuvent facilement être adaptés en ajoutant à la fonction teleNum à la fin.
La procédure est appelée à partir du script appelant ainsi
$telephone = New Telephone;
$formattedPhoneNumber = $telephone->toIntegerForm($num)»
<?php
class Telephone
{
public function toIntegerForm($num) {
/*
* This section takes the number, whatever its format, and purifies it to just digits without any space or other characters
* This ensures that the formatter only has one type of input to deal with
*/
$number = str_replace('+44', '0', $num);
$length = strlen($number);
$digits = '';
$i=0;
while ($i<$length){
$digits .= $this->first( substr($number,$i,1) , $i);
$i++;
}
if (strlen($number)<10) {return '';}
return $this->toTextForm($digits);
}
public function toTextForm($number) {
/*
* This works on the purified number to then format it according to the group code
* Numbers starting 01 and 07 are grouped 5 3 3
* Other numbers are grouped 3 4 4
*
*/
if (substr($number,0,1) == '+') { return $number; }
$group = substr($number,0,2);
switch ($group){
case "02" :
$formattedNumber = $this->teleNum($number, 3, 4); // If number commences '02N' then output will be (02N) NNNN NNNN
break;
default :
$formattedNumber = $this->teleNum($number, 5, 3); // Otherwise the ooutput will be (0NNNN) NNN NNN
}
return $formattedNumber;
}
private function first($digit,$position){
if ($digit == '+' && $position == 0) {return $digit;};
if (!is_numeric($digit)){
return '';
}
if ($position == 0) {
return ($digit == '0' ) ? $digit : '0'.$digit;
} else {
return $digit;
}
}
private function teleNum($number,$a,$b){
/*
* Formats the required output
*/
$c=strlen($number)-($a+$b);
$bit1 = substr($number,0,$a);
$bit2 = substr($number,$a,$b);
$bit3 = substr($number,$a+$b,$c);
return '('.$bit1.') '.$bit2." ".$bit3;
}
}Ceci est pour les lignes fixes du Royaume-Uni sans le code de pays
function format_phone_number($number) {
$result = preg_replace('~.*(\d{2})[^\d]{0,7}(\d{4})[^\d]{0,7}(\d{4}).*~', '$1 $2 $3', $number);
return $result;
}Résultat:
2012345678
becomes
20 1234 5678Veuillez jeter un œil à la fonction basée sur substr qui peut changer de format
function phone(string $in): string
{
$FORMAT_PHONE = [1,3,3,4];
$result =[];
$position = 0;
foreach ($FORMAT_PHONE as $key => $item){
$result[] = substr($in, $position, $item);
$position += $item;
}
return '+'.implode('-',$result);
}Vérifier le numéro de téléphone
$phone = '+385 99 1234 1234'
$str = preg_match('/^\+?\d{1,3}[\s-]?\d{1,3}[\s-]?\d{1,4}[\s-]?\d{1,4}$/', $phone);
if($str){
return true;
}else{
return false;
}