Trích xuất tên máy chủ từ chuỗi

Tôi muốn chỉ khớp với gốc của một URL chứ không phải toàn bộ URL từ một chuỗi văn bản. Được:

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

Tôi muốn nhận được 2 trường hợp cuối cùng giải quyết cho www.example.comhoặc example.comtên miền.

Tôi nghe nói regex rất chậm và đây sẽ là biểu thức regex thứ hai của tôi trên trang vì vậy Nếu có cách nào để làm điều đó mà không có regex hãy cho tôi biết.

Tôi đang tìm kiếm một phiên bản JS / jQuery của giải pháp này.

Tôi khuyên bạn nên sử dụng gói npm psl (Danh sách Suffix công khai) . "Danh sách hậu tố công cộng" là danh sách tất cả các hậu tố và quy tắc tên miền hợp lệ, không chỉ các tên miền cấp cao nhất của mã quốc gia, mà cả các ký tự unicode cũng sẽ được coi là tên miền gốc (ví dụ www. 食 狮. .Cn, bckobe .jp, v.v.). Đọc thêm về nó ở đây .

Thử:

npm install --save psl

Sau đó, với việc triển khai "extracthostname" của tôi:

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

Tôi không thể sử dụng gói npm, vì vậy, bên dưới chỉ kiểm tra 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"));

Bất kể có giao thức hoặc thậm chí số cổng, bạn có thể trích xuất tên miền. Đây là một giải pháp rất đơn giản, không regex, vì vậy tôi nghĩ rằng điều này sẽ làm.

* Cảm ơn bạn @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson vì những gợi ý của bạn! @ ross-allen, cảm ơn bạn đã báo cáo lỗi!

Một mẹo gọn gàng mà không sử dụng các biểu thức thông thường:

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'

Bao bọc bên trên trong một chức năng như bên dưới và bạn có cho mình một cách tuyệt vời để lấy phần miền ra khỏi URI.

function url_domain(data) {
  var    a      = document.createElement('a');
         a.href = data;
  return a.hostname;
}

Không cần phân tích chuỗi, chỉ cần chuyển URL của bạn làm đối số cho hàm URLtạo :

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

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

Thử cái này:

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

Nếu bạn muốn loại trừ cổng khỏi kết quả của mình, thay vào đó hãy sử dụng biểu thức này:

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

Chỉnh sửa: Để ngăn các tên miền cụ thể khớp, hãy sử dụng giao diện phủ định.(?!youtube.com)

/^https?\:\/\/(?!(?:www\.)?(?:youtube\.com|youtu\.be))([^\/:?#]+)(?:[\/:?#]|$)/i

Phân tích một URL có thể khó khăn vì bạn có thể có số cổng và ký tự đặc biệt. Vì vậy, tôi khuyên bạn nên sử dụng một cái gì đó như parseUri để làm điều này cho bạn. Tôi nghi ngờ hiệu suất sẽ là một vấn đề trừ khi bạn phân tích hàng trăm URL.

Sử dụng URL.hostnameđể dễ đọc

Trong thời đại Babel, giải pháp sạch nhất và dễ nhất là sử dụng 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 Là một phần của API URL , được hỗ trợ bởi tất cả các trình duyệt chính trừ IE ( caniuse ). Sử dụng một polyfill URL nếu bạn cần hỗ trợ các trình duyệt cũ.

Sử dụng giải pháp này cũng sẽ cung cấp cho bạn quyền truy cập vào các thuộc tính và phương thức URL khác . Điều này sẽ hữu ích nếu bạn cũng muốn trích xuất tên đường dẫn hoặc tham số chuỗi truy vấn của URL , ví dụ.

Sử dụng RegEx cho hiệu suất

URL.hostnamenhanh hơn sử dụng giải pháp neo hoặc parseUri . Tuy nhiên, nó vẫn chậm hơn nhiều so với regex của 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"));

Tự kiểm tra nó jsPerf

Nếu bạn cần xử lý một số lượng lớn URL (trong đó hiệu suất sẽ là một yếu tố), tôi khuyên bạn nên sử dụng giải pháp này thay thế. Nếu không, chọn URL.hostnamecho dễ đọc.

Tôi đã cố gắng sử dụng các giải pháp được đưa ra, một trong những lựa chọn là một sự quá mức cho mục đích của tôi và "Tạo ra một yếu tố" khiến tôi bối rối.

Nó chưa sẵn sàng cho Cổng trong URL. Tôi hy vọng ai đó thấy nó hữu ích

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

Chạy này:

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

Kết quả:

Object {
    domain : "www.facebook.com",
    host : "facebook",
    path : "100003379429021_356001651189146",
    protocol : "https",
    subdomain : "www",
    tld : "com"
}

Nếu bạn kết thúc trên trang này và bạn đang tìm kiếm REGEX tốt nhất của URL, hãy thử cái này:

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

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

Nó hoạt động cho các url mà không có http: //, với http, với https, chỉ với // và không lấy đường dẫn và đường dẫn truy vấn.

Chúc may mắn

Tất cả các thuộc tính url, không phụ thuộc, không có JQuery, dễ hiểu

Giải pháp này cho câu trả lời của bạn cộng với các thuộc tính bổ sung. Không yêu cầu JQuery hoặc các phụ thuộc khác, dán và đi.

Sử dụng

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

Đầu ra

{
  "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"
    }
  ]
}

Mã
Mã được thiết kế để dễ hiểu hơn là siêu nhanh. Nó có thể được gọi dễ dàng 100 lần mỗi giây, vì vậy thật tuyệt vời cho giao diện người dùng hoặc một vài cách sử dụng máy chủ, nhưng không phải cho thông lượng âm lượng cao.

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
}

Chỉ cần sử dụng hàm tạo URL () :

new URL(url).host

Đã tìm kiếm một giải pháp cho vấn đề này ngày hôm nay. Không có câu trả lời nào ở trên có vẻ thỏa mãn. Tôi muốn một giải pháp có thể là một lớp lót, không có logic có điều kiện và không có gì phải được bọc trong một hàm.

Đây là những gì tôi nghĩ ra, dường như hoạt động rất tốt:

tên máy chủ = "http://www.example.com:1234"
hostname.split ("//"). lát (-1) [0] .split (":") [0] .split ('.'). lát (-2) .join ('.') // đưa ra "example.com"

Thoạt nhìn có thể phức tạp, nhưng nó hoạt động khá đơn giản; khóa đang sử dụng 'lát (-n)' ở một vài vị trí mà phần tốt phải được kéo từ cuối mảng tách (và [0] để lấy từ phía trước của mảng tách).

Mỗi bài kiểm tra này trả về "example.com":

"http://example.com" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). lát (-2). tham gia('.')
"Http://example.com:1234".split("//").slice(-1)[0[.split(":")[0[.split('.').slice(-2 ).tham gia('.')
"http://www.example.com:1234" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). lát ( -2) .join ('.')
"http://foo.www.example.com:1234" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). lát (-2) .join ('.')

Đây là 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];
}

Đoạn mã trên sẽ phân tích thành công tên máy chủ cho các ví dụ sau:

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 ở đâu đó.com

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

Tín dụng gốc được chuyển đến: http://www.primaryobjects.com/CMS/Article145

Được rồi, tôi biết đây là một câu hỏi cũ, nhưng tôi đã tạo một trình phân tích cú pháp url siêu hiệu quả nên tôi nghĩ tôi sẽ chia sẻ nó.

Như bạn có thể thấy, cấu trúc của hàm rất kỳ quặc, nhưng nó mang lại hiệu quả. Không có chức năng nguyên mẫu nào được sử dụng, chuỗi không được lặp lại nhiều lần và không có ký tự nào được xử lý nhiều hơn mức cần thiết.

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

Đây không phải là một câu trả lời đầy đủ, nhưng đoạn mã dưới đây sẽ giúp bạn:

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

Tôi muốn một số để tạo mã nhanh hơn của tôi. Nó cũng giúp cải thiện bản thân tôi.

trực tuyến với 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]+.)/,"");
}

Cá nhân tôi đã nghiên cứu rất nhiều cho giải pháp này và cách tốt nhất tôi có thể tìm thấy thực sự là từ "kiểm tra trình duyệt" của 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();

Tôi đã viết lại các biến để nó dễ đọc hơn "con người", nhưng nó thực hiện công việc tốt hơn mong đợi.

Chà, sử dụng biểu thức chính quy sẽ dễ dàng hơn rất nhiều:

    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, ''));

điều này chăm sóc cả giao thức.

trong ngắn hạn, bạn có thể làm như thế này

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"

Sử dụng chức năng trên để có được tên miền

Phân tích cú pháp dường như là thư viện JavaScript có các mẫu mạnh nhất

Dưới đây là danh sách các tính năng:

Chương 1. Bình thường hóa hoặc phân tích một URL

Chương 2. Trích xuất tất cả các URL

Chương 3. Trích xuất URI với một số tên nhất định

Chương 4. Trích xuất tất cả các URL mờ

Chương 5. Đánh dấu tất cả các URL trong văn bản

Chương 6. Trích xuất tất cả các URL trong HTML hoặc XML thô

Mã số:

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

Kết quả:

youtube.com
youtu.be
example.com
example.com

parse-domain - một thư viện nhẹ rất chắc chắn

npm install parse-domain

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

ví dụ 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' ] }

Ví dụ 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' ] }

Tại sao?

Tùy thuộc vào trường hợp sử dụng và khối lượng, tôi thực sự khuyên bạn không nên tự mình giải quyết vấn đề này bằng cách sử dụng regex hoặc các phương tiện thao tác chuỗi khác. Cốt lõi của vấn đề này là bạn cần biết tất cả các hậu tố gtld và cctld để phân tích chính xác các chuỗi url thành tên miền và tên miền phụ, những hậu tố này được cập nhật thường xuyên. Đây là một vấn đề được giải quyết và không phải là một vấn đề bạn muốn tự giải quyết (trừ khi bạn là google hoặc một cái gì đó). Trừ khi bạn cần tên máy chủ hoặc tên miền trong một nhúm, đừng thử và phân tích theo cách của bạn ra khỏi cái này.

Mã của tôi trông như thế này. Biểu thức thông thường có thể có nhiều dạng và đây là những trường hợp thử nghiệm của tôi, tôi nghĩ nó có khả năng mở rộng hơn.

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

Hãy thử mã dưới đây cho tên miền chính xác bằng regex,

Chuỗi dòng = " 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");
  }