स्ट्रिंग से होस्टनाम नाम निकालें

239

मैं सिर्फ एक URL की जड़ से मेल खाना चाहता हूं, न कि एक टेक्स्ट स्ट्रिंग से पूरे URL से। दिया हुआ:

http://www.youtube.com/watch?v=ClkQA2Lb_iE
http://youtu.be/ClkQA2Lb_iE
http://www.example.com/12xy45
http://example.com/random

मैं www.example.comया example.comडोमेन के लिए हल करने वाले 2 अंतिम उदाहरण प्राप्त करना चाहता हूं ।

मैंने सुना है कि रेगेक्स धीमा है और यह पेज पर मेरा दूसरा रेगेक्स एक्सप्रेशन होगा इसलिए यदि रेगेक्स के बिना ऐसा करना है तो मुझे बताएं।

मैं इस समाधान के एक JS / jQuery संस्करण की मांग कर रहा हूं।

javascript  jquery  regex 
— Chamilyan
स्रोत

जवाबों:

281

मैं npm पैकेज psl (सार्वजनिक प्रत्यय सूची) का उपयोग करने की सलाह देता हूं । "सार्वजनिक प्रत्यय सूची" सभी मान्य डोमेन प्रत्ययों और नियमों की एक सूची है, न केवल कंट्री कोड टॉप-लेवल डोमेन, बल्कि यूनिकोड वर्ण भी हैं जिन्हें रूट डोमेन (यानी www। 食 狮। C .c।, Bckobe माना जाएगा। .jp, आदि)। इसके बारे में यहाँ और पढ़ें ।

प्रयत्न:

npm install --save psl

फिर मेरे "extractHostname" कार्यान्वयन रन के साथ:

let psl = require('psl');
let url = 'http://www.youtube.com/watch?v=ClkQA2Lb_iE';
psl.get(extractHostname(url)); // returns youtube.com

मैं एक npm पैकेज का उपयोग नहीं कर सकता, इसलिए नीचे केवल extractHostname परीक्षण।

function extractHostname(url) {
    var hostname;
    //find & remove protocol (http, ftp, etc.) and get hostname

    if (url.indexOf("//") > -1) {
        hostname = url.split('/')[2];
    }
    else {
        hostname = url.split('/')[0];
    }

    //find & remove port number
    hostname = hostname.split(':')[0];
    //find & remove "?"
    hostname = hostname.split('?')[0];

    return hostname;
}

//test the code
console.log("== Testing extractHostname: ==");
console.log(extractHostname("http://www.blog.classroom.me.uk/index.php"));
console.log(extractHostname("http://www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("https://www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("ftps://ftp.websitename.com/dir/file.txt"));
console.log(extractHostname("websitename.com:1234/dir/file.txt"));
console.log(extractHostname("ftps://websitename.com:1234/dir/file.txt"));
console.log(extractHostname("example.com?param=value"));
console.log(extractHostname("https://facebook.github.io/jest/"));
console.log(extractHostname("//youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("http://localhost:4200/watch?v=ClkQA2Lb_iE"));
स्निपेट का विस्तार करें

प्रोटोकॉल या पोर्ट नंबर होने के बावजूद, आप डोमेन निकाल सकते हैं। यह एक बहुत ही सरल, गैर-रेगेक्स समाधान है, इसलिए मुझे लगता है कि यह करेगा।

* आपके सुझाव के लिए धन्यवाद @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson! @ रॉस-एलन, बग की रिपोर्ट करने के लिए धन्यवाद!

— lewdev
स्रोत
3
यह किसी भी प्रोटोकॉल नोटेशन लंबाई का समर्थन करने के लिए बेहतर हो सकता है। एक सुधार हो सकता है url.split('/')[2]की हम लिख परवाह किए बिना के बाद से ftp, ftps, https, डोमेन नाम हमेशा पर सूचकांक 2. हो जाएगा
— renoirb
1
return url.split('/')[2] || url.split('/')[0];यदि आपके पास कोई प्रोटोकॉल नहीं है, तो आपके परिदृश्य के आधार पर आपको उपयोग करने की आवश्यकता हो सकती है।
— टिमरज
1
आप लोग इस तथ्य को अनदेखा क्यों कर रहे हैं कि यह फ़ंक्शन "ftp.websitename.com/dir/file.txt" जैसे कुछ इनपुट के लिए डोमेन नाम वापस करने में विफल रहेगा?
— रिनेज़
1
@renoirb क्षमा करें, यह डक टाइपिंग का अनुसरण कैसे करता है?
— रिनेज़
6
एक: youtube.com/watch -> www.youtube.com, youtube.com डोमेन का www उपडोमेन है। अतिरिक्त www को निकालने के लिए, मैंने जोड़ा:if (domain.split('.').length > 2) { //has also subdomain var splitArr = domain.split('.'); domain = splitArr[splitArr.length - 2] + '.' + splitArr[splitArr.length - 1]; }
— ra00l
306

नियमित अभिव्यक्तियों का उपयोग किए बिना एक साफ चाल:

var tmp        = document.createElement ('a');
;   tmp.href   = "http://www.example.com/12xy45";

// tmp.hostname will now contain 'www.example.com'
// tmp.host will now contain hostname and port 'www.example.com:80'

एक फ़ंक्शन को नीचे दिए गए जैसे लपेटें और आप अपने आप को एक URI से डोमेन भाग को छीनने का एक शानदार तरीका है।

function url_domain(data) {
  var    a      = document.createElement('a');
         a.href = data;
  return a.hostname;
}
— फिलिप रोसेन - refp
स्रोत
8
वास्तव में मैं parseUri समाधान की कोशिश करने जा रहा हूं, लेकिन रचनात्मकता के लिए +1।
— चामिलन
11
@Chamilyan मुझे लगता है कि आपको इस उत्तर को स्वीकार करना चाहिए .. यह बहुत अधिक कूलर है और बिना कुछ अतिरिक्त काम करता है :)
— लिपिस
3
बस फी - यह समाधान पोर्ट संख्या को संभाल नहीं करता है
— काइल
1
@Kyle यह सुनिश्चित करता है, तो आप कर रहे हैं, जिसका अर्थ है कि यदि पोर्ट संख्या का एक हिस्सा होना चाहिए hostname, ऐसा नहीं होना चाहिए अगर आप का उपयोग करने के लिए दोनों चाहते हैं hostnameऔर port(और के रूप में इसे पाने के domain.sample:1234बस का उपयोग a.host)
— फ़िलिप Roséen - refp
46
यदि आपको इसे तेजी से करने की आवश्यकता है तो इसका उपयोग न करें । यह gilly3 की विधि की तुलना में लगभग 40-60 गुना धीमा है। Jsperf में परीक्षण किया गया: jsperf.com/hostname-from-url ।
— cccrack
138

स्ट्रिंग को पार्स करने की आवश्यकता नहीं है, बस अपने URL को URLनिर्माता के तर्क के रूप में पास करें :

var url = 'http://www.youtube.com/watch?v=ClkQA2Lb_iE';
var hostname = (new URL(url)).hostname;

assert(hostname === 'www.youtube.com');
— पाव्लो
स्रोत
6
नीचे @mc द्वारा उत्तर के रूप में ही। टिप्पणी पर एक नज़र डालें "नया URL () IE (परीक्षण किए गए IE11) के साथ काम नहीं करता है"।
— चामिल
2
यह शायद समाधान के साथ काम करना सबसे आसान है, इसलिए
— चमिली
1
मैं इसे क्रोम एक्सटेंशन में इस्तेमाल कर रहा हूं, इसलिए इस समय मेरे लिए कोई IE समर्थन ठीक नहीं है।
— बोडिन
1
+1 यह स्वीकृत उत्तर होना चाहिए। यह तेज़, विश्वसनीय है, सभी आधुनिक ब्राउज़रों में काम करता है, बाहरी पुस्तकालय पर निर्भर नहीं करता है और इसे समझना आसान है (जैसा कि रेगेक्स समाधान के विपरीत)। मैं यह भी मानूंगा कि यह बहुत तेज़ है क्योंकि यह हर ब्राउज़र के मूल में है (ऐसा नहीं है कि यह आमतौर पर बहुत अधिक मायने रखता है)।
— १०:१२ पर जॉन्डोडो
128

इसे इस्तेमाल करे:

var matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
var domain = matches && matches[1];  // domain will be null if no match is found

यदि आप पोर्ट को अपने परिणाम से बाहर करना चाहते हैं, तो इसके बजाय इस अभिव्यक्ति का उपयोग करें:

/^https?\:\/\/([^\/:?#]+)(?:[\/:?#]|$)/i

संपादित करें: विशिष्ट डोमेन को मिलान करने से रोकने के लिए, नकारात्मक रूप का उपयोग करें।(?!youtube.com)

/^https?\:\/\/(?!(?:www\.)?(?:youtube\.com|youtu\.be))([^\/:?#]+)(?:[\/:?#]|$)/i
— gilly3
स्रोत
3
प्रोटोकॉल जैसे स्वरूपों के बारे में मत भूलना: // उपयोगकर्ता नाम: पासवर्ड @ होस्ट: पोर्ट / पथ / से / संसाधन ...
— एंड्रयू व्हाइट
1
बंद करें, लेकिन URL में कोई रास्ता नहीं हो सकता है और मेजबान भाग एक ?' (query) or # (खंड) पर समाप्त हो सकता है । जैसे http://example.com?var=valया http://example.com#fragment। इस प्रकार, सही regex की तरह कुछ किया जाना चाहिए: /^https?\:\/\/([^\/?#]+)/। उसके अलावा, आपको मेरा +1 मिलेगा (यह सबसे तेज़ समाधान है)
— रेंजरगनर
2
आप (?:www\.)?नकारात्मक रूपांतर में एक वैकल्पिक जोड़ना चाह सकते हैं ।
— ११:११ को १ger:
3
+1 क्योंकि यह बहुत तेज़ है, जो मेरे मामले में एक आवश्यकता है
— cprcrack
8
@FellowStranger - (?:www\.)?इस तरह से नियमित अभिव्यक्ति में जोड़ें :/^https?\:\/\/(?:www\.)?([^\/?#]+)(?:[\/?#]|$)/i
— gilly3
36

URL पार्स करना मुश्किल हो सकता है क्योंकि आपके पास पोर्ट नंबर और विशेष वर्ण हो सकते हैं। जैसे, मैं आपके लिए ऐसा करने के लिए पार्सेयूरी जैसी चीज़ का उपयोग करने की सलाह देता हूं। मुझे संदेह है कि प्रदर्शन तब तक जारी रहेगा जब तक आप सैकड़ों URLs पार्स नहीं कर रहे हैं।

— एंड्रयू व्हाइट
स्रोत
12
यदि आपको इसे तेजी से करने की आवश्यकता है तो इसका उपयोग न करें । केवल होस्टनाम प्राप्त करने के लिए, यह gilly3 की विधि की तुलना में लगभग 40-60 गुना धीमा है। Jsperf में परीक्षण किया गया: jsperf.com/hostname-from-url ।
— cccrack
यहां एक अपडेट किया गया URL है (अन्य में 404 नहीं मिले): javascriptoo.com/application/html/js/franzenzenhofer/parseUri/…
— ub3rst4r
@BigDong शायद आपको आसानी से देयता की आवश्यकता हो सकती है? nodejs.org/api/…
— mc।
2
दुर्भाग्य से URL IE10 में समर्थित नहीं है।
— advncd
1
URL()अभी तक पूरी तरह से समर्थित नहीं है। जाँच करें: caniuse.com/#feat=url
— Kousha
34

2020 का जवाब

इसके लिए आपको किसी अतिरिक्त निर्भरता की आवश्यकता नहीं है! आपको प्रदर्शन के लिए अनुकूलन करने की आवश्यकता है या नहीं इसके आधार पर, दो अच्छे समाधान हैं:

URL.hostnameपठनीयता के लिए उपयोग करें

बैबेल युग में, सबसे साफ और सबसे आसान समाधान का उपयोग करना है URL.hostname।

const getHostname = (url) => {
  // use URL constructor and return hostname
  return new URL(url).hostname;
}

// tests
console.log(getHostname("/programming/8498592/extract-hostname-name-from-string/"));
console.log(getHostname("https://developer.mozilla.org/en-US/docs/Web/API/URL/hostname"));
स्निपेट का विस्तार करें

URL.hostnameआईई ( एपीआई ) को छोड़कर सभी प्रमुख ब्राउज़रों द्वारा समर्थित यूआरएल एपीआई का हिस्सा है । यदि आपको लीगेसी ब्राउज़र का समर्थन करने की आवश्यकता है तो URL पॉलीफ़िल का उपयोग करें ।

इस समाधान का उपयोग करने से आपको अन्य URL गुणों और विधियों तक पहुंच प्राप्त होगी । यह उपयोगी होगा यदि आप उदाहरण के लिए URL के पथनाम या क्वेरी स्ट्रिंग परम को निकालना चाहते हैं ।

प्रदर्शन के लिए RegEx का उपयोग करें

URL.hostnameलंगर समाधान या parseUri का उपयोग करने से तेज है । हालांकि यह अभी भी gilly3 के रेगेक्स की तुलना में बहुत धीमा है :

const getHostnameFromRegex = (url) => {
  // run against regex
  const matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
  // extract hostname (will be null if no match is found)
  return matches && matches[1];
}

// tests
console.log(getHostnameFromRegex("/programming/8498592/extract-hostname-name-from-string/"));
console.log(getHostnameFromRegex("https://developer.mozilla.org/en-US/docs/Web/API/URL/hostname"));
स्निपेट का विस्तार करें

इस jsPerf पर अपना परीक्षण करें

यदि आपको बहुत बड़ी संख्या में URL (जहां प्रदर्शन एक कारक होगा) संसाधित करने की आवश्यकता है, तो मैं इसके बजाय इस समाधान का उपयोग करने की सलाह देता हूं। अन्यथा, URL.hostnameपठनीयता के लिए चुनें ।

— रॉबिन मेट्रल
स्रोत
15

मैंने दिए गए समाधानों का उपयोग करने की कोशिश की, चुना एक मेरे उद्देश्य के लिए एक ओवरकिल था और "एक तत्व बनाना" मेरे लिए एक गड़बड़ है।

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

function parseURL(url){
    parsed_url = {}

    if ( url == null || url.length == 0 )
        return parsed_url;

    protocol_i = url.indexOf('://');
    parsed_url.protocol = url.substr(0,protocol_i);

    remaining_url = url.substr(protocol_i + 3, url.length);
    domain_i = remaining_url.indexOf('/');
    domain_i = domain_i == -1 ? remaining_url.length - 1 : domain_i;
    parsed_url.domain = remaining_url.substr(0, domain_i);
    parsed_url.path = domain_i == -1 || domain_i + 1 == remaining_url.length ? null : remaining_url.substr(domain_i + 1, remaining_url.length);

    domain_parts = parsed_url.domain.split('.');
    switch ( domain_parts.length ){
        case 2:
          parsed_url.subdomain = null;
          parsed_url.host = domain_parts[0];
          parsed_url.tld = domain_parts[1];
          break;
        case 3:
          parsed_url.subdomain = domain_parts[0];
          parsed_url.host = domain_parts[1];
          parsed_url.tld = domain_parts[2];
          break;
        case 4:
          parsed_url.subdomain = domain_parts[0];
          parsed_url.host = domain_parts[1];
          parsed_url.tld = domain_parts[2] + '.' + domain_parts[3];
          break;
    }

    parsed_url.parent_domain = parsed_url.host + '.' + parsed_url.tld;

    return parsed_url;
}

इसे चलाना:

parseURL('https://www.facebook.com/100003379429021_356001651189146');

परिणाम:

Object {
    domain : "www.facebook.com",
    host : "facebook",
    path : "100003379429021_356001651189146",
    protocol : "https",
    subdomain : "www",
    tld : "com"
}
— BlackDivine
स्रोत
1
मुझे आमतौर पर कम मतदान वाले उत्तर याद आते हैं, लेकिन इस जवाब ने मुझे सतर्क कर दिया। बहुत अच्छा काम करता है! शुक्रिया @BlackDivine
— देवरूप
मेरे प्रयास की सराहना करने के लिए समय निकालने के लिए धन्यवाद @Devaroop
— BlackDivine
15

यदि आप इस पृष्ठ पर समाप्त होते हैं और आप URLS के सर्वोत्तम REGEX की तलाश कर रहे हैं, तो यह प्रयास करें:

^(?:https?:)?(?:\/\/)?([^\/\?]+)

https://regex101.com/r/pX5dL9/1

यह बिना http: // के साथ यूआरएल के लिए काम करता है, http के साथ, https के साथ, बस // और न ही पथ और क्वेरी पथ को भी पकड़ो।

शुभ लाभ

— लुइस लोपेज
स्रोत
हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना बेहतर है और संदर्भ के लिए लिंक प्रदान करना है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ बदल जाते हैं। - समीक्षा से
— लॉरेंस Aiello
1
संपादित करें और regex को प्रस्तुत किया :)
— लुइस लोप्स
6

सभी यूआरएल गुण, कोई निर्भरता, कोई JQuery, समझने में आसान

यह समाधान आपके उत्तर को अतिरिक्त गुण देता है। कोई JQuery या अन्य निर्भरता आवश्यक नहीं है, पेस्ट करें और जाएं।

प्रयोग

getUrlParts("https://news.google.com/news/headlines/technology.html?ned=us&hl=en")

उत्पादन

{
  "origin": "https://news.google.com",
  "domain": "news.google.com",
  "subdomain": "news",
  "domainroot": "google.com",
  "domainpath": "news.google.com/news/headlines",
  "tld": ".com",
  "path": "news/headlines/technology.html",
  "query": "ned=us&hl=en",
  "protocol": "https",
  "port": 443,
  "parts": [
    "news",
    "google",
    "com"
  ],
  "segments": [
    "news",
    "headlines",
    "technology.html"
  ],
  "params": [
    {
      "key": "ned",
      "val": "us"
    },
    {
      "key": "hl",
      "val": "en"
    }
  ]
}

कोड
कोड को सुपर फास्ट के बजाय समझने में आसान बनाया गया है। इसे प्रति सेकंड 100 बार आसानी से कहा जा सकता है, इसलिए यह फ्रंट एंड या कुछ सर्वर usages के लिए बहुत अच्छा है, लेकिन उच्च वॉल्यूम थ्रूपुट के लिए नहीं।

function getUrlParts(fullyQualifiedUrl) {
    var url = {},
        tempProtocol
    var a = document.createElement('a')
    // if doesn't start with something like https:// it's not a url, but try to work around that
    if (fullyQualifiedUrl.indexOf('://') == -1) {
        tempProtocol = 'https://'
        a.href = tempProtocol + fullyQualifiedUrl
    } else
        a.href = fullyQualifiedUrl
    var parts = a.hostname.split('.')
    url.origin = tempProtocol ? "" : a.origin
    url.domain = a.hostname
    url.subdomain = parts[0]
    url.domainroot = ''
    url.domainpath = ''
    url.tld = '.' + parts[parts.length - 1]
    url.path = a.pathname.substring(1)
    url.query = a.search.substr(1)
    url.protocol = tempProtocol ? "" : a.protocol.substr(0, a.protocol.length - 1)
    url.port = tempProtocol ? "" : a.port ? a.port : a.protocol === 'http:' ? 80 : a.protocol === 'https:' ? 443 : a.port
    url.parts = parts
    url.segments = a.pathname === '/' ? [] : a.pathname.split('/').slice(1)
    url.params = url.query === '' ? [] : url.query.split('&')
    for (var j = 0; j < url.params.length; j++) {
        var param = url.params[j];
        var keyval = param.split('=')
        url.params[j] = {
            'key': keyval[0],
            'val': keyval[1]
        }
    }
    // domainroot
    if (parts.length > 2) {
        url.domainroot = parts[parts.length - 2] + '.' + parts[parts.length - 1];
        // check for country code top level domain
        if (parts[parts.length - 1].length == 2 && parts[parts.length - 1].length == 2)
            url.domainroot = parts[parts.length - 3] + '.' + url.domainroot;
    }
    // domainpath (domain+path without filenames) 
    if (url.segments.length > 0) {
        var lastSegment = url.segments[url.segments.length - 1]
        var endsWithFile = lastSegment.indexOf('.') != -1
        if (endsWithFile) {
            var fileSegment = url.path.indexOf(lastSegment)
            var pathNoFile = url.path.substr(0, fileSegment - 1)
            url.domainpath = url.domain
            if (pathNoFile)
                url.domainpath = url.domainpath + '/' + pathNoFile
        } else
            url.domainpath = url.domain + '/' + url.path
    } else
        url.domainpath = url.domain
    return url
}
— whitneyland
स्रोत
कुछ सरल सरल पार्सिंग में विफल रहता है। getUrlParts('www.google.com')इस पृष्ठ पर कंसोल में प्रयास करें ।
— चामिलन
@Chamilyan यह एक यूआरएल नहीं है, यूआरएल का एक प्रोटोकॉल है। हालाँकि मैंने अधिक सामान्य मामले को संभालने के लिए कोड को अपडेट कर दिया है इसलिए कृपया अपना डाउनवोट वापस ले लें।
— व्हाइटनीलैंड
मैंने आपको वोट नहीं दिया। लेकिन मैं होता अगर मैं अपने मूल प्रश्न में http: // के लिए विशेष रूप से नहीं पूछ रहा होता।
— चामिलन
2
@Lee इस इनपुट पर विफल रहता है: होना चाहिए , लेकिन यह आउटपुट: जबकि एक उप-डोमेन है (डोमेन अनेक उप-डोमेन हो सकता है)। var url="https://mail.gggg.google.cn/link/link/link";domainrootgoogle.comgggg.google.cngggg
— कोई भी
4

आज इस समस्या का हल ढूंढ रहा था। उपरोक्त में से कोई भी उत्तर संतुष्ट नहीं हुआ। मैं एक समाधान चाहता था जो एक लाइनर हो सकता है, कोई सशर्त तर्क नहीं और कुछ भी नहीं जिसे एक फ़ंक्शन में लपेटा जाना था।

यहाँ मैं साथ आया हूँ, वास्तव में अच्छी तरह से काम करने लगता है:

होस्ट नाम = "http://www.example.com:1234"
hostname.split ("//")। slice (-1) [0] .plplit (":" [[0] .split (')'। slice (-2) .join (')') //। "example.com" देता है

पहली नज़र में जटिल लग सकता है, लेकिन यह बहुत सरलता से काम करता है; कुंजी का उपयोग कर 'टुकड़ा (-n) स्थानों के एक जोड़े जहां अच्छा हिस्से से खींच लिया जाना है में है अंत (विभाजन सरणी के सामने से प्राप्त करने के लिए और [0]) विभाजन सरणी के।

इनमें से प्रत्येक परीक्षण "example.com" पर लौटता है:

"Http://example.com" .split ( "//") .slice (-1) [0] .split ( ":")। [0] .split ( '।') टुकड़ा (-2)। में शामिल होने के ( '।')
"http://example.com:1234".split("//").slice(-1)[0].split(":")[0].split('.').slice(-2 ) .join ( '।')
"Http://www.example.com:1234" .split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '।') टुकड़ा (। -2) .join ( '।')
"Http://foo.www.example.com:1234" .split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '।')। टुकड़ा (-2) .join ( '।')
— zaphodb
स्रोत
अच्छा है क्योंकि यह एक मामले को संभालता है जहां www अप्रासंगिक है
— चामिलन
4

यहाँ jQuery का वन-लाइनर है:

$('<a>').attr('href', url).prop('hostname');
— gradosevic
स्रोत
3 
String.prototype.trim = function(){return his.replace(/^\s+|\s+$/g,"");}
function getHost(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    var _host,_arr;
    if(-1<url.indexOf("://")){
        _arr = url.split('://');
        if(-1<_arr[0].indexOf("/")||-1<_arr[0].indexOf(".")||-1<_arr[0].indexOf("\?")||-1<_arr[0].indexOf("\&")){
            _arr[0] = _arr[0].trim();
            if(0==_arr[0].indexOf("//")) _host = _arr[0].split("//")[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
            else return "";
        }
        else{
            _arr[1] = _arr[1].trim();
            _host = _arr[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
        }
    }
    else{
        if(0==url.indexOf("//")) _host = url.split("//")[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
        else return "";
    }
    return _host;
}
function getHostname(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    return getHost(url).split(':')[0];
}
function getDomain(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    return getHostname(url).replace(/([a-zA-Z0-9]+.)/,"");
}
— QazyCat
स्रोत
इसलिए मैं यहां टिप्पणी जोड़ देता हूं: यह कोड url के साथ भी काम करता है जो // से शुरू होता है या जिसमें वाक्यविन्यास त्रुटियां होती हैं जैसे qqq.qqq.qqq & test = 2 या URL के साथ क्वेरी परम है? param = www.www
— QazyChan
3 
function hostname(url) {
    var match = url.match(/:\/\/(www[0-9]?\.)?(.[^/:]+)/i);
    if ( match != null && match.length > 2 && typeof match[2] === 'string' && match[2].length > 0 ) return match[2];
}

उपरोक्त कोड निम्नलिखित उदाहरणों के लिए होस्टनाम को सफलतापूर्वक पार्स कर देगा:

http://WWW.first.com/folder/page.html first.com

http://mail.google.com/folder/page.html mail.google.com

https://mail.google.com/folder/page.html mail.google.com

http://www2.somewhere.com/folder/page.html?q=1 कहीं पर । com

https://www.another.eu/folder/page.html?q=1 other.eu

मूल क्रेडिट जाता है: http://www.primaryobjects.com/CMS/Article145

— jaggedsoft
स्रोत
3

ठीक है, मुझे पता है कि यह एक पुराना प्रश्न है, लेकिन मैंने एक सुपर-कुशल url पार्सर बनाया है इसलिए मुझे लगा कि मैं इसे साझा करूंगा।

जैसा कि आप देख सकते हैं, फ़ंक्शन की संरचना बहुत विषम है, लेकिन यह दक्षता के लिए है। कोई प्रोटोटाइप फ़ंक्शन का उपयोग नहीं किया जाता है, स्ट्रिंग को एक से अधिक बार पुनरावृत्त नहीं किया जाता है, और किसी भी वर्ण को आवश्यक से अधिक संसाधित नहीं किया जाता है।

function getDomain(url) {
    var dom = "", v, step = 0;
    for(var i=0,l=url.length; i<l; i++) {
        v = url[i]; if(step == 0) {
            //First, skip 0 to 5 characters ending in ':' (ex: 'https://')
            if(i > 5) { i=-1; step=1; } else if(v == ':') { i+=2; step=1; }
        } else if(step == 1) {
            //Skip 0 or 4 characters 'www.'
            //(Note: Doesn't work with www.com, but that domain isn't claimed anyway.)
            if(v == 'w' && url[i+1] == 'w' && url[i+2] == 'w' && url[i+3] == '.') i+=4;
            dom+=url[i]; step=2;
        } else if(step == 2) {
            //Stop at subpages, queries, and hashes.
            if(v == '/' || v == '?' || v == '#') break; dom += v;
        }
    }
    return dom;
}
— Pecacheu
स्रोत
3

यह एक पूर्ण उत्तर नहीं है, लेकिन नीचे दिए गए कोड को आपकी मदद करनी चाहिए:

function myFunction() {
    var str = "https://www.123rf.com/photo_10965738_lots-oop.html";
    matches = str.split('/');
    return matches[2];
}

मैं चाहूंगा कि कोई मेरी तुलना में तेजी से कोड बनाए। यह मेरे आत्म को भी बेहतर बनाने में मदद करता है।

— solokiran
स्रोत
3

jquery के साथ ऑनलाइन

$('<a>').attr('href', document.location.href).prop('hostname');
— VnDevil
स्रोत
2 
// use this if you know you have a subdomain
// www.domain.com -> domain.com
function getDomain() {
  return window.location.hostname.replace(/([a-zA-Z0-9]+.)/,"");
}
— Gubatron
स्रोत
2

मैंने व्यक्तिगत रूप से इस समाधान के लिए बहुत शोध किया, और जो सबसे अच्छा मैं पा सकता था वह वास्तव में CloudFlare के "ब्राउज़र चेक" से है:

function getHostname(){  
            secretDiv = document.createElement('div');
            secretDiv.innerHTML = "<a href='/'>x</a>";
            secretDiv = secretDiv.firstChild.href;
            var HasHTTPS = secretDiv.match(/https?:\/\//)[0];
            secretDiv = secretDiv.substr(HasHTTPS.length);
            secretDiv = secretDiv.substr(0, secretDiv.length - 1);
            return(secretDiv);  
}  

getHostname();

मैंने चर को फिर से लिखा इसलिए यह अधिक "मानव" पठनीय है, लेकिन यह उम्मीद से बेहतर काम करता है।

— नॉर्बर्ट बोरोस
स्रोत
2

खैर, एक नियमित अभिव्यक्ति का उपयोग करना बहुत आसान होगा:

    mainUrl = "http://www.mywebsite.com/mypath/to/folder";
    urlParts = /^(?:\w+\:\/\/)?([^\/]+)(.*)$/.exec(mainUrl);
    host = Fragment[1]; // www.mywebsite.com
— सौरभ मंडेल
स्रोत
2 
import URL from 'url';

const pathname = URL.parse(url).path;
console.log(url.replace(pathname, ''));

यह दोनों प्रोटोकॉल का ख्याल रखता है।

— स्टैनले ऑगुज़ु
स्रोत
दरअसल यह मॉड्यूल NodeJS के साथ दिया गया है।
— djibe
1

संक्षेप में आप इस तरह कर सकते हैं

var url = "http://www.someurl.com/support/feature"

function getDomain(url){
  domain=url.split("//")[1];
  return domain.split("/")[0];
}
eg:
  getDomain("http://www.example.com/page/1")

  output:
   "www.example.com"

डोमेन नाम प्राप्त करने के लिए उपरोक्त फ़ंक्शन का उपयोग करें

— uzaif
स्रोत
समस्या क्या है?
— uzaif
समस्या यह है कि अगर पहले कोई स्लैश नहीं है तो यह काम नहीं करेगा?
— टूलकिट
आपके मामले में आपको ?अपने डोमेन नाम स्ट्रिंग के लिए जाँच करने की आवश्यकता है और इसके बजाय return domain.split("/")[0]; इस return domain.split("?")[0];काम को करने की उम्मीद करें
— uzaif
1

Parse-Urls सबसे मजबूत पैटर्न के साथ जावास्क्रिप्ट लाइब्रेरी प्रतीत होता है

यहाँ सुविधाओं का एक प्रकार है:

अध्याय 1. एक URL को सामान्य करें या पार्स करें

अध्याय 2. सभी URL निकालें

अध्याय 3. कुछ नामों के साथ यूआरआई निकालें

अध्याय 4. सभी फजी यूआरएल निकालें

अध्याय 5. सभी URL को ग्रंथों में हाइलाइट करें

अध्याय 6. कच्चे HTML या XML में सभी URL निकालें

— Chamilyan
स्रोत
0

कोड:

var regex = /\w+.(com|co\.kr|be)/ig;
var urls = ['http://www.youtube.com/watch?v=ClkQA2Lb_iE',
            'http://youtu.be/ClkQA2Lb_iE',
            'http://www.example.com/12xy45',
            'http://example.com/random'];


$.each(urls, function(index, url) {
    var convertedUrl = url.match(regex);
    console.log(convertedUrl);
});

परिणाम:

youtube.com
youtu.be
example.com
example.com
— येओंगजुन किम
स्रोत
@ChristianTernus इसके विपरीत; ओपी ने रेगेक्स का उल्लेख किया है, और यह स्पष्ट रूप से एक रेगेक्स अभिव्यक्ति है जो एक यूआरएल के अनुरोधित हिस्से से मेल करने के लिए डिज़ाइन किया गया है। यह पूरी तरह से सही नहीं है (उदाहरण के लिए इसकी आवश्यकता होती है www., हालांकि सभी URL में यह घटक नहीं है), लेकिन यह निश्चित रूप से एक उत्तर है ।
— काइल स्ट्रैंड
@KyleStrand बहुत स्पष्ट रूप से एक व्यक्तिपरक निर्णय है; "जब मैं इस समाधान का JS / jQuery संस्करण चाह रहा हूँ" पूछा गया तो एक कच्चा रेग्क्स प्रदान करना "qeestone का जवाब नहीं देता है।
— क्रिश्चियन टेरनस
मैं ओपी हूं। मैं उस समय एक नया डेवलपर था जो जेएस में बॉक्स समाधान से बाहर था। वास्तव में, किसी भी संदर्भ के बिना एक कच्चा रेगीक्स स्ट्रिंग बिल्कुल भी मदद नहीं करता था। इसके अलावा यह अधूरा है।
— चामिलन
0

पार्स-डोमेन - एक बहुत ही ठोस हल्का पुस्तकालय

npm install parse-domain

const { fromUrl, parseDomain } = require("parse-domain");

उदाहरण 1

parseDomain(fromUrl("http://www.example.com/12xy45"))
{ type: 'LISTED',
  hostname: 'www.example.com',
  labels: [ 'www', 'example', 'com' ],
  icann:
   { subDomains: [ 'www' ],
     domain: 'example',
     topLevelDomains: [ 'com' ] },
  subDomains: [ 'www' ],
  domain: 'example',
  topLevelDomains: [ 'com' ] }

उदाहरण 2

parseDomain(fromUrl("http://subsub.sub.test.ExAmPlE.coM/12xy45"))
{ type: 'LISTED',
  hostname: 'subsub.sub.test.example.com',
  labels: [ 'subsub', 'sub', 'test', 'example', 'com' ],
  icann:
   { subDomains: [ 'subsub', 'sub', 'test' ],
     domain: 'example',
     topLevelDomains: [ 'com' ] },
  subDomains: [ 'subsub', 'sub', 'test' ],
  domain: 'example',
  topLevelDomains: [ 'com' ] }

क्यों?

उपयोग के मामले और मात्रा के आधार पर मैं दृढ़ता से इस समस्या को हल करने के खिलाफ खुद को रेगेक्स या अन्य स्ट्रिंग हेरफेर साधनों का उपयोग करने की सलाह देता हूं। इस समस्या का मूल यह है कि आपको डोमेन और उप-डोमेन में url स्ट्रिंग्स को ठीक से पार्सल करने के लिए सभी gtld और cctld प्रत्यय जानने की जरूरत है , ये प्रत्यय नियमित रूप से अपडेट किए जाते हैं। यह एक हल की गई समस्या है और न कि आप खुद को हल करना चाहते हैं (जब तक कि आप Google या कुछ और नहीं हैं)। जब तक आपको एक चुटकी में होस्टनाम या डोमेन नाम की आवश्यकता नहीं होती है, तब तक इस तरह से बाहर निकलने की कोशिश न करें।

— ग्लेन थॉम्पसन
स्रोत
इसका शायद एक पर्यावरण / संस्करण मुद्दा इस npmjs.com/package/parse-domain
— ग्लेन थॉम्पसन
-1

मेरा कोड इस तरह दिखता है। नियमित अभिव्यक्ति कई रूपों में आ सकती है, और यहां मेरे परीक्षण के मामले हैं जो मुझे लगता है कि यह अधिक स्केलेबल है।

function extractUrlInfo(url){
  let reg = /^((?<protocol>http[s]?):\/\/)?(?<host>((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])|[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)))(\:(?<port>[0-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5]))?$/
  return reg.exec(url).groups
}

var url = "https://192.168.1.1:1234"
console.log(extractUrlInfo(url))
var url = "/programming/8498592/extract-hostname-name-from-string"
console.log(extractUrlInfo(url))
स्निपेट का विस्तार करें

— gao.xiangyang
स्रोत
-6

रेगेक्स का उपयोग करके सटीक डोमेन नाम के लिए नीचे दिए गए कोड की कोशिश करें,

स्ट्रिंग लाइन = " http://www.youtube.com/watch?v=ClkQA2Lb_iE ";

  String pattern3="([\\w\\W]\\.)+(.*)?(\\.[\\w]+)";

  Pattern r = Pattern.compile(pattern3);


  Matcher m = r.matcher(line);
  if (m.find( )) {

    System.out.println("Found value: " + m.group(2) );
  } else {
     System.out.println("NO MATCH");
  }
— I_Tech
स्रोत
2
ओपी जावास्क्रिप्ट में जवाब की तलाश में था, जावा की नहीं।
— पीयर्सडियन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.