ฉันต้องการรับสาย

var a = "http://example.com/aa/bb/"

และประมวลผลเป็นวัตถุเช่นนั้น

a.hostname == "example.com"

และ

a.pathname == "/aa/bb"

วิธีการที่ทันสมัย:

new URL("http://example.com/aa/bb/")

ส่งคืนวัตถุที่มีคุณสมบัติhostnameและpathnameพร้อมกับคนอื่น ๆ

อาร์กิวเมนต์แรกคือ URL แบบสัมพัทธ์หรือสัมบูรณ์ หากเป็นแบบสัมพัทธ์คุณจะต้องระบุอาร์กิวเมนต์ที่สอง (URL หลัก) ตัวอย่างเช่นสำหรับ URL ที่เกี่ยวข้องกับหน้าปัจจุบัน:

new URL("/aa/bb/", location)

นอกเหนือไปจากเบราว์เซอร์, API นี้ยังมีอยู่ใน Node.jsตั้งแต่ v7 require('url').URLผ่าน

var getLocation = function(href) {
    var l = document.createElement("a");
    l.href = href;
    return l;
};
var l = getLocation("http://example.com/path");
console.debug(l.hostname)
>> "example.com"
console.debug(l.pathname)
>> "/path"

พบได้ที่นี่: https://gist.github.com/jlong/2428561

var parser = document.createElement('a');
parser.href = "http://example.com:3000/pathname/?search=test#hash";

parser.protocol; // => "http:"
parser.host;     // => "example.com:3000"
parser.hostname; // => "example.com"
parser.port;     // => "3000"
parser.pathname; // => "/pathname/"
parser.hash;     // => "#hash"
parser.search;   // => "?search=test"
parser.origin;   // => "http://example.com:3000"

นี่คือฟังก์ชั่นที่เรียบง่ายโดยใช้ regexp ที่เลียนแบบaพฤติกรรมแท็ก

ข้อดี

• พฤติกรรมที่คาดเดาได้ (ไม่มีปัญหาเบราว์เซอร์ข้าม)
• ไม่ต้องการ DOM
• มันสั้นจริงๆ

จุดด้อย

• regexp อ่านยากนิดหน่อย

-

function getLocation(href) {
    var match = href.match(/^(https?\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
    return match && {
        href: href,
        protocol: match[1],
        host: match[2],
        hostname: match[3],
        port: match[4],
        pathname: match[5],
        search: match[6],
        hash: match[7]
    }
}

-

getLocation("http://example.com/");
/*
{
    "protocol": "http:",
    "host": "example.com",
    "hostname": "example.com",
    "port": undefined,
    "pathname": "/"
    "search": "",
    "hash": "",
}
*/

getLocation("http://example.com:3000/pathname/?search=test#hash");
/*
{
    "protocol": "http:",
    "host": "example.com:3000",
    "hostname": "example.com",
    "port": "3000",
    "pathname": "/pathname/",
    "search": "?search=test",
    "hash": "#hash"
}
*/

แก้ไข:

นี่คือรายละเอียดของการแสดงออกปกติ

var reURLInformation = new RegExp([
    '^(https?:)//', // protocol
    '(([^:/?#]*)(?::([0-9]+))?)', // host (hostname and port)
    '(/{0,1}[^?#]*)', // pathname
    '(\\?[^#]*|)', // search
    '(#.*|)$' // hash
].join(''));
var match = href.match(reURLInformation);

var loc = window.location;  // => "http://example.com:3000/pathname/?search=test#hash"

ส่งคืน currentUrl

หากคุณต้องการส่งสตริงเป็น url ( ไม่ทำงานใน IE11 ):

var loc = new URL("http://example.com:3000/pathname/?search=test#hash")

จากนั้นคุณสามารถแยกวิเคราะห์ได้เช่น:

loc.protocol; // => "http:"
loc.host;     // => "example.com:3000"
loc.hostname; // => "example.com"
loc.port;     // => "3000"
loc.pathname; // => "/pathname/"
loc.hash;     // => "#hash"
loc.search;   // => "?search=test"

คำตอบของ freddiefujiwara ค่อนข้างดี แต่ฉันก็ต้องสนับสนุน URL ที่เกี่ยวข้องภายใน Internet Explorer ฉันคิดวิธีแก้ปัญหาต่อไปนี้ขึ้นมา:

function getLocation(href) {
    var location = document.createElement("a");
    location.href = href;
    // IE doesn't populate all link properties when setting .href with a relative URL,
    // however .href will return an absolute URL which then can be used on itself
    // to populate these additional fields.
    if (location.host == "") {
      location.href = location.href;
    }
    return location;
};

ตอนนี้ใช้เพื่อรับคุณสมบัติที่ต้องการ:

var a = getLocation('http://example.com/aa/bb/');
document.write(a.hostname);
document.write(a.pathname);

ตัวอย่าง JSFiddle: http://jsfiddle.net/6AEAB/

js-uri (มีอยู่ใน Google Code) ใช้ URL ของสตริงและแก้ไขวัตถุ URI จากมัน:

var some_uri = new URI("http://www.example.com/foo/bar");

alert(some_uri.authority); // www.example.com
alert(some_uri);           // http://www.example.com/foo/bar

var blah      = new URI("blah");
var blah_full = blah.resolve(some_uri);
alert(blah_full);         // http://www.example.com/foo/blah

สิ่งที่เกี่ยวกับการแสดงออกปกติง่าย ๆ

url = "http://www.example.com/path/to/somwhere";
urlParts = /^(?:\w+\:\/\/)?([^\/]+)(.*)$/.exec(url);
hostname = urlParts[1]; // www.example.com
path = urlParts[2]; // /path/to/somwhere

วันนี้ฉันพบปัญหานี้และพบ: URL - MDN Web APIs

var url = new URL("http://test.example.com/dir/subdir/file.html#hash");

ผลตอบแทนนี้:

{ hash:"#hash", host:"test.example.com", hostname:"test.example.com", href:"http://test.example.com/dir/subdir/file.html#hash", origin:"http://test.example.com", password:"", pathname:"/dir/subdir/file.html", port:"", protocol:"http:", search: "", username: "" }

หวังว่าการบริจาคครั้งแรกของฉันจะช่วยคุณ!

นี่คือรุ่นที่ฉันคัดลอกมาจากhttps://gist.github.com/1847816แต่เขียนใหม่ดังนั้นจึงง่ายต่อการอ่านและดีบัก วัตถุประสงค์ของการคัดลอกข้อมูลจุดยึดไปยังตัวแปรอื่นที่ชื่อว่า "ผลลัพธ์" เป็นเพราะข้อมูลจุดยึดยาวพอสมควรและการคัดลอกค่าจำนวน จำกัด ไปยังผลลัพธ์จะช่วยให้ผลลัพธ์ง่ายขึ้น

/**
 * See: https://gist.github.com/1847816
 * Parse a URI, returning an object similar to Location
 * Usage: var uri = parseUri("hello?search#hash")
 */
function parseUri(url) {

  var result = {};

  var anchor = document.createElement('a');
  anchor.href = url;

  var keys = 'protocol hostname host pathname port search hash href'.split(' ');
  for (var keyIndex in keys) {
    var currentKey = keys[keyIndex]; 
    result[currentKey] = anchor[currentKey];
  }

  result.toString = function() { return anchor.href; };
  result.requestUri = result.pathname + result.search;  
  return result;

}

แยก URL ข้ามเบราว์เซอร์ทำงานรอบปัญหาทางญาติสำหรับ IE 6, 7, 8 และ 9:

function ParsedUrl(url) {
    var parser = document.createElement("a");
    parser.href = url;

    // IE 8 and 9 dont load the attributes "protocol" and "host" in case the source URL
    // is just a pathname, that is, "/example" and not "http://domain.com/example".
    parser.href = parser.href;

    // IE 7 and 6 wont load "protocol" and "host" even with the above workaround,
    // so we take the protocol/host from window.location and place them manually
    if (parser.host === "") {
        var newProtocolAndHost = window.location.protocol + "//" + window.location.host;
        if (url.charAt(1) === "/") {
            parser.href = newProtocolAndHost + url;
        } else {
            // the regex gets everything up to the last "/"
            // /path/takesEverythingUpToAndIncludingTheLastForwardSlash/thisIsIgnored
            // "/" is inserted before because IE takes it of from pathname
            var currentFolder = ("/"+parser.pathname).match(/.*\//)[0];
            parser.href = newProtocolAndHost + currentFolder + url;
        }
    }

    // copies all the properties to this object
    var properties = ['host', 'hostname', 'hash', 'href', 'port', 'protocol', 'search'];
    for (var i = 0, n = properties.length; i < n; i++) {
      this[properties[i]] = parser[properties[i]];
    }

    // pathname is special because IE takes the "/" of the starting of pathname
    this.pathname = (parser.pathname.charAt(0) !== "/" ? "/" : "") + parser.pathname;
}

การใช้งาน ( สาธิต JSFiddle ที่นี่ ):

var myUrl = new ParsedUrl("http://www.example.com:8080/path?query=123#fragment");

ผลลัพธ์:

{
    hash: "#fragment"
    host: "www.example.com:8080"
    hostname: "www.example.com"
    href: "http://www.example.com:8080/path?query=123#fragment"
    pathname: "/path"
    port: "8080"
    protocol: "http:"
    search: "?query=123"
}

สำหรับผู้ที่กำลังมองหาโซลูชันที่ทันสมัยซึ่งใช้งานได้ใน IE, Firefox และ Chrome:

ไม่มีวิธีแก้ปัญหาเหล่านี้ที่ใช้องค์ประกอบเชื่อมโยงหลายมิติจะทำงานได้เหมือนกันในโครเมียม หากคุณส่ง URL ที่ไม่ถูกต้อง (หรือว่างเปล่า) ไปยังโครเมี่ยมจะส่งคืนโฮสต์ที่สคริปต์ถูกเรียกใช้ ดังนั้นใน IE คุณจะว่างเปล่าในขณะที่ Chrome คุณจะได้รับ localhost (หรืออะไรก็ตาม)

หากคุณพยายามที่จะดูผู้อ้างอิงนี่เป็นเรื่องหลอกลวง คุณจะต้องแน่ใจว่าโฮสต์ที่คุณได้รับนั้นอยู่ใน URL ดั้งเดิมเพื่อจัดการกับสิ่งนี้:

    function getHostNameFromUrl(url) {
        // <summary>Parses the domain/host from a given url.</summary>
        var a = document.createElement("a");
        a.href = url;

        // Handle chrome which will default to domain where script is called from if invalid
        return url.indexOf(a.hostname) != -1 ? a.hostname : '';
    }

วิธี AngularJS - ซอที่นี่: http://jsfiddle.net/PT5BG/4/

<!DOCTYPE html>
<html>
<head>
    <title>Parse URL using AngularJS</title>
</head>
<body ng-app ng-controller="AppCtrl" ng-init="init()">

<h3>Parse URL using AngularJS</h3>

url: <input type="text" ng-model="url" value="" style="width:780px;">

<ul>
    <li>href = {{parser.href}}</li>
    <li>protocol = {{parser.protocol}}</li>
    <li>host = {{parser.host}}</li>
    <li>hostname = {{parser.hostname}}</li>
    <li>port = {{parser.port}}</li>
    <li>pathname = {{parser.pathname}}</li>
    <li>hash = {{parser.hash}}</li>
    <li>search = {{parser.search}}</li>
</ul>

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.6/angular.min.js"></script>

<script>
function AppCtrl($scope) {

    $scope.$watch('url', function() {
        $scope.parser.href = $scope.url;
    });

    $scope.init = function() {
        $scope.parser = document.createElement('a');
        $scope.url = window.location;
    }

}
</script>

</body>
</html>

วิธีการแก้ปัญหาที่ง่ายและมีประสิทธิภาพโดยใช้รูปแบบโมดูล ซึ่งรวมถึงการแก้ไขสำหรับ IE ที่pathnameไม่ได้นำหน้าทับ ( /)

ฉันได้สร้างGistพร้อมกับJSFiddleซึ่งมีตัวแยกวิเคราะห์แบบไดนามิกมากขึ้น ฉันแนะนำให้คุณตรวจสอบและให้ข้อเสนอแนะ

var URLParser = (function (document) {
    var PROPS = 'protocol hostname host pathname port search hash href'.split(' ');
    var self = function (url) {
        this.aEl = document.createElement('a');
        this.parse(url);
    };
    self.prototype.parse = function (url) {
        this.aEl.href = url;
        if (this.aEl.host == "") {
           this.aEl.href = this.aEl.href;
        }
        PROPS.forEach(function (prop) {
            switch (prop) {
                case 'hash':
                    this[prop] = this.aEl[prop].substr(1);
                    break;
                default:
                    this[prop] = this.aEl[prop];
            }
        }, this);
        if (this.pathname.indexOf('/') !== 0) {
            this.pathname = '/' + this.pathname;
        }
        this.requestUri = this.pathname + this.search;
    };
    self.prototype.toObj = function () {
        var obj = {};
        PROPS.forEach(function (prop) {
            obj[prop] = this[prop];
        }, this);
        obj.requestUri = this.requestUri;
        return obj;
    };
    self.prototype.toString = function () {
        return this.href;
    };
    return self;
})(document);

การสาธิต

var URLParser = (function(document) {
  var PROPS = 'protocol hostname host pathname port search hash href'.split(' ');
  var self = function(url) {
    this.aEl = document.createElement('a');
    this.parse(url);
  };
  self.prototype.parse = function(url) {
    this.aEl.href = url;
    if (this.aEl.host == "") {
      this.aEl.href = this.aEl.href;
    }
    PROPS.forEach(function(prop) {
      switch (prop) {
        case 'hash':
          this[prop] = this.aEl[prop].substr(1);
          break;
        default:
          this[prop] = this.aEl[prop];
      }
    }, this);
    if (this.pathname.indexOf('/') !== 0) {
      this.pathname = '/' + this.pathname;
    }
    this.requestUri = this.pathname + this.search;
  };
  self.prototype.toObj = function() {
    var obj = {};
    PROPS.forEach(function(prop) {
      obj[prop] = this[prop];
    }, this);
    obj.requestUri = this.requestUri;
    return obj;
  };
  self.prototype.toString = function() {
    return this.href;
  };
  return self;
})(document);

/* Main */
var out = document.getElementById('out');
var urls = [
  'https://www.example.org:5887/foo/bar?a=1&b=2#section-1',
  'ftp://www.files.com:22/folder?id=7'
];
var parser = new URLParser();
urls.forEach(function(url) {
  parser.parse(url);
  println(out, JSON.stringify(parser.toObj(), undefined, ' '), 0, '#0000A7');
});

/* Utility functions */
function print(el, text, bgColor, fgColor) {
  var span = document.createElement('span');
  span.innerHTML = text;
  span.style['backgroundColor'] = bgColor || '#FFFFFF';
  span.style['color'] = fgColor || '#000000';
  el.appendChild(span);
}
function println(el, text, bgColor, fgColor) {
  print(el, text, bgColor, fgColor);
  el.appendChild(document.createElement('br'));
}

body {
  background: #444;
}
span {
  background-color: #fff;
  border: thin solid black;
  display: inline-block;
}
#out {
  display: block;
  font-family: Consolas, Menlo, Monaco, Lucida Console, Liberation Mono, DejaVu Sans Mono, Bitstream Vera Sans Mono, Courier New, monospace, serif;
  font-size: 12px;
  white-space: pre;
}

<div id="out"></div>

เอาท์พุต

{
 "protocol": "https:",
 "hostname": "www.example.org",
 "host": "www.example.org:5887",
 "pathname": "/foo/bar",
 "port": "5887",
 "search": "?a=1&b=2",
 "hash": "section-1",
 "href": "https://www.example.org:5887/foo/bar?a=1&b=2#section-1",
 "requestUri": "/foo/bar?a=1&b=2"
}
{
 "protocol": "ftp:",
 "hostname": "www.files.com",
 "host": "www.files.com:22",
 "pathname": "/folder",
 "port": "22",
 "search": "?id=7",
 "hash": "",
 "href": "ftp://www.files.com:22/folder?id=7",
 "requestUri": "/folder?id=7"
}

ใช้https://www.npmjs.com/package/uri-parse-libสำหรับสิ่งนี้

var t = parserURI("http://user:pass@example.com:8080/directory/file.ext?query=1&next=4&sed=5#anchor");

ทำไมไม่ใช้มัน?

        $scope.get_location=function(url_str){
        var parser = document.createElement('a');
        parser.href =url_str;//"http://example.com:3000/pathname/?search=test#hash";
        var info={
            protocol:parser.protocol,   
            hostname:parser.hostname, // => "example.com"
            port:parser.port,     // => "3000"
            pathname:parser.pathname, // => "/pathname/"
            search:parser.search,   // => "?search=test"
            hash:parser.hash,     // => "#hash"
            host:parser.host, // => "example.com:3000"      
        }
        return info;
    }
    alert( JSON.stringify( $scope.get_location("http://localhost:257/index.php/deploy/?asd=asd#asd"),null,4 ) );

นอกจากนี้คุณยังสามารถใช้parse_url()ฟังก์ชันจากโครงการLocutus (php.js เดิม)

รหัส:

parse_url('http://username:password@hostname/path?arg=value#anchor');

ผลลัพธ์:

{
  scheme: 'http',
  host: 'hostname',
  user: 'username',
  pass: 'password',
  path: '/path',
  query: 'arg=value',
  fragment: 'anchor'
}

function parseUrl(url) {
    var m = url.match(/^(([^:\/?#]+:)?(?:\/\/((?:([^\/?#:]*):([^\/?#:]*)@)?([^\/?#:]*)(?::([^\/?#:]*))?)))?([^?#]*)(\?[^#]*)?(#.*)?$/),
        r = {
            hash: m[10] || "",                   // #asd
            host: m[3] || "",                    // localhost:257
            hostname: m[6] || "",                // localhost
            href: m[0] || "",                    // http://username:password@localhost:257/deploy/?asd=asd#asd
            origin: m[1] || "",                  // http://username:password@localhost:257
            pathname: m[8] || (m[1] ? "/" : ""), // /deploy/
            port: m[7] || "",                    // 257
            protocol: m[2] || "",                // http:
            search: m[9] || "",                  // ?asd=asd
            username: m[4] || "",                // username
            password: m[5] || ""                 // password
        };
    if (r.protocol.length == 2) {
        r.protocol = "file:///" + r.protocol.toUpperCase();
        r.origin = r.protocol + "//" + r.host;
    }
    r.href = r.origin + r.pathname + r.search + r.hash;
    return m && r;
};
parseUrl("http://username:password@localhost:257/deploy/?asd=asd#asd");

ใช้งานได้ทั้ง URL แบบสัมบูรณ์และแบบสัมพัทธ์

หยุดการสร้างล้อใหม่ ใช้https://github.com/medialize/URI.js/

var uri = new URI("http://example.org:80/foo/hello.html");
// get host
uri.host(); // returns string "example.org:80"
// set host
uri.host("example.org:80");

เพียงใช้ไลบรารี url.js (สำหรับเว็บและ node.js)

https://github.com/websanova/js-url

url: http://example.com?param=test#param=again

url('?param'); // test
url('#param'); // again
url('protocol'); // http
url('port'); // 80
url('domain'); // example.com
url('tld'); // com

etc...

แฮ็คง่ายๆกับคำตอบแรก

var getLocation = function(href=window.location.href) {
    var l = document.createElement("a");
    l.href = href;
    return l;
};

สิ่งนี้สามารถใช้งานได้โดยไม่ต้องมีอาร์กิวเมนต์ที่จะคิดออกชื่อโฮสต์ปัจจุบัน getLocation () ชื่อโฮสต์จะให้ชื่อโฮสต์ปัจจุบัน