URL के लिए PHP सत्यापन / regex

125

मैं यूआरएल के लिए एक सरल रेगेक्स की तलाश कर रहा हूं, क्या किसी के पास एक काम है जो अच्छी तरह से काम करता है? मैं zend फ्रेमवर्क सत्यापन वर्गों के साथ एक नहीं मिला और कई कार्यान्वयन देखे हैं।

php  regex  url  validation 
— AndreLiem
स्रोत
1
यह एक बहुत अच्छा संसाधन है। विभिन्न पैटर्न और परीक्षणों की बहुत सारी सूची देता है: mathiasbynens.be/demo/url-regex
— omar j

जवाबों:

79

मैंने कुछ परियोजनाओं पर इसका उपयोग किया है, मुझे विश्वास नहीं है कि मैं मुद्दों में चला गया हूं, लेकिन मुझे यकीन है कि यह संपूर्ण नहीं है:

$text = preg_replace(
  '#((https?|ftp)://(\S*?\.\S*?))([\s)\[\]{},;"\':<]|\.\s|$)#i',
  "'<a href=\"$1\" target=\"_blank\">$3</a>$4'",
  $text
);

अंत में यादृच्छिक रद्दी का अधिकांश http://domain.com.एक वाक्य में स्थितियों से निपटने के लिए है (अनुगामी अवधि के मिलान से बचने के लिए)। मुझे यकीन है कि इसे साफ किया जा सकता है लेकिन जब से यह काम किया है। मैंने कमोबेश इसे प्रोजेक्ट से प्रोजेक्ट में कॉपी किया है।

— ओवेन
स्रोत
7
कुछ चीजें जो मुझ पर छपती हैं: एकांतर का उपयोग जहां चरित्र वर्गों को बुलाया जाता है (हर वैकल्पिक मैच बिल्कुल एक चरित्र); और प्रतिस्थापन को बाहरी दोहरे उद्धरण चिह्नों की आवश्यकता नहीं होनी चाहिए (वे केवल regex पर व्यर्थ / ई संशोधक के कारण आवश्यक थे)।
— एलन मूर
1
@ जॉन स्काइप: google.comएक मान्य सापेक्ष URL पथ है, लेकिन एक मान्य पूर्ण URL नहीं है। और मुझे लगता है कि वह वही है जिसकी उसे तलाश है।
— गुम्बो
यह इस मामले में काम नहीं करता है - यह लगने वाला "में शामिल हैं: 3 cantari नोई में albumul <a href=" audio.resursecrestine.ro/cantece/index-autori/andrei-rosu/...>
— बुद्धू
1
@ सोफ्टी कुछ ऐसा http://example.com/somedir/...है जो पूरी तरह से वैध URL है, जिसका नाम फ़ाइल है ...- जो एक वैध फ़ाइल नाम है।
— स्टीफन पी।
मैं आपके पैटर्न का उपयोग करके url को मान्य करने के लिए Zend \ Validator \ Regex का उपयोग कर रहा हूं, लेकिन यह अभी भी http://www.exampleवैध होने का पता लगाता है
— जोको वांडेरो
207

filter_var()स्ट्रिंग एक URL है या नहीं, यह सत्यापित करने के लिए फ़ंक्शन का उपयोग करें :

var_dump(filter_var('example.com', FILTER_VALIDATE_URL));

आवश्यक नहीं होने पर नियमित अभिव्यक्ति का उपयोग करने के लिए यह बुरा अभ्यास है।

संपादित करें : सावधान रहें, यह समाधान यूनिकोड-सुरक्षित नहीं है और एक्सएसएस-सुरक्षित नहीं है। यदि आपको एक जटिल सत्यापन की आवश्यकता है, तो शायद कहीं और देखना बेहतर है।

— स्टानिस्लाव
स्रोत
29
5.2.13 में एक बग है (और मुझे लगता है कि 5.3.2) जो इस पद्धति का उपयोग करके मान्य करने से उन में डैश के साथ यूआरएल को रोकता है।
— मोमिन
14
filter_var test-site.com को अस्वीकार कर देगा , मेरे पास डैश के साथ डोमेन नाम हैं, घरघराहट वे मान्य हैं या नहीं। मुझे नहीं लगता कि किसी url को मान्य करने के लिए फ़िल्टर_वर सबसे अच्छा तरीका है। यह एक url की अनुमति देगा जैसेhttp://www
— सीज़र
4
> यह ' www ' की तरह एक यूआरएल की अनुमति देगा यह ठीक है जब URL ' लोकलहोस्ट ' की तरह है
— स्टैनिस्लाव
12
इस पद्धति के साथ अन्य समस्या यह है कि यह यूनिकोड-सुरक्षित नहीं है।
— बेंजी XVI
3
FILTER_VALIDATE_URL में बहुत सारी समस्याएं हैं जिन्हें ठीक करने की आवश्यकता है। इसके अलावा, झंडे का वर्णन करने वाले डॉक्स वास्तविक स्रोत कोड को प्रतिबिंबित नहीं करते हैं जहां कुछ झंडे के संदर्भ पूरी तरह से हटा दिए गए हैं। अधिक जानकारी यहाँ: news.php.net/php.internals/99018
— S. Imp
29

PHP मैनुअल के अनुसार - URL को सत्यापित करने के लिए parse_url का उपयोग नहीं किया जाना चाहिए ।

दुर्भाग्य से, ऐसा लगता है कि filter_var('example.com', FILTER_VALIDATE_URL)कोई बेहतर प्रदर्शन नहीं करता है।

दोनों parse_url()और filter_var()इस तरह के रूप विकृत यूआरएल पारित करेंगेhttp://...

इसलिए इस मामले में - regex है बेहतर तरीका।

— catchdave
स्रोत
10
इस तर्क का पालन नहीं करता है। यदि FILTER_VALIDATE_URL आपके इच्छित मामलों की तुलना में थोड़ा अधिक अनुमत है, तो आपके अतिरिक्त मामलों से निपटने के लिए कुछ अतिरिक्त जांचों से निपटें। अपने स्वयं के प्रयास के साथ पहिया को फिर से शुरू करने के लिए एक urge के खिलाफ regex पर केवल आपको पूर्ण चेक से आगे प्राप्त करना है।
— कज़कई
2
इस पृष्ठ पर सभी शॉट-डाउन रेग्जेस देखें, क्यों -नहीं- अपने स्वयं के लिखने के लिए।
— कज़कई
3
आप एक उचित बिंदु Tchalvak बनाते हैं। URL जैसी किसी चीज़ के लिए Rexxes (अन्य प्रतिक्रियाओं के अनुसार) सही होने के लिए बहुत कठिन हो सकता है। रेगेक्स हमेशा जवाब नहीं होता है। इसके विपरीत regex भी हमेशा गलत उत्तर नहीं होता है। महत्वपूर्ण बिंदु यह है कि नौकरी के लिए सही टूल (रेगेक्स या अन्यथा) चुनें और विशेष रूप से "एंटी" या "प्रो" रेक्सक्स न हों। बाधा के रूप में, इसके किनारे के मामलों में बाधाओं के साथ संयोजन में filter_var का उपयोग करने का आपका उत्तर, बेहतर उत्तर की तरह दिखता है (विशेषकर जब regex उत्तर 100 से अधिक वर्णों को प्राप्त करना शुरू करते हैं या तो - उक्त regex के रखरखाव को एक बुरा सपना बनाना)
— catchdave
12

यदि आप यह जानना चाहते हैं कि क्या वास्तव में url मौजूद है:

function url_exist($url){//se passar a URL existe
    $c=curl_init();
    curl_setopt($c,CURLOPT_URL,$url);
    curl_setopt($c,CURLOPT_HEADER,1);//get the header
    curl_setopt($c,CURLOPT_NOBODY,1);//and *only* get the header
    curl_setopt($c,CURLOPT_RETURNTRANSFER,1);//get the response as a string from curl_exec(), rather than echoing it
    curl_setopt($c,CURLOPT_FRESH_CONNECT,1);//don't use a cached version of the url
    if(!curl_exec($c)){
        //echo $url.' inexists';
        return false;
    }else{
        //echo $url.' exists';
        return true;
    }
    //$httpcode=curl_getinfo($c,CURLINFO_HTTP_CODE);
    //return ($httpcode<400);
}
— आरे
स्रोत
1
मैं $urlवास्तव में url को वास्तविक बनाने से पहले कुछ इस तरह का सत्यापन करना चाहूंगा, क्योंकि उपरोक्त ऑपरेशन महंगा है - शायद फ़ाइल आकार के आधार पर 200 मिलीसेकंड जितना। कुछ मामलों में url में वास्तव में अभी तक उपलब्ध अपने स्थान पर एक संसाधन नहीं हो सकता है (उदाहरण के लिए एक छवि के लिए एक यूआरएल बनाना जो अभी तक अपलोड नहीं किया गया है)। इसके अतिरिक्त आप एक कैश्ड संस्करण का उपयोग नहीं कर रहे हैं, इसलिए ऐसा नहीं है file_exists()कि एक फ़ाइल पर एक स्टेट को कैश करेगा और लगभग तुरंत वापस आ जाएगा। आपके द्वारा प्रदान किया गया समाधान अभी भी उपयोगी है। सिर्फ उपयोग क्यों नहीं fopen($url, 'r')?
— यजीर रामिरेज़
धन्यवाद, बस मैं क्या देख रहा था। हालाँकि, मैंने इसका उपयोग करने की कोशिश में एक गलती की। समारोह "url_exist" नहीं "url_exists" उफ़; ;-)
— PJ ब्रुनेट
9
क्या उपयोगकर्ता द्वारा दर्ज किए गए URL तक सीधे पहुंचने में कोई सुरक्षा जोखिम है?
— सिलिकॉनपी
यदि कोई 404 पाया गया था, तो आप एक चेक जोड़ना चाहेंगे: <code> $ httpCode = curl_getinfo ($ c, CURLINFO_HTTP_CODE); // इको $ url। ''। $ httpCode। '<br>'; if ($ httpCode == 404) {गूंज $ url। ' 404 '; } </ code>
— Camaleo
बिल्कुल सुरक्षित नहीं है .. किसी भी इनपुट URL को सक्रिय रूप से एक्सेस किया जाएगा।
— dmmd
11

के अनुसार जॉन Gruber (बहादुर फायरबॉल):

regex:

(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))

preg_match () में उपयोग करना:

preg_match("/(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))/", $url)

यहाँ विस्तारित रेगेक्स पैटर्न (टिप्पणियों के साथ) है:

(?xi)
\b
(                       # Capture 1: entire matched URL
  (?:
    https?://               # http or https protocol
    |                       #   or
    www\d{0,3}[.]           # "www.", "www1.", "www2." … "www999."
    |                           #   or
    [a-z0-9.\-]+[.][a-z]{2,4}/  # looks like domain name followed by a slash
  )
  (?:                       # One or more:
    [^\s()<>]+                  # Run of non-space, non-()<>
    |                           #   or
    \(([^\s()<>]+|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
  )+
  (?:                       # End with:
    \(([^\s()<>]+|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
    |                               #   or
    [^\s`!()\[\]{};:'".,<>?«»“”‘’]        # not a space or one of these punct chars
  )
)

अधिक जानकारी के लिए कृपया यहाँ देखें: http://daringfireball.net/2010/07/improved_regex_for_matching_urls

— abhiomkar
स्रोत
9

मुझे नहीं लगता कि इस मामले में नियमित अभिव्यक्ति का उपयोग करना एक स्मार्ट बात है। सभी संभावनाओं का मिलान करना असंभव है और अगर आपने किया भी, तो अभी भी एक मौका है कि url बस मौजूद नहीं है।

यहाँ परीक्षण करने के लिए एक बहुत ही सरल तरीका है यदि url वास्तव में मौजूद है और पठनीय है:

if (preg_match("#^https?://.+#", $link) and @fopen($link,"r")) echo "OK";

(यदि ऐसा नहीं है preg_matchतो यह आपके सर्वर पर सभी फ़ाइलनामों को भी मान्य करेगा)

— promaty
स्रोत
7

मैंने इसे अच्छी सफलता के साथ उपयोग किया है - मुझे याद नहीं है कि मुझे यह कहाँ से मिला है

$pattern = "/\b(?:(?:https?|ftp):\/\/|www\.)[-a-z0-9+&@#\/%?=~_|!:,.;]*[-a-z0-9+&@#\/%=~_|]/i";
— पीटर बेली
स्रोत
^ (http: // | https: //)?? (([एक-Z0-9] ([-एक-Z0-9] * [एक-Z0-9] +)) {1,63} \ ।) + [az] {2,6} (अभी बहुत लालची हो सकता है, अभी तक निश्चित नहीं है, लेकिन यह प्रोटोकॉल पर अधिक लचीला है और www)
— andrewbadera
7 
    function validateURL($URL) {
      $pattern_1 = "/^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i";
      $pattern_2 = "/^(www)((\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i";       
      if(preg_match($pattern_1, $URL) || preg_match($pattern_2, $URL)){
        return true;
      } else{
        return false;
      }
    }
— विकाश कुमार
स्रोत
लिंक के साथ काम नहीं करता है: 'www.w3schools.com/home/3/?a=l'
— user3396065
5

और तुम्हारा जवाब है =) इसे तोड़ने की कोशिश करो, तुम नहीं कर सकते !!!

function link_validate_url($text) {
$LINK_DOMAINS = 'aero|arpa|asia|biz|com|cat|coop|edu|gov|info|int|jobs|mil|museum|name|nato|net|org|pro|travel|mobi|local';
  $LINK_ICHARS_DOMAIN = (string) html_entity_decode(implode("", array( // @TODO completing letters ...
    "&#x00E6;", // æ
    "&#x00C6;", // Æ
    "&#x00C0;", // À
    "&#x00E0;", // à
    "&#x00C1;", // Á
    "&#x00E1;", // á
    "&#x00C2;", // Â
    "&#x00E2;", // â
    "&#x00E5;", // å
    "&#x00C5;", // Å
    "&#x00E4;", // ä
    "&#x00C4;", // Ä
    "&#x00C7;", // Ç
    "&#x00E7;", // ç
    "&#x00D0;", // Ð
    "&#x00F0;", // ð
    "&#x00C8;", // È
    "&#x00E8;", // è
    "&#x00C9;", // É
    "&#x00E9;", // é
    "&#x00CA;", // Ê
    "&#x00EA;", // ê
    "&#x00CB;", // Ë
    "&#x00EB;", // ë
    "&#x00CE;", // Î
    "&#x00EE;", // î
    "&#x00CF;", // Ï
    "&#x00EF;", // ï
    "&#x00F8;", // ø
    "&#x00D8;", // Ø
    "&#x00F6;", // ö
    "&#x00D6;", // Ö
    "&#x00D4;", // Ô
    "&#x00F4;", // ô
    "&#x00D5;", // Õ
    "&#x00F5;", // õ
    "&#x0152;", // Œ
    "&#x0153;", // œ
    "&#x00FC;", // ü
    "&#x00DC;", // Ü
    "&#x00D9;", // Ù
    "&#x00F9;", // ù
    "&#x00DB;", // Û
    "&#x00FB;", // û
    "&#x0178;", // Ÿ
    "&#x00FF;", // ÿ 
    "&#x00D1;", // Ñ
    "&#x00F1;", // ñ
    "&#x00FE;", // þ
    "&#x00DE;", // Þ
    "&#x00FD;", // ý
    "&#x00DD;", // Ý
    "&#x00BF;", // ¿
  )), ENT_QUOTES, 'UTF-8');

  $LINK_ICHARS = $LINK_ICHARS_DOMAIN . (string) html_entity_decode(implode("", array(
    "&#x00DF;", // ß
  )), ENT_QUOTES, 'UTF-8');
  $allowed_protocols = array('http', 'https', 'ftp', 'news', 'nntp', 'telnet', 'mailto', 'irc', 'ssh', 'sftp', 'webcal');

  // Starting a parenthesis group with (?: means that it is grouped, but is not captured
  $protocol = '((?:'. implode("|", $allowed_protocols) .'):\/\/)';
  $authentication = "(?:(?:(?:[\w\.\-\+!$&'\(\)*\+,;=" . $LINK_ICHARS . "]|%[0-9a-f]{2})+(?::(?:[\w". $LINK_ICHARS ."\.\-\+%!$&'\(\)*\+,;=]|%[0-9a-f]{2})*)?)?@)";
  $domain = '(?:(?:[a-z0-9' . $LINK_ICHARS_DOMAIN . ']([a-z0-9'. $LINK_ICHARS_DOMAIN . '\-_\[\]])*)(\.(([a-z0-9' . $LINK_ICHARS_DOMAIN . '\-_\[\]])+\.)*('. $LINK_DOMAINS .'|[a-z]{2}))?)';
  $ipv4 = '(?:[0-9]{1,3}(\.[0-9]{1,3}){3})';
  $ipv6 = '(?:[0-9a-fA-F]{1,4}(\:[0-9a-fA-F]{1,4}){7})';
  $port = '(?::([0-9]{1,5}))';

  // Pattern specific to external links.
  $external_pattern = '/^'. $protocol .'?'. $authentication .'?('. $domain .'|'. $ipv4 .'|'. $ipv6 .' |localhost)'. $port .'?';

  // Pattern specific to internal links.
  $internal_pattern = "/^(?:[a-z0-9". $LINK_ICHARS ."_\-+\[\]]+)";
  $internal_pattern_file = "/^(?:[a-z0-9". $LINK_ICHARS ."_\-+\[\]\.]+)$/i";

  $directories = "(?:\/[a-z0-9". $LINK_ICHARS ."_\-\.~+%=&,$'#!():;*@\[\]]*)*";
  // Yes, four backslashes == a single backslash.
  $query = "(?:\/?\?([?a-z0-9". $LINK_ICHARS ."+_|\-\.~\/\\\\%=&,$'():;*@\[\]{} ]*))";
  $anchor = "(?:#[a-z0-9". $LINK_ICHARS ."_\-\.~+%=&,$'():;*@\[\]\/\?]*)";

  // The rest of the path for a standard URL.
  $end = $directories .'?'. $query .'?'. $anchor .'?'.'$/i';

  $message_id = '[^@].*@'. $domain;
  $newsgroup_name = '(?:[0-9a-z+-]*\.)*[0-9a-z+-]*';
  $news_pattern = '/^news:('. $newsgroup_name .'|'. $message_id .')$/i';

  $user = '[a-zA-Z0-9'. $LINK_ICHARS .'_\-\.\+\^!#\$%&*+\/\=\?\`\|\{\}~\'\[\]]+';
  $email_pattern = '/^mailto:'. $user .'@'.'(?:'. $domain .'|'. $ipv4 .'|'. $ipv6 .'|localhost)'. $query .'?$/';

  if (strpos($text, '<front>') === 0) {
    return false;
  }
  if (in_array('mailto', $allowed_protocols) && preg_match($email_pattern, $text)) {
    return false;
  }
  if (in_array('news', $allowed_protocols) && preg_match($news_pattern, $text)) {
    return false;
  }
  if (preg_match($internal_pattern . $end, $text)) {
    return false;
  }
  if (preg_match($external_pattern . $end, $text)) {
    return false;
  }
  if (preg_match($internal_pattern_file, $text)) {
    return false;
  }

  return true;
}
— जॉर्ज मिलनस
स्रोत
— जेफ पकेट
4

संपादित करें:
जैसा कि घटना ने बताया कि इस कोड को PHP 5.3.0 (2009-06-30) की रिलीज़ के साथ हटा दिया गया है और इसे तदनुसार उपयोग किया जाना चाहिए।

बस मेरे दो सेंट लेकिन मैंने इस फ़ंक्शन को विकसित किया है और कुछ समय के लिए सफलता के साथ इसका उपयोग कर रहा हूं। यह अच्छी तरह से प्रलेखित और अलग है ताकि आप इसे आसानी से बदल सकें।

// Checks if string is a URL
// @param string $url
// @return bool
function isURL($url = NULL) {
    if($url==NULL) return false;

    $protocol = '(http://|https://)';
    $allowed = '([a-z0-9]([-a-z0-9]*[a-z0-9]+)?)';

    $regex = "^". $protocol . // must include the protocol
             '(' . $allowed . '{1,63}\.)+'. // 1 or several sub domains with a max of 63 chars
             '[a-z]' . '{2,6}'; // followed by a TLD
    if(eregi($regex, $url)==true) return true;
    else return false;
}
— फ्रेंकी
स्रोत
1
पीएचपी 6.0.0 में एग्री को हटा दिया जाएगा। और "öäåø" वाले डोमेन आपके फ़ंक्शन के साथ मान्य नहीं होंगे। संभवतः आपको पहले URL को पंचकोश में बदलना चाहिए?
@ विश्वास बिल्कुल सहमत हैं। मैंने यह मार्च में लिखा था और PHP 5.3 केवल जून के अंत में eregi को DEPRECATED के रूप में सेट करता है। धन्यवाद। संपादित करें और अद्यतन करें।
— फ्रेंकी
सही होने पर मुझे सही करें, लेकिन क्या हम अभी भी मान सकते हैं कि TLD में न्यूनतम 2 वर्ण और अधिकतम 6 वर्ण होंगे?
— यजीर रामिरेज़
2
@YzmirRamirez (इन सभी वर्षों के बाद ...) अगर आपको कोई संदेह था, जब आपने अपनी टिप्पणी वहां लिखी थी, तो निश्चित रूप से अब नहीं है, इन दिनों TLD के साथ जैसे कि .photography
— Nick Rice
@NickRice आप सही हैं ... वेब 5 वर्षों में कितना बदल जाता है। अब मैं तब तक इंतजार नहीं कर सकता जब तक कोई TLD नहीं बनाता। supercalifragilisticexpialidocious
— Yzmir Ramirez
4 
function is_valid_url ($url="") {

        if ($url=="") {
            $url=$this->url;
        }

        $url = @parse_url($url);

        if ( ! $url) {


            return false;
        }

        $url = array_map('trim', $url);
        $url['port'] = (!isset($url['port'])) ? 80 : (int)$url['port'];
        $path = (isset($url['path'])) ? $url['path'] : '';

        if ($path == '') {
            $path = '/';
        }

        $path .= ( isset ( $url['query'] ) ) ? "?$url[query]" : '';



        if ( isset ( $url['host'] ) AND $url['host'] != gethostbyname ( $url['host'] ) ) {
            if ( PHP_VERSION >= 5 ) {
                $headers = get_headers("$url[scheme]://$url[host]:$url[port]$path");
            }
            else {
                $fp = fsockopen($url['host'], $url['port'], $errno, $errstr, 30);

                if ( ! $fp ) {
                    return false;
                }
                fputs($fp, "HEAD $path HTTP/1.1\r\nHost: $url[host]\r\n\r\n");
                $headers = fread ( $fp, 128 );
                fclose ( $fp );
            }
            $headers = ( is_array ( $headers ) ) ? implode ( "\n", $headers ) : $headers;
            return ( bool ) preg_match ( '#^HTTP/.*\s+[(200|301|302)]+\s#i', $headers );
        }

        return false;
    }
— Jini
स्रोत
नमस्ते, यह समाधान अच्छा है, और मैंने इसे बढ़ा दिया, लेकिन यह https के लिए मानक पोर्ट को ध्यान में नहीं रखता है: - आपको सुझाव देता है कि आप 80 को '' के साथ बदलें जहां यह पोर्ट का काम करता है
— pgee70
मैंने इस पर एक भिन्नता लागू करना समाप्त कर दिया, क्योंकि मेरे डोमेन को परवाह है कि क्या कोई URL वास्तव में मौजूद है या नहीं :)
— Raz0rwire
2

इस .NET स्टैकऑवरफ्लो प्रश्न से प्रेरित होकर और उस प्रश्न के संदर्भित लेख में यह URI सत्यापनकर्ता है (URI का अर्थ है कि यह URL और URN दोनों को मान्य करता है)।

if( ! preg_match( "/^([a-z][a-z0-9+.-]*):(?:\\/\\/((?:(?=((?:[a-z0-9-._~!$&'()*+,;=:]|%[0-9A-F]{2})*))(\\3)@)?(?=(\\[[0-9A-F:.]{2,}\\]|(?:[a-z0-9-._~!$&'()*+,;=]|%[0-9A-F]{2})*))\\5(?::(?=(\\d*))\\6)?)(\\/(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/]|%[0-9A-F]{2})*))\\8)?|(\\/?(?!\\/)(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/]|%[0-9A-F]{2})*))\\10)?)(?:\\?(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/?]|%[0-9A-F]{2})*))\\11)?(?:#(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/?]|%[0-9A-F]{2})*))\\12)?$/i", $uri ) )
{
    throw new \RuntimeException( "URI has not a valid format." );
}

मैंने इस फ़ंक्शन को सफलतापूर्वक एक ValueObject के अंदर इस फ़ंक्शन Uriका परीक्षण किया है जिसका नाम और परीक्षण मैंने किया है UriTest।

UriTest.php (URL और URN दोनों के लिए वैध और अमान्य मामले शामिल हैं)

<?php

declare( strict_types = 1 );

namespace XaviMontero\ThrasherPortage\Tests\Tour;

use XaviMontero\ThrasherPortage\Tour\Uri;

class UriTest extends \PHPUnit_Framework_TestCase
{
    private $sut;

    public function testCreationIsOfProperClassWhenUriIsValid()
    {
        $sut = new Uri( 'http://example.com' );
        $this->assertInstanceOf( 'XaviMontero\\ThrasherPortage\\Tour\\Uri', $sut );
    }

    /**
     * @dataProvider urlIsValidProvider
     * @dataProvider urnIsValidProvider
     */
    public function testGetUriAsStringWhenUriIsValid( string $uri )
    {
        $sut = new Uri( $uri );
        $actual = $sut->getUriAsString();

        $this->assertInternalType( 'string', $actual );
        $this->assertEquals( $uri, $actual );
    }

    public function urlIsValidProvider()
    {
        return
            [
                [ 'http://example-server' ],
                [ 'http://example.com' ],
                [ 'http://example.com/' ],
                [ 'http://subdomain.example.com/path/?parameter1=value1&parameter2=value2' ],
                [ 'random-protocol://example.com' ],
                [ 'http://example.com:80' ],
                [ 'http://example.com?no-path-separator' ],
                [ 'http://example.com/pa%20th/' ],
                [ 'ftp://example.org/resource.txt' ],
                [ 'file://../../../relative/path/needs/protocol/resource.txt' ],
                [ 'http://example.com/#one-fragment' ],
                [ 'http://example.edu:8080#one-fragment' ],
            ];
    }

    public function urnIsValidProvider()
    {
        return
            [
                [ 'urn:isbn:0-486-27557-4' ],
                [ 'urn:example:mammal:monotreme:echidna' ],
                [ 'urn:mpeg:mpeg7:schema:2001' ],
                [ 'urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66' ],
                [ 'rare-urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66' ],
                [ 'urn:FOO:a123,456' ]
            ];
    }

    /**
     * @dataProvider urlIsNotValidProvider
     * @dataProvider urnIsNotValidProvider
     */
    public function testCreationThrowsExceptionWhenUriIsNotValid( string $uri )
    {
        $this->expectException( 'RuntimeException' );
        $this->sut = new Uri( $uri );
    }

    public function urlIsNotValidProvider()
    {
        return
            [
                [ 'only-text' ],
                [ 'http//missing.colon.example.com/path/?parameter1=value1&parameter2=value2' ],
                [ 'missing.protocol.example.com/path/' ],
                [ 'http://example.com\\bad-separator' ],
                [ 'http://example.com|bad-separator' ],
                [ 'ht tp://example.com' ],
                [ 'http://exampl e.com' ],
                [ 'http://example.com/pa th/' ],
                [ '../../../relative/path/needs/protocol/resource.txt' ],
                [ 'http://example.com/#two-fragments#not-allowed' ],
                [ 'http://example.edu:portMustBeANumber#one-fragment' ],
            ];
    }

    public function urnIsNotValidProvider()
    {
        return
            [
                [ 'urn:mpeg:mpeg7:sch ema:2001' ],
                [ 'urn|mpeg:mpeg7:schema:2001' ],
                [ 'urn?mpeg:mpeg7:schema:2001' ],
                [ 'urn%mpeg:mpeg7:schema:2001' ],
                [ 'urn#mpeg:mpeg7:schema:2001' ],
            ];
    }
}

Uri.php (मान वस्तु)

<?php

declare( strict_types = 1 );

namespace XaviMontero\ThrasherPortage\Tour;

class Uri
{
    /** @var string */
    private $uri;

    public function __construct( string $uri )
    {
        $this->assertUriIsCorrect( $uri );
        $this->uri = $uri;
    }

    public function getUriAsString()
    {
        return $this->uri;
    }

    private function assertUriIsCorrect( string $uri )
    {
        // /programming/30847/regex-to-validate-uris
        // http://snipplr.com/view/6889/regular-expressions-for-uri-validationparsing/

        if( ! preg_match( "/^([a-z][a-z0-9+.-]*):(?:\\/\\/((?:(?=((?:[a-z0-9-._~!$&'()*+,;=:]|%[0-9A-F]{2})*))(\\3)@)?(?=(\\[[0-9A-F:.]{2,}\\]|(?:[a-z0-9-._~!$&'()*+,;=]|%[0-9A-F]{2})*))\\5(?::(?=(\\d*))\\6)?)(\\/(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/]|%[0-9A-F]{2})*))\\8)?|(\\/?(?!\\/)(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/]|%[0-9A-F]{2})*))\\10)?)(?:\\?(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/?]|%[0-9A-F]{2})*))\\11)?(?:#(?=((?:[a-z0-9-._~!$&'()*+,;=:@\\/?]|%[0-9A-F]{2})*))\\12)?$/i", $uri ) )
        {
            throw new \RuntimeException( "URI has not a valid format." );
        }
    }
}

UnitTests चल रहा है

46 परीक्षणों में 65 दावे हैं। सावधानी: वैध के लिए 2 डेटा-प्रदाता और अमान्य अभिव्यक्तियों के लिए 2 अधिक हैं। एक URL के लिए है और दूसरा URNs के लिए है। यदि आप v5.6 * या इससे पहले के PhpUnit के संस्करण का उपयोग कर रहे हैं, तो आपको दो डेटा प्रदाताओं को एक में शामिल करना होगा।

xavi@bromo:~/custom_www/hello-trip/mutant-migrant$ vendor/bin/phpunit
PHPUnit 5.7.3 by Sebastian Bergmann and contributors.

..............................................                    46 / 46 (100%)

Time: 82 ms, Memory: 4.00MB

OK (46 tests, 65 assertions)

कोड कवरेज़

इस नमूने URI चेकर में 100% कोड-कवरेज है।

— ज़ावी मोंटेरो
स्रोत
2 
"/(http(s?):\/\/)([a-z0-9\-]+\.)+[a-z]{2,4}(\.[a-z]{2,4})*(\/[^ ]+)*/i"

  1. (http (s?): //) का अर्थ है http: // या https: //

  2. ((A-z0-9 -] +।) + => 2.0 [a-z0-9-] का अर्थ है किसी भी az वर्ण या कोई 0-9 या (-) चिन्ह)

                 2.1 (+) means the character can be one or more ex: a1w, 
                 a9-,c559s, f)

             2.2 \. is (.)sign

             2.3. the (+) sign after ([a-z0-9\-]+\.) mean do 2.1,2.2,2.3 
                at least 1 time 
              ex: abc.defgh0.ig, aa.b.ced.f.gh. also in case www.yyy.com

             3.[a-z]{2,4} mean a-z at least 2 character but not more than 
                          4 characters for check that there will not be 
                          the case 
                          ex: https://www.google.co.kr.asdsdagfsdfsf

             4.(\.[a-z]{2,4})*(\/[^ ]+)* mean 

               4.1 \.[a-z]{2,4} means like number 3 but start with 
                   (.)sign 

               4.2 * means (\.[a-z]{2,4})can be use or not use never mind

               4.3 \/ means \
               4.4 [^ ] means any character except blank
               4.5 (+) means do 4.3,4.4,4.5 at least 1 times
               4.6 (*) after (\/[^ ]+) mean use 4.3 - 4.5 or not use 
                   no problem

               use for case https://stackoverflow.com/posts/51441301/edit

               5. when you use regex write in "/ /" so it come

    "/(http(s?)://)([a-z0-9-]+.)+[az]{2,4}(.[az]{2,4}) (/ [^] ) / i "

                   6. almost forgot: letter i on the back mean ignore case of 
                  Big letter or small letter ex: A same as a, SoRRy same 
                  as sorry.

नोट: खराब अंग्रेजी के लिए क्षमा करें। मेरा देश इसका अच्छा उपयोग नहीं करता है।

— Some_North_korea_kid
स्रोत
4
क्या आपने देखा कि यह प्रश्न कितना पुराना है? कृपया अपने रेगेक्स की व्याख्या करें, जो उपयोगकर्ता पहले से नहीं जानते हैं, उन्हें बिना विवरण के समझने में कठिन समय होगा।
— निक 3500
1

ठीक है, इसलिए यह थोड़ा और अधिक जटिल है फिर एक सरल रेगेक्स है, लेकिन यह विभिन्न प्रकार के url के लिए अनुमति देता है।

उदाहरण:

जो सभी मान्य के रूप में चिह्नित किया जाना चाहिए।

function is_valid_url($url) {
    // First check: is the url just a domain name? (allow a slash at the end)
    $_domain_regex = "|^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)*(\.[A-Za-z]{2,})/?$|";
    if (preg_match($_domain_regex, $url)) {
        return true;
    }

    // Second: Check if it's a url with a scheme and all
    $_regex = '#^([a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))$#';
    if (preg_match($_regex, $url, $matches)) {
        // pull out the domain name, and make sure that the domain is valid.
        $_parts = parse_url($url);
        if (!in_array($_parts['scheme'], array( 'http', 'https' )))
            return false;

        // Check the domain using the regex, stops domains like "-example.com" passing through
        if (!preg_match($_domain_regex, $_parts['host']))
            return false;

        // This domain looks pretty valid. Only way to check it now is to download it!
        return true;
    }

    return false;
}

ध्यान दें कि प्रोटोकॉल के लिए एक in_array चेक है जिसे आप अनुमति देना चाहते हैं (वर्तमान में केवल http और https उस सूची में हैं)।

var_dump(is_valid_url('google.com'));         // true
var_dump(is_valid_url('google.com/'));        // true
var_dump(is_valid_url('http://google.com'));  // true
var_dump(is_valid_url('http://google.com/')); // true
var_dump(is_valid_url('https://google.com')); // true
— टिम ग्रिनेवल्ड
स्रोत
फेंकता है: ErrorException: अनिर्धारित सूचकांक: यदि प्रोटोकॉल निर्दिष्ट नहीं किया गया है तो योजना है कि मैं यह जांचने का सुझाव देता हूं कि क्या पहले सेट किया गया है।
— 15:33 पर user3396065
@ user3396065, क्या आप कृपया एक उदाहरण इनपुट प्रदान कर सकते हैं जो इसे फेंकता है?
— टिम ग्रैनेवेल्ड
1

सबसे अच्छा URL Regex जो मेरे लिए काम करता है:

function valid_URL($url){
    return preg_match('%^(?:(?:https?|ftp)://)(?:\S+(?::\S*)?@|\d{1,3}(?:\.\d{1,3}){3}|(?:(?:[a-z\d\x{00a1}-\x{ffff}]+-?)*[a-z\d\x{00a1}-\x{ffff}]+)(?:\.(?:[a-z\d\x{00a1}-\x{ffff}]+-?)*[a-z\d\x{00a1}-\x{ffff}]+)*(?:\.[a-z\x{00a1}-\x{ffff}]{2,6}))(?::\d+)?(?:[^\s]*)?$%iu', $url);
}

उदाहरण:

valid_URL('https://twitter.com'); // true
valid_URL('http://twitter.com');  // true
valid_URL('http://twitter.co');   // true
valid_URL('http://t.co');         // true
valid_URL('http://twitter.c');    // false
valid_URL('htt://twitter.com');   // false

valid_URL('http://example.com/?a=1&b=2&c=3'); // true
valid_URL('http://127.0.0.1');    // true
valid_URL('');                    // false
valid_URL(1);                     // false

स्रोत: http://urlregex.com/

— फ्रेड वानेली
स्रोत
0

पीटर रेगेक्स मुझे कई कारणों से सही नहीं लगता। यह डोमेन नाम में सभी प्रकार के विशेष पात्रों की अनुमति देता है और बहुत परीक्षण नहीं करता है।

फ्रेंकी का कार्य मुझे अच्छा लगता है और यदि आप एक फ़ंक्शन नहीं चाहते हैं, तो आप घटकों से एक अच्छा रेगेक्स बना सकते हैं:

^(http://|https://)(([a-z0-9]([-a-z0-9]*[a-z0-9]+)?){1,63}\.)+[a-z]{2,6}

अनकहा लेकिन मुझे लगता है कि काम करना चाहिए।

इसके अलावा, ओवेन का जवाब 100% भी नहीं दिखता है। मैंने regex का डोमेन हिस्सा लिया और इसे Regex परीक्षक उपकरण http://erik.eae.net/playground/regexp/regexp.html पर परीक्षण किया।

मैंने निम्नलिखित पंक्ति लगाई:

(\S*?\.\S*?)

"regexp" अनुभाग और निम्न पंक्ति में:

-hello.com

"नमूना पाठ" अनुभाग के तहत।

परिणाम के माध्यम से ऋण चरित्र की अनुमति दी। क्योंकि \ _ का मतलब किसी भी गैर-स्थान वर्ण से है।

फ्रेंकी से रेगेक्स पर ध्यान दें माइनस को संभालता है क्योंकि इसमें पहले चरित्र के लिए यह हिस्सा है:

[a-z0-9]

जो माइनस या किसी अन्य विशेष चरित्र की अनुमति नहीं देगा।

— joedevon
स्रोत
0

यहां मैंने ऐसा ही किया है। लेकिन मैं इस बात पर ध्यान देना चाहता हूं कि मैं रेगेक्स को लेकर इतना श्योर नहीं हूं। लेकिन यह आपको काम करना चाहिए :)

$pattern = "#((http|https)://(\S*?\.\S*?))(\s|\;|\)|\]|\[|\{|\}|,|”|\"|'|:|\<|$|\.\s)#i";
        $text = preg_replace_callback($pattern,function($m){
                return "<a href=\"$m[1]\" target=\"_blank\">$m[1]</a>$m[4]";
            },
            $text);

इस तरह आपको अपने पैटर्न पर eval मार्कर की आवश्यकता नहीं होगी।

आशा करता हूँ की ये काम करेगा :)

— थॉमस वेंटुरिनी
स्रोत
0

यहां RegEx का उपयोग करके URL सत्यापन के लिए एक सरल वर्ग है और फिर लोकप्रिय RBL (रीयलटाइम ब्लैकहोल सूची) के खिलाफ डोमेन को क्रॉस-रेफरेंस करता है:

इंस्टॉल: 

require 'URLValidation.php';

उपयोग: 

require 'URLValidation.php';
$urlVal = new UrlValidation(); //Create Object Instance

domain()विधि के पैरामीटर के रूप में एक URL जोड़ें और रिटर्न की जांच करें।

$urlArray = ['http://www.bokranzr.com/test.php?test=foo&test=dfdf', 'https://en-gb.facebook.com', 'https://www.google.com'];
foreach ($urlArray as $k=>$v) {

    echo var_dump($urlVal->domain($v)) . ' URL: ' . $v . '<br>';

}

आउटपुट: 

bool(false) URL: http://www.bokranzr.com/test.php?test=foo&test=dfdf
bool(true) URL: https://en-gb.facebook.com
bool(true) URL: https://www.google.com

जैसा कि आप ऊपर देख सकते हैं, www.bokranzr.com को एक RBL के माध्यम से दुर्भावनापूर्ण वेबसाइट के रूप में सूचीबद्ध किया गया है, इसलिए डोमेन को गलत के रूप में वापस किया गया था।

— Kitson88
स्रोत
0

वर्डप्रेस के साथ विकसित होने वाले किसी के लिए, बस उपयोग करें 

esc_url_raw($url) === $url

URL को मान्य करने के लिए ( यहाँ पर वर्डप्रेस का प्रलेखनesc_url_raw )। यह यूआरएल ज्यादा की तुलना में बेहतर संभालती है filter_var($url, FILTER_VALIDATE_URL), क्योंकि यह है यूनिकोड और XSS सुरक्षित। ( यहाँ एक अच्छा लेख है जिसमें सभी समस्याओं का उल्लेख हैfilter_var )।

— thespacecamel
स्रोत
-1

मैंने पाया है कि यह URL से मेल खाने के लिए सबसे उपयोगी है।

^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$
— जेरेमी मूर
स्रोत
1
क्या वह URL से मेल खाएगा जो शुरू होता है ftp:?
— andrewsi
// * \ /? $ /
— शाहबाज
-1

उसके लिए एक PHP देशी फ़ंक्शन है:

$url = 'http://www.yoururl.co.uk/sub1/sub2/?param=1&param2/';

if ( ! filter_var( $url, FILTER_VALIDATE_URL ) ) {
    // Wrong
}
else {
    // Valid
}

फ़िल्टर किए गए डेटा को लौटाता है, या फ़िल्टर विफल होने पर FALSE करता है।

इसे यहां देखें

— Fredmat
स्रोत
यह उत्तर 2008 के उत्तरों में से एक को दोहराता है!
— सस्पेंस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.