텍스트 문자열의 전체 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또는 2 개의 마지막 인스턴스를 example.com도메인으로 해결하려고 합니다.

나는 정규 표현식이 느리다는 것을 들었고 이것이 페이지의 두 번째 정규 표현식이 될 것이므로 정규 표현식없이 할 수 있다면 알려주십시오.

이 솔루션의 JS / jQuery 버전을 찾고 있습니다.

npm 패키지 psl (Public Suffix List)을 사용하는 것이 좋습니다 . "공개 접미사 목록"은 국가 코드 최상위 도메인뿐만 아니라 루트 도메인으로 간주 될 유니 코드 문자 (예 : www. 食 狮. 公司 .cn, 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에게 감사드립니다! @ ross-allen, 버그를보고 해 주셔서 감사합니다!

정규 표현식을 사용하지 않는 깔끔한 트릭 :

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;
}

문자열을 구문 분석 할 필요가 없으며 URL을 URL생성자에 인수로 전달하면됩니다 .

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

assert(hostname === 'www.youtube.com');

이 시도:

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

포트 번호와 특수 문자를 사용할 수 있으므로 URL 구문 분석이 까다로울 수 있습니다. 따라서 parseUri 와 같은 것을 사용 하여이 작업 을 수행하는 것이 좋습니다 . 수백 개의 URL을 구문 분석하지 않으면 성능이 문제가 될 것입니다.

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 API의 일부이며 IE ( caniuse )를 제외한 모든 주요 브라우저에서 지원됩니다 . 레거시 브라우저를 지원해야하는 경우 URL 폴리 필을 사용하십시오 .

이 솔루션을 사용하면 다른 URL 속성 및 메소드에 액세스 할 수도 있습니다 . 예를 들어 URL의 경로 이름 또는 쿼리 문자열 params 도 추출하려는 경우에 유용합니다 .

성능을 위해 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가독성을 선택하십시오 .

나는 주어진 솔루션을 사용하려고 시도했는데, 선택된 솔루션은 내 목적을 위해 과잉이었고 "요소 만들기"는 나를 엉망으로 만듭니다.

아직 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"
}

이 페이지가 끝나고 최고의 REGEX를 찾고 있다면 다음 중 하나를 시도하십시오.

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

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

http : //없이 URL, http로, https로, //로만 작동하며 경로 및 쿼리 경로도 가져 가지 마십시오.

행운을 빕니다

모든 URL 속성, 종속성 없음, 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 번 쉽게 호출 할 수 있으므로 프런트 엔드 또는 몇 가지 서버 사용에는 적합하지만 대량 처리량에는 적합하지 않습니다.

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
}

URL () 생성자를 사용 하십시오 .

new URL(url).host

오늘이 문제에 대한 해결책을 찾고있었습니다. 위의 답변 중 어느 것도 만족시키지 못했습니다. 나는 하나의 라이너가 될 수 있고 조건부 논리가없고 함수에 싸여서는 안되는 솔루션을 원했습니다.

여기에 내가 생각해 낸 것이 실제로 잘 작동하는 것 같습니다.

hostname = "http://www.example.com:1234"
hostname.split ( "//"). slice (-1) [0] .split ( ":") [0] .split ( '.'). slice (-2) .join ( '.') // "example.com"제공

언뜻보기에는 복잡해 보일 수 있지만 간단하게 작동합니다. 핵심은 분할 배열 의 끝 에서 좋은 부품을 가져와야하는 두 곳에서 'slice (-n)'을 사용하는 것입니다 (그리고 분할 배열의 앞쪽에서 가져 오려면 [0]).

각 테스트는 "example.com"을 반환합니다.

"http://example.com".split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '.'). slice (-2). 붙다('.')
"http://example.com:1234".split("//").slice(-1)[0].split(":")[0].split('.').slice(-2 ).붙다('.')
"http://www.example.com:1234".split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '.'). slice ( -2) .join ( '.')
"http://foo.www.example.com:1234".split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '.'). 슬라이스 (-2) .join ( '.')

다음은 jQuery one-liner입니다.

$('<a>').attr('href', url).prop('hostname');

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]+.)/,"");
}

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];
}

위의 코드는 다음 예제 URL의 호스트 이름을 성공적으로 구문 분석합니다.

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 somewhere.com

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

최초 크레딧 : http://www.primaryobjects.com/CMS/Article145

좋아, 나는 이것이 오래된 질문이라는 것을 알고 있지만, 매우 효율적인 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;
}

이것은 완전한 대답은 아니지만 아래 코드가 도움이 될 것입니다.

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

내 것보다 코드를 더 빨리 작성하고 싶습니다. 그것은 나 자신도 향상시키는 데 도움이됩니다.

jquery와 함께 한 줄

$('<a>').attr('href', document.location.href).prop('hostname');

// 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]+.)/,"");
}

개인적으로이 솔루션에 대해 많은 연구를했으며 실제로 찾을 수있는 가장 좋은 방법은 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();

변수를 다시 작성하여 "사람이 읽을 수 있도록"읽을 수 있지만 예상보다 더 잘 수행합니다.

정규 표현식을 사용하는 것이 훨씬 쉽습니다.

    mainUrl = "http://www.mywebsite.com/mypath/to/folder";
    urlParts = /^(?:\w+\:\/\/)?([^\/]+)(.*)$/.exec(mainUrl);
    host = Fragment[1]; // www.mywebsite.com

import URL from 'url';

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

이것은 두 프로토콜을 모두 처리합니다.

짧은 방법으로 당신은 이렇게 할 수 있습니다

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"

위의 기능을 사용하여 도메인 이름을 얻습니다.

Parse-Urls 는 가장 강력한 패턴을 가진 JavaScript 라이브러리 인 것으로 보입니다.

다음은 기능에 대한 요약입니다.

1 장. 하나의 URL 정규화 또는 구문 분석

2 장. 모든 URL 추출

제 3 장 특정 이름으로 URI 추출

퍼지 URL 추출

5 장. 텍스트의 모든 URL을 강조

6 장. 원시 HTML 또는 XML로 모든 URL 추출

암호:

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

구문 분석 도메인 -매우 견고한 경량 라이브러리

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 또는 다른 사람이 아닌 한). 꼬집음에 호스트 이름이나 도메인 이름이 필요하지 않으면이 이름에서 벗어나려고 시도하지 마십시오.

내 코드는 다음과 같습니다. 정규 표현식은 여러 형태로 나올 수 있으며 여기에 더 확장 가능한 것으로 생각되는 테스트 사례가 있습니다.

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))

정규식을 사용하여 정확한 도메인 이름을 보려면 아래 코드를 시도하십시오.

문자열 줄 = " 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");
  }