URL (Regex) के कुछ हिस्से

132

URL (सिंगल लाइन) दिया गया:
http://test.example.com/dir/subdir/file.html

मैं नियमित अभिव्यक्ति का उपयोग करके निम्नलिखित भागों को कैसे निकाल सकता हूं:

  1. उपडोमेन (परीक्षण)
  2. डोमेन (example.com)
  3. फ़ाइल के बिना पथ (/ dir / subdir /)
  4. फ़ाइल (file.html)
  5. फ़ाइल के साथ पथ (/dir/subdir/file.html)
  6. पथ के बिना URL ( http://test.example.com )
  7. (कोई अन्य जोड़ें जो आपको लगता है कि उपयोगी होगा)

यदि मुझे निम्नलिखित URL दर्ज करना है, तो regex को सही ढंग से काम करना चाहिए: 

http://example.example.com/example/example/example.html
regex  language-agnostic  url 
— pek
स्रोत
यह एक सीधा जवाब नहीं है, लेकिन अधिकांश वेब पुस्तकालयों में एक कार्य है जो इस कार्य को पूरा करता है। फ़ंक्शन को अक्सर कुछ समान कहा जाता है CrackUrl। यदि ऐसा कोई फ़ंक्शन मौजूद है, तो इसका उपयोग करें, यह किसी भी हाथ से तैयार किए गए कोड की तुलना में अधिक विश्वसनीय और अधिक कुशल होने की गारंटी है।
— कोनराड रुडोल्फ
7
कृपया हमें यह समझाएं कि रेगेक्स के साथ ऐसा करने की आवश्यकता क्यों है। यदि यह होमवर्क है, तो यह कहें कि क्योंकि यह आपकी बाधा है। अन्यथा, रेगेक्स का उपयोग करने की तुलना में बेहतर भाषा-विशिष्ट समाधान हैं।
— एंडी लेस्टर
1
पहले और अंतिम नमूने के लिंक टूट गए हैं।
— टिन मैन
यहाँ आप स्कीम, डोमेन, TLD, पोर्ट और क्वेरी पथ निकालने का तरीका पा सकते हैं: stackoverflow.com/questions/9760588/…
— पाओलो रूवेल्ली

जवाबों:

151

एक पूर्ण regex को पार्स करने और क्वेरी पैरामीटर और एंकर सहित एक पूर्ण URL को तोड़ने के लिए

https://www.google.com/dir/1/2/search.html?arg=0-a&arg1=1-b&arg3-c#hash

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(.*)?(#[\w\-]+)?$

RexEx पदों:

url: RegExp ['$ &'],

प्रोटोकॉल:। RegExp $ 2,

मेजबान:। RegExp $ 3,

पथ:। RegExp $ 4,

फ़ाइल:। RegExp $ 6,

क्वेरी:। RegExp $ 7,

हैश:। RegExp $ 8

इसके बाद आप मेजबान ('।' सीमांकित) को बहुत आसानी से पार्स कर सकते हैं।

क्या मैं करना होगा कुछ इस तरह इस्तेमाल होता है:

/*
    ^(.*:)//([A-Za-z0-9\-\.]+)(:[0-9]+)?(.*)$
*/
proto $1
host $2
port $3
the-rest $4

आगे के पार्स 'बाकी' जितना संभव हो उतना विशिष्ट होने के लिए। यह एक रेगेक्स में कर रहा है, ठीक है, थोड़ा पागल है।

— गृहनगर
स्रोत
4
— posts
19
समस्या यह हिस्सा है: (.*)?चूंकि क्लेन स्टार पहले से ही 0 या अधिक स्वीकार करता है, इसलिए ?भाग (0 या 1) इसे भ्रमित कर रहा है। मैंने इसे बदलकर तय (.*)?किया (.+)?। तुम भी बस को दूर कर सकता है?
— rossipedia
3
हाय Dve, मैं इसे थोड़ा और निकालने के लिए सुधार किया है example.com तरह यूआरएल से http://www.example.com:8080/....यहाँ जाता है:^((http[s]?|ftp):\/\/)?\/?([^\/\.]+\.)*?([^\/\.]+\.[^:\/\s\.]{2,3}(\.[^:\/\s\.]{2,3})?(:\d+)?)($|\/)([^#?\s]+)?(.*?)?(#[\w\-]+)?$
— mnacos
4
और सबूत है कि कोई भी regexp सही नहीं है, यहाँ एक तत्काल सुधार है:^((http[s]?|ftp):\/\/)?\/?([^\/\.]+\.)*?([^\/\.]+\.[^:\/\s\.]{2,3}(\.[^:\/\s\.]{2,3})?)(:\d+)?($|\/)([^#?\s]+)?(.*?)?(#[\w\-]+)?$
— mnacos
2
मैंने URL (सुधार किए गए संस्करण) के सभी हिस्सों की पहचान करने के लिए इस regex को संशोधित किया - Python में कोड ^((?P<scheme>[^:/?#]+):(?=//))?(//)?(((?P<login>[^:]+)(?::(?P<password>[^@]+)?)?@)?(?P<host>[^@/?#:]*)(?::(?P<port>\d+)?)?)?(?P<path>[^?#]*)(\?(?P<query>[^#]*))?(#(?P<fragment>.*))? code आपने pythex.org
— arannasousa
81

मुझे एहसास है कि मुझे पार्टी में देर हो रही है, लेकिन ब्राउज़र को एक रेगेक्स के बिना आपके लिए यूआरएल लिखने देने का एक सरल तरीका है:

var a = document.createElement('a');
a.href = 'http://www.example.com:123/foo/bar.html?fox=trot#foo';

['href','protocol','host','hostname','port','pathname','search','hash'].forEach(function(k) {
    console.log(k+':', a[k]);
});

/*//Output:
href: http://www.example.com:123/foo/bar.html?fox=trot#foo
protocol: http:
host: www.example.com:123
hostname: www.example.com
port: 123
pathname: /foo/bar.html
search: ?fox=trot
hash: #foo
*/
— लूटना
स्रोत
9
यह देखते हुए कि मूल प्रश्न "भाषा-अज्ञेय" को टैग किया गया था, यह कौन सी भाषा है?
— MarkHu
ध्यान दें कि इस समाधान के लिए प्रोटोकॉल उपसर्ग के अस्तित्व की आवश्यकता है, उदाहरण के लिए http://, प्रोटोकॉल, होस्ट और होस्टनाम गुणों के सही प्रदर्शन के लिए। अन्यथा पहली स्लैश तक url की शुरुआत प्रोटोकॉल की संपत्ति में जाती है।
— Oleksii Aza
मेरा मानना ​​है कि, हालांकि, RegEx पार्सिंग की तुलना में सरल, लेकिन बहुत धीमी है।
— डेविक्स
क्या यह सभी ब्राउज़रों द्वारा समर्थित है?
— शॉन
1
अगर हम इस तरह से जा रहे हैं तो आप भी कर सकते हैंvar url = new URL(someUrl)
— gman
67

मुझे पार्टी में कुछ साल हो गए हैं, लेकिन मुझे आश्चर्य है कि किसी ने भी यूनिफ़ॉर्म रिसोर्स आइडेंटिफ़ायर स्पेसिफिकेशन का उल्लेख नहीं किया है, जिसमें यूआरआई को नियमित अभिव्यक्ति के साथ पार्स करने पर एक सेक्शन है । बर्नर्स-ली, एट अल।, द्वारा लिखित नियमित अभिव्यक्ति है:

^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9

ऊपर की दूसरी पंक्ति में संख्या केवल पठनीयता की सहायता के लिए है; वे प्रत्येक उपसंचाई (यानी, प्रत्येक युग्मित कोष्ठक) के लिए संदर्भ बिंदुओं को इंगित करते हैं। हम $ के रूप में सब-डेप्रिसिएशन के लिए मिलान किए गए मूल्य का उल्लेख करते हैं। उदाहरण के लिए, उपरोक्त अभिव्यक्ति का मिलान करना

http://www.ics.uci.edu/pub/ietf/uri/#Related

निम्नलिखित सबडिप्रेशन मैच में परिणाम:

$1 = http:
$2 = http
$3 = //www.ics.uci.edu
$4 = www.ics.uci.edu
$5 = /pub/ietf/uri/
$6 = <undefined>
$7 = <undefined>
$8 = #Related
$9 = Related

इसके लायक क्या है, मैंने पाया कि मुझे जावास्क्रिप्ट में आगे की स्लैश से बचना था:

^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?

— GWG
स्रोत
4
बहुत बढ़िया जवाब! एक RFC से कुछ चुनना निश्चित रूप से गलत काम करने के लिए कभी भी बुरा नहीं हो सकता है
— खुलकर
1
यह क्वेरी पैरामीटर
— रेमी
2
यह सबसे अच्छा एक afaict है। विशेष रूप से यह दो समस्याओं को स्वीकार करता है जो मैंने दूसरों के साथ देखी हैं 1: यह अन्य प्रोटोकॉल के साथ सही तरीके से संबंधित है, जैसे ftp://और mailto://। 2: यह सही ढंग से usernameऔर के साथ संबंधित है password। ये वैकल्पिक फ़ील्ड होस्टनाम और पोर्ट की तरह, एक बृहदान्त्र द्वारा अलग किए जाते हैं, और यह मेरे द्वारा देखे गए अधिकांश अन्य रेगेक्स की यात्रा करेगा। @ RémyDAVID querystring भी ब्राउज़र locationऑब्जेक्ट द्वारा सामान्य रूप से पार्स नहीं किया जाता है । यदि आपको क्वेरी स्ट्रिंग को पार्स करने की आवश्यकता है, तो इसके लिए मेरी छोटी लाइब्रेरी पर एक नज़र डालें: uqs ।
— स्टिजन डे विट
2
यह उत्तर अधिक वोटों का हकदार है क्योंकि इसमें सभी प्रोटोकॉल शामिल हैं।
— तियानजिन लिन
1
यह तब टूटता है जब प्रोटोकॉल को यूज़रनेम / पासवर्ड (एक गूढ़ और तकनीकी रूप से अमान्य वाक्यविन्यास, I के साथ HTTP निहित है) :, जैसे user:pass@example.com- RFC 3986 कहता है:A path segment that contains a colon character (e.g., "this:that") cannot be used as the first segment of a relative-path reference, as it would be mistaken for a scheme name. Such a segment must be preceded by a dot-segment (e.g., "./this:that") to make a relative- path reference.
— मैट चेम्बर्स
33

मुझे सबसे अधिक मतदान का जवाब मिला (गृहनगर का जवाब) मेरे लिए पूरी तरह से काम नहीं करता है। दो समस्याएं:

  1. यह पोर्ट नंबर को हैंडल नहीं कर सकता है।
  2. हैश वाला हिस्सा टूट गया है।

निम्नलिखित एक संशोधित संस्करण है:

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$

भागों की स्थिति इस प्रकार है:

int SCHEMA = 2, DOMAIN = 3, PORT = 5, PATH = 6, FILE = 8, QUERYSTRING = 9, HASH = 12

Anon उपयोगकर्ता द्वारा पोस्ट किया गया संपादन:

function getFileName(path) {
    return path.match(/^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/[\w\/-]+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$/i)[8];
}
— mingfai
स्रोत
1
सावधान रहें कि यदि डोमेन के बाद URL में पथ नहीं है तो यह काम नहीं करता है - उदाहरण के लिए http://www.example.comया यदि पथ एकल वर्ण जैसा है http://www.example.com/a।
— फर्नांडो कोर्रेइया
11

मुझे सभी url से मेल खाने के लिए एक नियमित अभिव्यक्ति की आवश्यकता थी और इसने इसे बनाया:

/(?:([^\:]*)\:\/\/)?(?:([^\:\@]*)(?:\:([^\@]*))?\@)?(?:([^\/\:]*)\.(?=[^\.\/\:]*\.[^\.\/\:]*))?([^\.\/\:]*)(?:\.([^\/\.\:]*))?(?:\:([0-9]*))?(\/[^\?#]*(?=.*?\/)\/)?([^\?#]*)?(?:\?([^#]*))?(?:#(.*))?/

यह सभी यूआरएल, किसी भी प्रोटोकॉल से मेल खाता है, यहां तक ​​कि जैसे यूआरएल

ftp://user:pass@www.cs.server.com:8080/dir1/dir2/file.php?param1=value1#hashtag

परिणाम (जावास्क्रिप्ट में) इस तरह दिखता है:

["ftp", "user", "pass", "www.cs", "server", "com", "8080", "/dir1/dir2/", "file.php", "param1=value1", "hashtag"]

एक यूआरएल की तरह

mailto://admin@www.cs.server.com

इस तरह दिखता है:

["mailto", "admin", undefined, "www.cs", "server", "com", undefined, undefined, undefined, undefined, undefined]
— baadf00d
स्रोत
3
यदि आप पूरे डोमेन / आईपी पते (डॉट्स द्वारा अलग नहीं किए गए) से मेल खाना चाहते हैं, तो इस का उपयोग करें:/(?:([^\:]*)\:\/\/)?(?:([^\:\@]*)(?:\:([^\@]*))?\@)?(?:([^\/\:]*))?(?:\:([0-9]*))?\/(\/[^\?#]*(?=.*?\/)\/)?([^\?#]*)?(?:\?([^#]*))?(?:#(.*))?/
— lep
11

मैं इसे जावास्क्रिप्ट में हल करने की कोशिश कर रहा था, जिसे इसके द्वारा नियंत्रित किया जाना चाहिए:

var url = new URL('http://a:b@example.com:890/path/wah@t/foo.js?foo=bar&bingobang=&king=kong@kong.com#foobar/bing/bo@ng?bang');

चूंकि (क्रोम में, कम से कम) यह पार्स करता है:

{
  "hash": "#foobar/bing/bo@ng?bang",
  "search": "?foo=bar&bingobang=&king=kong@kong.com",
  "pathname": "/path/wah@t/foo.js",
  "port": "890",
  "hostname": "example.com",
  "host": "example.com:890",
  "password": "b",
  "username": "a",
  "protocol": "http:",
  "origin": "http://example.com:890",
  "href": "http://a:b@example.com:890/path/wah@t/foo.js?foo=bar&bingobang=&king=kong@kong.com#foobar/bing/bo@ng?bang"
}

हालाँकि, यह क्रॉस ब्राउज़र ( https://developer.mozilla.org/en-US/docs/Web/API/URL ) नहीं है, इसलिए मैंने ऊपर के समान हिस्सों को खींचने के लिए इसे एक साथ सिल दिया था:

^(?:(?:(([^:\/#\?]+:)?(?:(?:\/\/)(?:(?:(?:([^:@\/#\?]+)(?:\:([^:@\/#\?]*))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?

इस रेगेक्स का श्रेय https://gist.github.com/rpflorence को जाता है जिन्होंने इस jsperf को पोस्ट किया है http://jsperf.com/url-parsing (मूल रूप से यहां पाया गया: https://gist.github.com/jlong/2428561 # टिप्पणी -310066 ) जो रेगेक्स के साथ आया था, यह मूल रूप से आधारित था।

भागों इस क्रम में हैं:

var keys = [
    "href",                    // http://user:pass@host.com:81/directory/file.ext?query=1#anchor
    "origin",                  // http://user:pass@host.com:81
    "protocol",                // http:
    "username",                // user
    "password",                // pass
    "host",                    // host.com:81
    "hostname",                // host.com
    "port",                    // 81
    "pathname",                // /directory/file.ext
    "search",                  // ?query=1
    "hash"                     // #anchor
];

एक छोटा पुस्तकालय भी है जो इसे लपेटता है और क्वेरी परम प्रदान करता है:

https://github.com/sadams/lite-url (बोवर पर भी उपलब्ध)

यदि आपके पास एक सुधार है, तो कृपया अधिक परीक्षणों के साथ एक पुल अनुरोध बनाएं और मैं धन्यवाद के साथ स्वीकार और विलय करूंगा।

— सैम एडम्स
स्रोत
यह बहुत अच्छा है लेकिन वास्तव में इस तरह के एक संस्करण के साथ कर सकता है जो डुप्लिकेटेड होस्ट, होस्टनाम के बजाय उप-डोमेन को बाहर निकालता है। इसलिए अगर मैं http://test1.dev.mydomain.com/उदाहरण के लिए इसे बाहर निकालता test1.dev.।
— लैंकिमार्ट
यह बहुत अच्छा काम करता है। मैं यूआरएल से असामान्य सामान्य मापदंडों को निकालने का एक तरीका ढूंढ रहा हूं, और यह खूबसूरती से काम करता है।
— हारून M
6

बहुत अधिक पठनीय समाधान प्रस्तावित करें (पायथन में, लेकिन किसी भी रेगेक्स पर लागू होता है):

def url_path_to_dict(path):
    pattern = (r'^'
               r'((?P<schema>.+?)://)?'
               r'((?P<user>.+?)(:(?P<password>.*?))?@)?'
               r'(?P<host>.*?)'
               r'(:(?P<port>\d+?))?'
               r'(?P<path>/.*?)?'
               r'(?P<query>[?].*?)?'
               r'$'
               )
    regex = re.compile(pattern)
    m = regex.match(path)
    d = m.groupdict() if m is not None else None

    return d

def main():
    print url_path_to_dict('http://example.example.com/example/example/example.html')

प्रिंटों: 

{
'host': 'example.example.com', 
'user': None, 
'path': '/example/example/example.html', 
'query': None, 
'password': None, 
'port': None, 
'schema': 'http'
}
— okigan
स्रोत
5

उपडोमेन और डोमेन मुश्किल है क्योंकि उपडोमेन के कई भाग हो सकते हैं, जैसा कि शीर्ष स्तर डोमेन, http://sub1.sub2.domain.co.uk/

 the path without the file : http://[^/]+/((?:[^/]+/)*(?:[^/]+$)?)  
 the file : http://[^/]+/(?:[^/]+/)*((?:[^/.]+\.)+[^/.]+)$  
 the path with the file : http://[^/]+/(.*)  
 the URL without the path : (http://[^/]+/)

(मार्कडाउन रेगेक्स के लिए बहुत अनुकूल नहीं है)

— tgmdbm
स्रोत
2
बहुत उपयोगी - मैंने (http(s?)://[^/]+/)https
— Mojowen
5

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

   // Applies to URI, not just URL or URN:
   //    http://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Relationship_to_URL_and_URN
   //
   // http://labs.apache.org/webarch/uri/rfc/rfc3986.html#regexp
   //
   // (?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?
   //
   // http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax
   //
   // $@ matches the entire uri
   // $1 matches scheme (ftp, http, mailto, mshelp, ymsgr, etc)
   // $2 matches authority (host, user:pwd@host, etc)
   // $3 matches path
   // $4 matches query (http GET REST api, etc)
   // $5 matches fragment (html anchor, etc)
   //
   // Match specific schemes, non-optional authority, disallow white-space so can delimit in text, and allow 'www.' w/o scheme
   // Note the schemes must match ^[^\s|:/?#]+(?:\|[^\s|:/?#]+)*$
   //
   // (?:()(www\.[^\s/?#]+\.[^\s/?#]+)|(schemes)://([^\s/?#]*))([^\s?#]*)(?:\?([^\s#]*))?(#(\S*))?
   //
   // Validate the authority with an orthogonal RegExp, so the RegExp above won’t fail to match any valid urls.
   function uriRegExp( flags, schemes/* = null*/, noSubMatches/* = false*/ )
   {
      if( !schemes )
         schemes = '[^\\s:\/?#]+'
      else if( !RegExp( /^[^\s|:\/?#]+(?:\|[^\s|:\/?#]+)*$/ ).test( schemes ) )
         throw TypeError( 'expected URI schemes' )
      return noSubMatches ? new RegExp( '(?:www\\.[^\\s/?#]+\\.[^\\s/?#]+|' + schemes + '://[^\\s/?#]*)[^\\s?#]*(?:\\?[^\\s#]*)?(?:#\\S*)?', flags ) :
         new RegExp( '(?:()(www\\.[^\\s/?#]+\\.[^\\s/?#]+)|(' + schemes + ')://([^\\s/?#]*))([^\\s?#]*)(?:\\?([^\\s#]*))?(?:#(\\S*))?', flags )
   }

   // http://en.wikipedia.org/wiki/URI_scheme#Official_IANA-registered_schemes
   function uriSchemesRegExp()
   {
      return 'about|callto|ftp|gtalk|http|https|irc|ircs|javascript|mailto|mshelp|sftp|ssh|steam|tel|view-source|ymsgr'
   }
— शेल्बी मूर
स्रोत
5

निम्नलिखित आज़माएँ:

^((ht|f)tp(s?)\:\/\/|~/|/)?([\w]+:\w+@)?([a-zA-Z]{1}([\w\-]+\.)+([\w]{2,5}))(:[\d]{1,5})?((/?\w+/)+|/?)(\w+\.[\w]{3,4})?((\?\w+=\w+)?(&\w+=\w+)*)?

यह HTTP / FTP, subdomains, फ़ोल्डरों, फाइलों आदि का समर्थन करता है।

मुझे यह त्वरित Google खोज से मिला:

http://geekswithblogs.net/casualjim/archive/2005/12/01/61722.aspx

— मार्क इनग्राम
स्रोत
4 
/^((?P<scheme>https?|ftp):\/)?\/?((?P<username>.*?)(:(?P<password>.*?)|)@)?(?P<hostname>[^:\/\s]+)(?P<port>:([^\/]*))?(?P<path>(\/\w+)*\/)(?P<filename>[-\w.]+[^#?\s]*)?(?P<query>\?([^#]*))?(?P<fragment>#(.*))?$/

एक ऐसे ही सवाल पर मेरे जवाब से । उल्लेख किए गए कुछ अन्य की तुलना में बेहतर काम करता है क्योंकि उनके पास कुछ कीड़े थे (जैसे कि उपयोगकर्ता नाम / पासवर्ड का समर्थन नहीं करना, एकल-वर्ण फ़ाइलनामों का समर्थन नहीं करना, खंड पहचानकर्ता टूट जाना)।

— strager
स्रोत
2

आप .NET में Uri ऑब्जेक्ट का उपयोग करके सभी http / https, होस्ट, पोर्ट, पथ और क्वेरी प्राप्त कर सकते हैं। बस मुश्किल काम मेजबान को उप डोमेन, डोमेन नाम और TLD में तोड़ना है।

ऐसा करने के लिए कोई मानक नहीं है और केवल सही परिणाम का उत्पादन करने के लिए स्ट्रिंग पार्सिंग या RegEx का उपयोग नहीं किया जा सकता है। सबसे पहले, मैं RegEx फ़ंक्शन का उपयोग कर रहा हूं लेकिन सभी URL सबडोमेन को सही ढंग से पार्स नहीं कर सकते हैं। अभ्यास तरीका TLDs की सूची का उपयोग करना है। URL के लिए एक TLD के बाद परिभाषित किया गया है कि बाएं भाग डोमेन है और शेष उप डोमेन है।

हालाँकि सूची में इसे बनाए रखने की आवश्यकता है क्योंकि नए टीएलडी संभव है। वर्तमान समय में मुझे पता है publicsuffix.org नवीनतम सूची को बनाए रखता है और आप डोमेननेम-पार्सर टूल का उपयोग कर सकते हैं, जो Google कोड से सार्वजनिक प्रत्यय सूची को पार्स कर सकते हैं और DomainName ऑब्जेक्ट का उपयोग करके आसानी से उप डोमेन, डोमेन और TLD प्राप्त कर सकते हैं: domainName.SubDomain, domainName .Domain और domainName.TLD

यह उत्तर भी उपयोगी है: एक URL से उपडोमेन प्राप्त करें

CaLLMeLaNN

— CallMeLaNN
स्रोत
2

यहाँ एक है जो पूरा हो गया है, और किसी भी प्रोटोकॉल पर निर्भर नहीं है।

function getServerURL(url) {
        var m = url.match("(^(?:(?:.*?)?//)?[^/?#;]*)");
        console.log(m[1]) // Remove this
        return m[1];
    }

getServerURL("http://dev.test.se")
getServerURL("http://dev.test.se/")
getServerURL("//ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js")
getServerURL("//")
getServerURL("www.dev.test.se/sdas/dsads")
getServerURL("www.dev.test.se/")
getServerURL("www.dev.test.se?abc=32")
getServerURL("www.dev.test.se#abc")
getServerURL("//dev.test.se?sads")
getServerURL("http://www.dev.test.se#321")
getServerURL("http://localhost:8080/sads")
getServerURL("https://localhost:8080?sdsa")

प्रिंटों

http://dev.test.se

http://dev.test.se

//ajax.googleapis.com

//

www.dev.test.se

www.dev.test.se

www.dev.test.se

www.dev.test.se

//dev.test.se

http://www.dev.test.se

http://localhost:8080

https://localhost:8080
— mmm
स्रोत
2

उपरोक्त में से किसी ने भी मेरे लिए काम नहीं किया। यहाँ मैंने क्या उपयोग किया है:

/^(?:((?:https?|s?ftp):)\/\/)([^:\/\s]+)(?::(\d*))?(?:\/([^\s?#]+)?([?][^?#]*)?(#.*)?)?/
— Skone
स्रोत
2

मुझे रेगेक्स पसंद है जो "जावास्क्रिप्ट: द गुड पार्ट्स" में प्रकाशित हुआ था। यह बहुत छोटा नहीं है और बहुत जटिल भी नहीं है। इस पृष्ठ पर github का जावास्क्रिप्ट कोड भी है जो इसका उपयोग करता है। लेकिन यह किसी भी भाषा के लिए अनुकूलित किया जाना चाहिए। https://gist.github.com/voodooGQ/4057330

— Yetti99
स्रोत
1

जावा एक URL वर्ग प्रदान करता है जो ऐसा करेगा। क्वेरी URL ऑब्जेक्ट्स।

साइड नोट पर, PHP parse_url () प्रदान करता है ।

— क्रिस बार्टो
स्रोत
ऐसा लगता है कि यह हालांकि उपडोमेन को पार्स नहीं करता है?
— क्रिस डट्रो
पूछने वाले ने रेगेक्स मांगा। जब आप इसे बनाएंगे तो URL क्लास एक कनेक्शन खोलेगा।
— 4
"जब आप इसे बनाते हैं तो URL क्लास एक कनेक्शन खोलेगा" - यह गलत है, केवल तभी जब आप कनेक्ट जैसे तरीकों को कॉल करते हैं ()। लेकिन यह सच है कि java.net.URL कुछ भारी है। इस उपयोग के मामले के लिए, java.net.URI बेहतर है।
— jcsahnwaldt
1

मैं regex का उपयोग नहीं करने की सलाह दूंगा। WinHttpCrackUrl () की तरह एक एपीआई कॉल कम त्रुटि प्रवण है।

http://msdn.microsoft.com/en-us/library/aa384092%28VS.85%29.aspx

— जेसन
स्रोत
5
और भी बहुत विशिष्ट मंच।
— एंडीर
2
मुझे लगता है कि बिंदु एक पुस्तकालय का उपयोग करने के लिए था, बजाय पहिया को सुदृढ़ करने के। रूबी, पायथन, पर्ल के पास अलग-अलग URL को फाड़ने के लिए उपकरण हैं इसलिए खराब पैटर्न को लागू करने के बजाय उन्हें पकड़ो।
— टिन मैन
1

मैंने इनमें से कुछ को आज़माया जो मेरी ज़रूरतों को पूरा नहीं करते थे, विशेष रूप से सबसे अधिक मतदान किया गया जो बिना किसी पथ के यूआरएल को नहीं पकड़ता था ( http://example.com/ )

समूह के नामों की भी कमी से इसे अनुपयोगी बना दिया जा सकता है (या शायद मेरे jinja2 कौशल की कमी है)।

इसलिए यह मेरा संस्करण है जो स्रोत के साथ थोड़ा संशोधित किया गया है, यहां सबसे अधिक मतदान संस्करण है:

^((?P<protocol>http[s]?|ftp):\/)?\/?(?P<host>[^:\/\s]+)(?P<path>((\/\w+)*\/)([\w\-\.]+[^#?\s]+))*(.*)?(#[\w\-]+)?$
— गिल ज़ेलर
स्रोत
0

Http://www.fileformat.info/tool/regex.htm hometoast का regex का उपयोग करना बेहतरीन काम करता है।

लेकिन यहां सौदा है, मैं अपने कार्यक्रम में विभिन्न स्थितियों में अलग-अलग रेगेक्स पैटर्न का उपयोग करना चाहता हूं।

उदाहरण के लिए, मेरे पास यह URL है, और मेरे पास एक संसेचन है जो मेरे कार्यक्रम में सभी समर्थित URL को सूचीबद्ध करता है। गणना में प्रत्येक ऑब्जेक्ट में एक विधि getRegexPattern होती है जो regex पैटर्न को लौटाती है जिसका उपयोग तब URL के साथ तुलना करने के लिए किया जाएगा। यदि विशेष रेगेक्स पैटर्न सही है, तो मुझे पता है कि यह URL मेरे प्रोग्राम द्वारा समर्थित है। इसलिए, प्रत्येक गणना में यह URL के अंदर कहाँ दिखना चाहिए, इसके आधार पर इसका स्वयं का regex है।

Hometoast का सुझाव बहुत अच्छा है, लेकिन मेरे मामले में, मुझे लगता है कि यह मदद नहीं करेगा (जब तक कि मैं सभी गणनाओं में एक ही rexx पेस्ट नहीं कर देता)।

यही कारण है कि मैं प्रत्येक स्थिति के लिए रेगेक्स को अलग से देने के लिए उत्तर चाहता था। हालांकि गृहनगर के लिए +1। ;)

— pek
स्रोत
0

मुझे पता है कि आप इस पर भाषा-अज्ञेयवाद का दावा कर रहे हैं, लेकिन क्या आप हमें बता सकते हैं कि आप क्या उपयोग कर रहे हैं, इसलिए हम जानते हैं कि आपके पास कौन सी क्षमताएँ हैं?

यदि आपके पास गैर-कैप्चरिंग मैचों के लिए क्षमताएँ हैं, तो आप गृहनगर की अभिव्यक्ति को संशोधित कर सकते हैं, ताकि आपके द्वारा कैप्चरिंग में रुचि न रखने वाले सबएक्सप्रेस को इस तरह सेट किया जाए:

(?:SOMESTUFF)

आपको अभी भी Regex को कई स्थानों पर कॉपी और पेस्ट (और थोड़ा संशोधित) करना होगा, लेकिन यह समझ में आता है - आप सिर्फ यह देखने के लिए जाँच नहीं कर रहे हैं कि क्या उपप्रकार मौजूद है, बल्कि यदि वह URL के हिस्से के रूप में मौजूद है । उप-संदर्भों के लिए गैर-कैप्चरिंग संशोधक का उपयोग करना आपको वह दे सकता है जिसकी आपको आवश्यकता है और इससे अधिक कुछ नहीं, जो कि अगर मैं आपको सही ढंग से पढ़ रहा हूं, तो आप यही चाहते हैं।

एक छोटे, छोटे नोट के रूप में, होमटॉस्ट की अभिव्यक्ति को 'https' के लिए 's' के चारों ओर कोष्ठक लगाने की आवश्यकता नहीं है, क्योंकि उसके पास केवल एक वर्ण है। क्वांटिफ़ायर एक वर्ण (या वर्ण वर्ग या उपप्रकार) को सीधे पूर्ववर्ती करते हैं। इसलिए:

https?

'http' या 'https' का मिलान ठीक होगा।

— ब्रायन वारशॉ
स्रोत
0

फ़ाइल के बिना URL पथ प्राप्त करने के लिए regexp।

url = ' http: // domain / dir1 / dir2 / somefile ' url.scan (/ ^ (http: // [^ /] +) ((?: / [^ ^]] + (? = /)) ? /? (? [^ /] +)? $ / i) .to_s

यह इस यूआरएल के लिए एक रिश्तेदार पथ जोड़ने के लिए उपयोगी हो सकता है।

0

पूर्ण पार्सिंग करने का रेगेक्स काफी भयावह है। मैंने पठनीयता के लिए बैकरेफरेंस का नाम शामिल किया है, और प्रत्येक भाग को अलग-अलग लाइनों में तोड़ दिया है, लेकिन यह अभी भी इस तरह दिखता है:

^(?:(?P<protocol>\w+(?=:\/\/))(?::\/\/))?
(?:(?P<host>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^\/?#:]+)(?::(?P<port>[0-9]+))?)\/)?
(?:(?P<path>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)\/)?
(?P<file>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)
(?:\?(?P<querystring>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^#])+))?
(?:#(?P<fragment>.*))?$

इस क्रिया को करने के लिए जिस चीज की आवश्यकता होती है वह यह है कि प्रोटोकॉल या पोर्ट को छोड़कर, किसी भी हिस्से में HTML इकाइयाँ हो सकती हैं, जो टुकड़े के विखंडन को काफी पेचीदा बना देती हैं। तो पिछले कुछ मामलों में - मेजबान, पथ, फ़ाइल, क्वेरी स्ट्रिंग, और टुकड़ा, हम या तो किसी भी html इकाई या किसी चरित्र है कि नहीं एक के लिए अनुमति देने ?या #। Html इकाई के लिए रेगेक्स इस तरह दिखता है:

$htmlentity = "&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);"

जब इसे निकाला जाता है (मैंने इसे दर्शाने के लिए मूंछ के सिंटैक्स का उपयोग किया है), यह थोड़ा अधिक सुपाठ्य हो जाता है:

^(?:(?P<protocol>(?:ht|f)tps?|\w+(?=:\/\/))(?::\/\/))?
(?:(?P<host>(?:{{htmlentity}}|[^\/?#:])+(?::(?P<port>[0-9]+))?)\/)?
(?:(?P<path>(?:{{htmlentity}}|[^?#])+)\/)?
(?P<file>(?:{{htmlentity}}|[^?#])+)
(?:\?(?P<querystring>(?:{{htmlentity}};|[^#])+))?
(?:#(?P<fragment>.*))?$

जावास्क्रिप्ट में, निश्चित रूप से, आप नाम का उपयोग नहीं कर सकते, इसलिए रेगेक्स बन जाता है

^(?:(\w+(?=:\/\/))(?::\/\/))?(?:((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^\/?#:]+)(?::([0-9]+))?)\/)?(?:((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)\/)?((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)(?:\?((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^#])+))?(?:#(.*))?$

और प्रत्येक मैच में, प्रोटोकॉल है \1, होस्ट है \2, पोर्ट है \3, पथ है \4, फ़ाइल है \5, क्लेरिस्ट्रिंग है \6, और टुकड़ा है \7।

— स्टीव के
स्रोत
0 
//USING REGEX
/**
 * Parse URL to get information
 *
 * @param   url     the URL string to parse
 * @return  parsed  the URL parsed or null
 */
var UrlParser = function (url) {
    "use strict";

    var regx = /^(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
        matches = regx.exec(url),
        parser = null;

    if (null !== matches) {
        parser = {
            href              : matches[0],
            withoutHash       : matches[1],
            url               : matches[2],
            origin            : matches[3],
            protocol          : matches[4],
            protocolseparator : matches[5],
            credhost          : matches[6],
            cred              : matches[7],
            user              : matches[8],
            pass              : matches[9],
            host              : matches[10],
            hostname          : matches[11],
            port              : matches[12],
            pathname          : matches[13],
            segment1          : matches[14],
            segment2          : matches[15],
            search            : matches[16],
            hash              : matches[17]
        };
    }

    return parser;
};

var parsedURL=UrlParser(url);
console.log(parsedURL);
— मोहन मु
स्रोत
0

मैंने url विभाजन पार्स करने के लिए इस regex की कोशिश की:

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*))(\?([^#]*))?(#(.*))?$

यूआरएल: https://www.google.com/my/path/sample/asd-dsa/this?key1=value1&key2=value2

मेल खाता है:

Group 1.    0-7 https:/
Group 2.    0-5 https
Group 3.    8-22    www.google.com
Group 6.    22-50   /my/path/sample/asd-dsa/this
Group 7.    22-46   /my/path/sample/asd-dsa/
Group 8.    46-50   this
Group 9.    50-74   ?key1=value1&key2=value2
Group 10.   51-74   key1=value1&key2=value2
— बिलाल डेमीर
स्रोत
-1 
String s = "https://www.thomas-bayer.com/axis2/services/BLZService?wsdl";

String regex = "(^http.?://)(.*?)([/\\?]{1,})(.*)";

System.out.println("1: " + s.replaceAll(regex, "$1"));
System.out.println("2: " + s.replaceAll(regex, "$2"));
System.out.println("3: " + s.replaceAll(regex, "$3"));
System.out.println("4: " + s.replaceAll(regex, "$4"));

निम्नलिखित आउटपुट प्रदान करेगा:
1: https: //
2: www.thomas-bayer.com
3: /
4: axis2 / services / BLZService? Wsdl

यदि आप URL को
String s = " https: //www.ththasas? -bayer.com?wsdl=qwerwer&ttt=888 "; आउटपुट निम्न होगा:
1: https: //
2: www.thomas-bayer.com
3:?
4: wsdl = qwerwer & ttt = 888

आनंद लें ..
योसी लेव

— ylev
स्रोत
बंदरगाहों को नहीं संभालता। भाषा अज्ञेय नहीं है।
— ओहगोधी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.