मैं एक एसएमएस ऐप पर काम कर रहा हूं और प्रेषक के फोन नंबर को +11234567890 से 123-456-7890 तक बदलने में सक्षम होने की आवश्यकता है, इसलिए इसकी तुलना एक MySQL डेटाबेस में रिकॉर्ड से की जा सकती है ।
साइट पर कहीं और उपयोग करने के लिए नंबर को बाद के प्रारूप में संग्रहीत किया जाता है और मैं उस प्रारूप को नहीं बदलूंगा क्योंकि इसमें बहुत सारे कोड को संशोधित करने की आवश्यकता होगी।
मैं PHP के साथ इस बारे में कैसे जाऊँगा?
धन्यवाद!
जवाबों:
$data = '+11234567890';
if( preg_match( '/^\+\d(\d{3})(\d{3})(\d{4})$/', $data, $matches ) )
{
$result = $matches[1] . '-' .$matches[2] . '-' . $matches[3];
return $result;
}sprintfया `printf``? कृपया कोई मुझे समझाए। मैं केवल फोन नंबरों के साथ यूएस में काम कर रहा हूं और यह नहीं सोचता कि सबस्टेशन का उपयोग करके उन्हें आउटपुट फ़ंक्शन के माध्यम से चलाना सबसे अच्छा तरीका है।
यह एक यूएस फोन फॉर्मैटर है जो किसी भी वर्तमान उत्तर की तुलना में संख्याओं के अधिक संस्करणों पर काम करता है।
$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";
}और यहाँ रेगेक्स का एक विराम है:
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 ")"अपडेट किया गया: 11 मार्च 2015 के {0,7}बजाय उपयोग करने के लिए{,7}
~.*(\d{3})[^\d]*(\d{3})[^\d]*(\d{4})(?:[ \D#\-]*(\d{3,6}))?.*~।
(\d{3}) // 3 digits [\d]// चरित्र जो एक अंक नहीं है
{,7}इसे अपडेट करने की आवश्यकता है {0,7}। मैंने कोड अपडेट कर दिया है।
यह फ़ंक्शन अंतर्राष्ट्रीय (10+ अंक), गैर-अंतर्राष्ट्रीय (10 अंक) या पुराने स्कूल (7 अंक) फ़ोन नंबर को प्रारूपित करेगा। 10+, 10 या 7 अंको के अलावा कोई भी संख्या बिना सूचना के रहेगी।
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;
}यह मानते हुए कि आपके फ़ोन नंबरों में हमेशा यह सटीक प्रारूप होता है, आप इस स्निपेट का उपयोग कर सकते हैं:
$from = "+11234567890";
$to = sprintf("%s-%s-%s",
substr($from, 2, 3),
substr($from, 5, 3),
substr($from, 8));फोन नंबर कठिन हैं। अधिक मजबूत, अंतर्राष्ट्रीय समाधान के लिए, मैं Google के लिबफोनेनंबर लाइब्रेरी के इस सुव्यवस्थित पीएचपी पोर्ट की सिफारिश करूंगा ।
इस तरह का उपयोग करना,
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
}आपको निम्न आउटपुट मिलेगा:
Input: +12123456789
isValid: true
E164: +12123456789
National: (212) 345-6789
International: +1 212-345-6789मैं E164डुप्लिकेट चेक के प्रारूप का उपयोग करने की सलाह दूंगा। आप यह भी जांच सकते हैं कि नंबर वास्तव में मोबाइल नंबर है या नहीं (उपयोग कर रहा है PhoneNumberUtil::getNumberType()), या यह कि यह यूएस नंबर (उपयोग PhoneNumberUtil::getRegionCodeForNumber()) भी है या नहीं ।
एक बोनस के रूप में, पुस्तकालय बहुत अधिक किसी भी इनपुट को संभाल सकता है। यदि आप, उदाहरण के लिए, 1-800-JETBLUEऊपर दिए गए कोड के माध्यम से दौड़ना चुनते हैं , तो आपको मिलेगा
Input: 1-800-JETBLUE
isValid: true
E164: +18005382583
National: (800) 538-2583
International: +1 800-538-2583Neato।
यह सिर्फ अमेरिका के अलावा अन्य देशों के लिए भी अच्छा काम करता है। बस parse()तर्क में एक और आईएसओ देश कोड का उपयोग करें ।
number_formattedअपने डेटाबेस में सिर्फ एक कॉलम जोड़ने का फैसला किया और मैन्युअल रूप से स्वरूपित संख्याओं को दर्ज किया। अभी भी libphonenumberस्थानीय रूप से उपयोग किए गए स्वरूपित संख्याओं को उत्पन्न करने के लिए उपयोग करते हैं , लेकिन मेरी छोटी परियोजना के लिए इतनी बड़ी लाइब्रेरी सहित सिर्फ ओवरकिल है।
यहां मेरा यूएसए केवल समाधान है, एक वैकल्पिक घटक के रूप में क्षेत्र कोड के साथ, विस्तार के लिए आवश्यक सीमांकक, और 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;
}और यहाँ इसका परीक्षण करने के लिए स्क्रिप्ट है:
$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");
}यहां अधिक यूरोपीय (या स्वीडिश?) तरीके से 7 से 10 अंकों वाले फोन नंबर को प्रारूपित करने का एक सरल कार्य है:
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;
}पहिया को मजबूत मत करो! इस अद्भुत पुस्तकालय को आयात करें:
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);यह अंतरराष्ट्रीय फ़ोन नंबरों को पार्स करने, स्वरूपण और मान्य करने के लिए Google की लाइब्रेरी पर आधारित है: https://github.com/google/libphonenumber
यह RegEx से तेज है।
$input = "0987654321";
$output = substr($input, -10, -7) . "-" . substr($input, -7, -4) . "-" . substr($input, -4);
echo $output;कुछ इस तरह की कोशिश करो:
preg_replace('/\d{3}/', '$0-', str_replace('.', null, trim($number)), 2);यह एक $ संख्या लेता है 8881112222और में परिवर्तित होता है 888-111-2222। उम्मीद है की यह मदद करेगा।
'.'को भी अपडेट '-'या हटाया जाना चाहिए । यह विशेष रूप से उपयोग किए गए मामले का सामना करने के कारण शामिल किया गया था - बहुत कम प्रयास के साथ आप इसे बदल सकते थे preg_replace('/\d{3}/', '$0-', substr($number, 2))और सीधे सवाल का जवाब दे सकते थे।
एक अन्य विकल्प - कॉन्फ़िगरेशन से एक प्रारूप प्राप्त करने के लिए आसानी से अपडेट किया गया।
$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;
}सब,
मुझे लगता है कि मैंने इसे ठीक कर लिया। वर्तमान इनपुट फ़ाइलों के लिए कार्य करना और इसे पूरा करने के लिए 2 कार्यों का पालन करना है!
समारोह 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_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_numberध्यान दें कि मेरे पास यह क्लास के लिब में है, इसलिए इस प्रकार पहले फ़ंक्शन / विधि से "self :: validate_phone_number" कॉल करें।
"Validate_phone_number" फ़ंक्शन की सूचना पंक्ति # 32 जहाँ मैंने जोड़ा:
if ( !$valid['format'] ) {
return false;
} else {यदि मान्य फ़ोन नंबर नहीं है तो मुझे गलत रिटर्न की आवश्यकता होगी।
अभी भी इसे अधिक डेटा के खिलाफ परीक्षण करने की आवश्यकता है, लेकिन वर्तमान डेटा पर काम करना, वर्तमान प्रारूप के साथ और मैं इस विशेष डेटा बैच के लिए शैली '8' का उपयोग कर रहा हूं।
इसके अलावा मैंने "एक्सटेंशन" तर्क पर टिप्पणी की क्योंकि मुझे लगातार इसमें से त्रुटियां मिल रही थीं, यह देखकर कि मेरे डेटा में मुझे कोई जानकारी नहीं है।
यह 7, 10 और 11 अंक लेता है, अतिरिक्त वर्णों को हटाता है और स्ट्रिंग के माध्यम से दाएं से बाएं तक जाकर डैश जोड़ता है। डैश को स्पेस या डॉट में बदलें।
$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;मुझे पता है कि ओपी एक 123-456-7890 प्रारूप का अनुरोध कर रहा है, लेकिन, जॉन डुल के जवाब के आधार पर , मैंने इसे कोष्ठक प्रारूप में फोन नंबर वापस करने के लिए संशोधित किया, उदाहरण के लिए (123) 456-7890। यह केवल 7 और 10 अंकों की संख्या को संभालता है।
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;
}यहाँ मेरा ले रहा है:
$phone='+11234567890';
$parts=sscanf($phone,'%2c%3c%3c%4c');
print "$parts[1]-$parts[2]-$parts[3]";
// 123-456-7890sscanfसमारोह में एक दूसरे पैरामीटर के रूप में एक प्रारूप स्ट्रिंग यह कह रही है कि कैसे पहली स्ट्रिंग से पात्रों की व्याख्या करने लगते हैं। इस स्थिति में, इसका अर्थ है 2 वर्ण ( %2c), 3 वर्ण, 3 वर्ण, 4 वर्ण।
आम तौर पर sscanfफ़ंक्शन में निकाले गए डेटा को पकड़ने के लिए चर भी शामिल होंगे। यदि नहीं, तो डेटा एक सरणी में वापस आ जाता है जिसे मैंने कॉल किया है $parts।
printबयान अंतर्वेशित स्ट्रिंग आउटपुट। $part[0]नजरअंदाज कर दिया है।
मैंने ऑस्ट्रेलियाई फोन नंबरों को प्रारूपित करने के लिए एक समान फ़ंक्शन का उपयोग किया है।
ध्यान दें कि फ़ोन नंबर संग्रहीत करने के दृष्टिकोण से:
यूनाइटेड किंगडम फोन प्रारूप
मेरे द्वारा विकसित किए गए एप्लिकेशन के लिए, मैंने पाया कि लोगों ने मानव पठनीय रूप से अपने फोन नंबर 'सही ढंग से' में प्रवेश किया, लेकिन विभिन्न प्रकार के यादृच्छिक वर्ण जैसे - '' / '' +44 'आदि डाला। समस्या यह थी कि क्लाउड ऐप प्रारूप के बारे में बात करना काफी विशिष्ट था। एक नियमित अभिव्यक्ति का उपयोग करने के बजाय (उपयोगकर्ता के लिए निराशाजनक हो सकता है) मैंने एक ऑब्जेक्ट क्लास बनाया, जो दृढ़ता मॉड्यूल द्वारा संसाधित होने से पहले दर्ज संख्या को सही प्रारूप में संसाधित करता है।
आउटपुट का प्रारूप यह सुनिश्चित करता है कि कोई भी प्राप्त सॉफ़्टवेयर एक पूर्णांक के बजाय आउटपुट को टेक्स्ट के रूप में व्याख्या करता है (जो तब तत्काल शून्य को खो देगा) और प्रारूप ब्रिटिश टेलीकॉम के अनुरूप है संख्या स्वरूपण पर दिशा-निर्देश - जो एक लंबी संख्या को छोटे, आसानी से याद किए गए समूहों में विभाजित करके मानव संस्मरण को सहायता करता है।
+441234567890 (01234) 567 890
02012345678 का उत्पादन (020) 1234 5678
1923123456 का उत्पादन (01923) 123 456
01923123456 का उत्पादन (01923) 123 456
01923hello का यह पाठ है12345456 (01923) 123 456 का उत्पादन
नंबर के एक्सचेंज सेगमेंट का महत्व - कोष्ठकों में - यह है कि यूके और अधिकांश अन्य देशों में, एक ही एक्सचेंज में संख्याओं के बीच कॉल एक्सचेंज सेगमेंट को छोड़ दिया जा सकता है। हालाँकि यह 07, 08 और 09 श्रृंखला के फोन नंबरों पर लागू नहीं होता है।
मुझे यकीन है कि अधिक कुशल समाधान हैं, लेकिन यह एक बहुत विश्वसनीय साबित हुआ है। अंत में टेलीनम फ़ंक्शन को जोड़कर अधिक स्वरूपों को आसानी से समायोजित किया जा सकता है।
इस प्रकार इस प्रक्रिया को कॉलिंग स्क्रिप्ट से लागू किया जाता है
$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;
}
}कृपया रूट आधारित फ़ंक्शन पर एक नज़र डालें जो प्रारूप बदल सकते हैं
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);
}फ़ोन नंबर की जाँच करें
$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;
}