Bir JavaScript dizesinin URL olup olmadığını kontrol edin

JavaScript'te bir dizenin URL olup olmadığını kontrol etmenin bir yolu var mı?

URL büyük olasılıkla şöyle yazıldığı için RegExes hariç tutulur stackoverflow; o bir olmayabilir yani .com, wwwya http.

Cevabı olan ilgili bir soru:

Javascript normal ifade URL eşlemesi

Veya Devshed'den bu Regexp :

function validURL(str) {
  var pattern = new RegExp('^(https?:\\/\\/)?'+ // protocol
    '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
    '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
    '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
    '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
    '(\\#[-a-z\\d_]*)?$','i'); // fragment locator
  return !!pattern.test(str);
}

function isURL(str) {
  var pattern = new RegExp('^(https?:\\/\\/)?'+ // protocol
  '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|'+ // domain name
  '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
  '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
  '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
  '(\\#[-a-z\\d_]*)?$','i'); // fragment locator
  return pattern.test(str);
}

Sen kullanımı deneyebilirsiniz URLyapıcı : Bu atmak değilse, dize, geçerli bir URL:

function isValidUrl(string) {
  try {
    new URL(string);
  } catch (_) {
    return false;  
  }

  return true;
}

'URL' terimi RFC 3886'da (URI olarak) tanımlanmıştır; bir şema adıyla başlamalıdır ve şema adı http / https ile sınırlı değildir.

Dikkate değer örnekler:

• www.google.com geçerli bir URL değil (eksik şema)
• javascript:void(0) HTTP olmasa da geçerli URL
• http://..ile geçerli bir URL'dir, ev sahibi olmanın ..; çözülüp çözülmediği DNS'inize bağlıdır
• https://google..com geçerli URL, yukarıdakiyle aynı

Bir dizenin geçerli bir HTTP URL'si olup olmadığını kontrol etmek istiyorsanız:

function isValidHttpUrl(string) {
  let url;

  try {
    url = new URL(string);
  } catch (_) {
    return false;  
  }

  return url.protocol === "http:" || url.protocol === "https:";
}

Normal bir ifade kullanmak yerine, bir bağlantı elemanı kullanmanızı tavsiye ederim.

hrefan özelliğini ayarladığınızda, anchordiğer çeşitli özellikler de ayarlanır.

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

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

kaynak

Ancak, değerin hrefbağlı olması geçerli bir URL değilse, bu yardımcı özelliklerin değeri boş dize olur.

Düzenleme: yorumlarda belirtildiği gibi: geçersiz bir URL kullanılırsa, geçerli URL'nin özellikleri değiştirilebilir.

Dolayısıyla, geçerli sayfanın URL'sini geçmediğiniz sürece, aşağıdakileri yapabilirsiniz:

function isValidURL(str) {
   var a  = document.createElement('a');
   a.href = str;
   return (a.host && a.host != window.location.host);
}

URL ile veya olmadan URL doğrulamak için aşağıdaki işlevi kullanıyorum http/https:

function isValidURL(string) {
  var res = string.match(/(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/g);
  return (res !== null)
};

var testCase1 = "http://en.wikipedia.org/wiki/Procter_&_Gamble";
console.log(isValidURL(testCase1)); // return true

var testCase2 = "http://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&docid=nIv5rk2GyP3hXM&tbnid=isiOkMe3nCtexM:&ved=0CAUQjRw&url=http%3A%2F%2Fanimalcrossing.wikia.com%2Fwiki%2FLion&ei=ygZXU_2fGKbMsQTf4YLgAQ&bvm=bv.65177938,d.aWc&psig=AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g&ust=1398298682009707";
console.log(isValidURL(testCase2)); // return true

var testCase3 = "https://sdfasd";
console.log(isValidURL(testCase3)); // return false

var testCase4 = "dfdsfdsfdfdsfsdfs";
console.log(isValidURL(testCase4)); // return false

var testCase5 = "magnet:?xt=urn:btih:123";
console.log(isValidURL(testCase5)); // return false

var testCase6 = "https://stackoverflow.com/";
console.log(isValidURL(testCase6)); // return true

var testCase7 = "https://w";
console.log(isValidURL(testCase7)); // return false

var testCase8 = "https://sdfasdp.ppppppppppp";
console.log(isValidURL(testCase8)); // return false

Javascript kullanarak Url'yi Doğrulamak için aşağıda gösterilmiştir

function ValidURL(str) {
  var regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
  if(!regex .test(str)) {
    alert("Please enter valid URL.");
    return false;
  } else {
    return true;
  }
}

Bir kütüphaneye güvenin: https://www.npmjs.com/package/valid-url

import { isWebUri } from 'valid-url';
// ...
if (!isWebUri(url)) {
    return "Not a valid url.";
}

Kabul edilen cevapta iyileştirme ...

• Protokol olarak ftp / ftps olup olmadığını kontrol edin
• Ters eğik çizgiler için çift çıkış (\\) var
• Alan adlarının bir noktaya ve uzantıya sahip olmasını sağlar (.com .io .xyz)
• Yolda tam iki nokta üst üste (:) işaretine izin verir http://thingiverse.com/download:1894343
• Yoldaki "ve" işaretine (&) izin verir, örneğin http://en.wikipedia.org/wiki/Procter_&_Gamble

• Yoldaki @ simgesine izin verir örn. Https://medium.com/@techytimo

  isURL(str) {
    var pattern = new RegExp('^((ft|htt)ps?:\\/\\/)?'+ // protocol
    '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name and extension
    '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
    '(\\:\\d+)?'+ // port
    '(\\/[-a-z\\d%@_.~+&:]*)*'+ // path
    '(\\?[;&a-z\\d%@_.,~+&:=-]*)?'+ // query string
    '(\\#[-a-z\\d_]*)?$','i'); // fragment locator
    return pattern.test(str);
  }

İşte başka bir yöntem.

var elm;
function isValidURL(u){
  if(!elm){
    elm = document.createElement('input');
    elm.setAttribute('type', 'url');
  }
  elm.value = u;
  return elm.validity.valid;
}

console.log(isValidURL('http://www.google.com/'));
console.log(isValidURL('//google.com'));
console.log(isValidURL('google.com'));
console.log(isValidURL('localhost:8000'));

( ValidURL örneğine yorum yapmak için temsilcim yok ; bu nedenle bunu bir cevap olarak gönderin.)

Protokole bağlı URL'lerin kullanımı desteklenmese de ( Protokole bağlı URL ), bazen işe alınırlar. Böyle bir URL'yi normal bir ifadeyle doğrulamak için protokol kısmı isteğe bağlı olabilir, örneğin:

function isValidURL(str) {
    var pattern = new RegExp('^((https?:)?\\/\\/)?'+ // protocol
        '(?:\\S+(?::\\S*)?@)?' + // authentication
        '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
        '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
        '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
        '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
        '(\\#[-a-z\\d_]*)?$','i'); // fragment locater
    if (!pattern.test(str)) {
        return false;
    } else {
        return true;
    }
}

Diğerlerinin belirttiği gibi, düzenli ifade URL'leri doğrulamak için en uygun yaklaşım gibi görünmemektedir.

URL yerel API'sını kullanabilirsiniz :

  const isUrl = string => {
      try { return Boolean(new URL(string)); }
      catch(e){ return false; }
  }

Daha önce belirtildiği gibi, mükemmel regex zor ama yine de makul bir yaklaşım gibi görünüyor (alternatifler sunucu tarafı testleri veya yeni deneysel URL API'sıdır ). Bununla birlikte, yüksek sıralamalı yanıtlar genellikle yaygın URL'ler için yanlış döndürür, ancak daha da kötüsü, uygulamanızı / sayfanızı dakikalar boyunca basit bir dizede bile dondurur isURL('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'). Bazı yorumlarda işaret edildi, ancak büyük olasılıkla görmek için kötü bir değer girmedi. Böyle asmak, bu kodu herhangi bir ciddi uygulamada kullanılamaz hale getirir. Kod gibi tekrarlanan vaka duyarsız setleri nedeniyle düşünüyorum ((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|' .... 'İ' yi çıkarın ve asmayın ama elbette istendiği gibi çalışmayacak. Ancak yoksayma durumu bayrağıyla bile, bu testler izin verilen yüksek unicode değerlerini reddeder.

Daha önce bahsedilen en iyi şey:

function isURL(str) {
  return /^(?:\w+:)?\/\/([^\s\.]+\.\S{2}|localhost[\:?\d]*)\S*$/.test(str); 
}

Bu Github segmentio / is-url'den geliyor . Bir kod deposu ile ilgili iyi bir şey, testi ve herhangi bir sorunu görebilmeniz ve ayrıca test dizelerinin üzerinden geçmesidir. google.comMuhtemelen o zaman çok fazla varsayım yapsanız da, dizeleri protokol eksik gibi izin verecek bir şube var . Depo güncellendi ve burada bir ayna tutmayı düşünmüyorum. DOS saldırıları için sömürülebilen RegEx redosunu önlemek için ayrı testlere ayrıldı (İstemci tarafı js ile ilgili endişelenmeniz gerektiğini düşünmüyorum, ancak sayfanızın bu kadar uzun süre asılı kalması konusunda endişelenmeniz gerekiyor. ziyaretçi sitenizden ayrılır).

Dperini / regex-weburl.js'de isURL için daha iyi olabileceğini düşündüğüm başka bir havuz var , ancak oldukça karmaşık. Geçerli ve geçersiz URL'lerin daha büyük bir test listesine sahiptir. Yukarıdaki basit olan hala tüm pozitifleri geçer ve sadece http://a.b--c.de/özel ips gibi birkaç garip negatifi engellemez .

Hangisini seçerseniz seçin, tarayıcınızın Geliştirici Araçları denetçisini kullanırken dperini / regex-weburl.js'deki testlerden uyarladığım bu işlevle çalıştırın.

function testIsURL() {
//should match
console.assert(isURL("http://foo.com/blah_blah"));
console.assert(isURL("http://foo.com/blah_blah/"));
console.assert(isURL("http://foo.com/blah_blah_(wikipedia)"));
console.assert(isURL("http://foo.com/blah_blah_(wikipedia)_(again)"));
console.assert(isURL("http://www.example.com/wpstyle/?p=364"));
console.assert(isURL("https://www.example.com/foo/?bar=baz&inga=42&quux"));
console.assert(isURL("http://✪df.ws/123"));
console.assert(isURL("http://userid:password@example.com:8080"));
console.assert(isURL("http://userid:password@example.com:8080/"));
console.assert(isURL("http://userid@example.com"));
console.assert(isURL("http://userid@example.com/"));
console.assert(isURL("http://userid@example.com:8080"));
console.assert(isURL("http://userid@example.com:8080/"));
console.assert(isURL("http://userid:password@example.com"));
console.assert(isURL("http://userid:password@example.com/"));
console.assert(isURL("http://142.42.1.1/"));
console.assert(isURL("http://142.42.1.1:8080/"));
console.assert(isURL("http://➡.ws/䨹"));
console.assert(isURL("http://⌘.ws"));
console.assert(isURL("http://⌘.ws/"));
console.assert(isURL("http://foo.com/blah_(wikipedia)#cite-1"));
console.assert(isURL("http://foo.com/blah_(wikipedia)_blah#cite-1"));
console.assert(isURL("http://foo.com/unicode_(✪)_in_parens"));
console.assert(isURL("http://foo.com/(something)?after=parens"));
console.assert(isURL("http://☺.damowmow.com/"));
console.assert(isURL("http://code.google.com/events/#&product=browser"));
console.assert(isURL("http://j.mp"));
console.assert(isURL("ftp://foo.bar/baz"));
console.assert(isURL("http://foo.bar/?q=Test%20URL-encoded%20stuff"));
console.assert(isURL("http://مثال.إختبار"));
console.assert(isURL("http://例子.测试"));
console.assert(isURL("http://उदाहरण.परीक्षा"));
console.assert(isURL("http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com"));
console.assert(isURL("http://1337.net"));
console.assert(isURL("http://a.b-c.de"));
console.assert(isURL("http://223.255.255.254"));
console.assert(isURL("postgres://u:p@example.com:5702/db"));
console.assert(isURL("https://d1f4470da51b49289906b3d6cbd65074@app.getsentry.com/13176"));

//SHOULD NOT MATCH:
console.assert(!isURL("http://"));
console.assert(!isURL("http://."));
console.assert(!isURL("http://.."));
console.assert(!isURL("http://../"));
console.assert(!isURL("http://?"));
console.assert(!isURL("http://??"));
console.assert(!isURL("http://??/"));
console.assert(!isURL("http://#"));
console.assert(!isURL("http://##"));
console.assert(!isURL("http://##/"));
console.assert(!isURL("http://foo.bar?q=Spaces should be encoded"));
console.assert(!isURL("//"));
console.assert(!isURL("//a"));
console.assert(!isURL("///a"));
console.assert(!isURL("///"));
console.assert(!isURL("http:///a"));
console.assert(!isURL("foo.com"));
console.assert(!isURL("rdar://1234"));
console.assert(!isURL("h://test"));
console.assert(!isURL("http:// shouldfail.com"));
console.assert(!isURL(":// should fail"));
console.assert(!isURL("http://foo.bar/foo(bar)baz quux"));
console.assert(!isURL("ftps://foo.bar/"));
console.assert(!isURL("http://-error-.invalid/"));
console.assert(!isURL("http://a.b--c.de/"));
console.assert(!isURL("http://-a.b.co"));
console.assert(!isURL("http://a.b-.co"));
console.assert(!isURL("http://0.0.0.0"));
console.assert(!isURL("http://10.1.1.0"));
console.assert(!isURL("http://10.1.1.255"));
console.assert(!isURL("http://224.1.1.1"));
console.assert(!isURL("http://1.1.1.1.1"));
console.assert(!isURL("http://123.123.123"));
console.assert(!isURL("http://3628126748"));
console.assert(!isURL("http://.www.foo.bar/"));
console.assert(!isURL("http://www.foo.bar./"));
console.assert(!isURL("http://.www.foo.bar./"));
console.assert(!isURL("http://10.1.1.1"));}

Ve sonra o dizeyi test edin.

Görünüşte harika bir normal ifade göndermeden önce, daha fazla bilgi için isURL normal ifadesinin Mathias Bynens'in bu karşılaştırmasına bakın .

Ben en yakın # 5717133 sonrası yorum yapamam , ama aşağıda @ tom-gullen regex çalışma nasıl anladım yolu.

/^(https?:\/\/)?((([a-z\d]([a-z\d-]*[a-z\d])*)\.)+[a-z]{2,}|((\d{1,3}\.){3}\d{1,3}))(\:\d+)?(\/[-a-z\d%_.~+]*)*(\?[;&a-z\d%_.~+=-]*)?(\#[-a-z\d_]*)?$/i

Validator.js kullanın

ES6

import isURL from 'validator/lib/isURL'

isURL(string)

ES6 yok

var validator = require('validator');

validator.isURL(string)

Ayrıca, isteğe bağlı optionsnesneyi ikinci argüman olarak ileterek bu işlevin davranışında ince ayar yapabilirsiniz .isURL

İşte varsayılan optionsnesne:

let options = {
    protocols: [
        'http',
        'https',
        'ftp'
    ],
    require_tld: true,
    require_protocol: false,
    require_host: true,
    require_valid_protocol: true,
    allow_underscores: false,
    host_whitelist: false,
    host_blacklist: false,
    allow_trailing_dot: false,
    allow_protocol_relative_urls: false,
    disallow_auth: false
}

isURL(string, options)

host_whitelistve host_blacklistana diziler olabilir. Ayrıca düzenli ifadeleri de desteklerler.

let options = {
    host_blacklist: ['foo.com', 'bar.com'],
}

isURL('http://foobar.com', options) // => true
isURL('http://foo.bar.com/', options) // => true
isURL('http://qux.com', options) // => true

isURL('http://bar.com/', options) // => false
isURL('http://foo.com/', options) // => false


options = {
    host_blacklist: ['bar.com', 'foo.com', /\.foo\.com$/],
}

isURL('http://foobar.com', options) // => true
isURL('http://foo.bar.com/', options) // => true
isURL('http://qux.com', options) // => true

isURL('http://bar.com/', options) // => false
isURL('http://foo.com/', options) // => false
isURL('http://images.foo.com/', options) // => false
isURL('http://cdn.foo.com/', options) // => false
isURL('http://a.b.c.foo.com/', options) // => false

Bir URL "dizesi" doğrulamak için kullandığınız bir işlevi:

var matcher = /^(?:\w+:)?\/\/([^\s\.]+\.\S{2}|localhost[\:?\d]*)\S*$/;

function isUrl(string){
  return matcher.test(string);
}

Bu işlev, dize bir URL olsa da bir boole döndürür.

Örnekler:

isUrl("https://google.com");     // true
isUrl("http://google.com");      // true
isUrl("http://google.de");       // true
isUrl("//google.de");            // true
isUrl("google.de");              // false
isUrl("http://google.com");      // true
isUrl("http://localhost");       // true
isUrl("https://sdfasd");         // false

URL'lerin birçok 'rahatsızlığı' olduğu için bunun saf normal ifade ile yapılması oldukça zordur.

1. Örneğin, alan adlarının tireler üzerinde karmaşık kısıtlamaları vardır:

   a. Ortada birçok ardışık tirenin bulunmasına izin verilir.

   b. ancak alan adının ilk karakteri ve son karakteri kısa çizgi olamaz

   c. 3. ve 4. karakterlerin her ikisi de kısa çizgi olamaz

2. Benzer şekilde port numarası sadece 1-65535 aralığında olabilir. Bu, bağlantı noktası parçasını çıkarıp dönüştürüp dönüştürmediğinizi kontrol etmek kolaydır, intancak normal bir ifade ile kontrol etmek oldukça zordur.

3. Geçerli alan adı uzantılarını kontrol etmenin kolay bir yolu da yoktur. Bazı ülkelerde ikinci düzey alan adları vardır ('co.uk' gibi) veya uzantı, '.international' gibi uzun bir kelime olabilir. Ve yeni TLD'ler düzenli olarak eklenir. Bu tür şeyler yalnızca sabit kodlu bir listeyle kontrol edilebilir. (bkz. https://en.wikipedia.org/wiki/Top-level_domain )

4. Sonra mıknatıs URL'leri, ftp adresleri vb. Var. Bunların hepsinin farklı gereksinimleri var.

Bununla birlikte, burada aşağıdakiler hariç hemen hemen her şeyi işleyen bir işlev var:

• Durum 1. c
• 1-5 basamaklı herhangi bir bağlantı noktası numarasını kabul eder
• 2-13 karakter uzantılarını kabul eder
• Ftp, mıknatıs vb. Kabul etmez.

function isValidURL(input) {
    pattern = '^(https?:\\/\\/)?' + // protocol
        '((([a-zA-Z\\d]([a-zA-Z\\d-]{0,61}[a-zA-Z\\d])*\\.)+' + // sub-domain + domain name
        '[a-zA-Z]{2,13})' + // extension
        '|((\\d{1,3}\\.){3}\\d{1,3})' + // OR ip (v4) address
        '|localhost)' + // OR localhost
        '(\\:\\d{1,5})?' + // port
        '(\\/[a-zA-Z\\&\\d%_.~+-:@]*)*' + // path
        '(\\?[a-zA-Z\\&\\d%_.,~+-:@=;&]*)?' + // query string
        '(\\#[-a-zA-Z&\\d_]*)?$'; // fragment locator
    regex = new RegExp(pattern);
    return regex.test(input);
}

let tests = [];
tests.push(['', false]);
tests.push(['http://en.wikipedia.org/wiki/Procter_&_Gamble', true]);
tests.push(['https://sdfasd', false]);
tests.push(['http://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&docid=nIv5rk2GyP3hXM&tbnid=isiOkMe3nCtexM:&ved=0CAUQjRw&url=http%3A%2F%2Fanimalcrossing.wikia.com%2Fwiki%2FLion&ei=ygZXU_2fGKbMsQTf4YLgAQ&bvm=bv.65177938,d.aWc&psig=AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g&ust=1398298682009707', true]);
tests.push(['https://stackoverflow.com/', true]);
tests.push(['https://w', false]);
tests.push(['aaa', false]);
tests.push(['aaaa', false]);
tests.push(['oh.my', true]);
tests.push(['dfdsfdsfdfdsfsdfs', false]);
tests.push(['google.co.uk', true]);
tests.push(['test-domain.MUSEUM', true]);
tests.push(['-hyphen-start.gov.tr', false]);
tests.push(['hyphen-end-.com', false]);
tests.push(['https://sdfasdp.international', true]);
tests.push(['https://sdfasdp.pppppppp', false]);
tests.push(['https://sdfasdp.ppppppppppppppppppp', false]);
tests.push(['https://sdfasd', false]);
tests.push(['https://sub1.1234.sub3.sub4.sub5.co.uk/?', true]);
tests.push(['http://www.google-com.123', false]);
tests.push(['http://my--testdomain.com', false]);
tests.push(['http://my2nd--testdomain.com', true]);
tests.push(['http://thingiverse.com/download:1894343', true]);
tests.push(['https://medium.com/@techytimo', true]);
tests.push(['http://localhost', true]);
tests.push(['localhost', true]);
tests.push(['localhost:8080', true]);
tests.push(['localhost:65536', true]);
tests.push(['localhost:80000', false]);
tests.push(['magnet:?xt=urn:btih:123', true]);

for (let i = 0; i < tests.length; i++) {
    console.log('Test #' + i + (isValidURL(tests[i][0]) == tests[i][1] ? ' passed' : ' failed') + ' on ["' + tests[i][0] + '", ' + tests[i][1] + ']');
}

Yerel URL API kullanarak @pavlo önerilen karmaşık bir normal ifade desen daha iyi olduğunu düşünüyorum . Bazı ekstra kodlarla düzeltebileceğimiz bazı dezavantajları var. Bu yaklaşım aşağıdaki geçerli URL için başarısız olur.

//cdn.google.com/script.js

Bundan kaçınmak için eksik protokolü önceden ekleyebiliriz. Ayrıca, aşağıdaki geçersiz URL'yi algılayamaz.

http://w
http://..

Peki neden tüm url'yi kontrol etmeliyim? sadece alanı kontrol edebiliriz. Buradan alan adını doğrulamak için normal ifadeyi ödünç aldım .

function isValidUrl(string) {
    if (string && string.length > 1 && string.slice(0, 2) == '//') {
        string = 'http:' + string; //dummy protocol so that URL works
    }
    try {
        var url = new URL(string);
        return url.hostname && url.hostname.match(/^([a-z0-9])(([a-z0-9-]{1,61})?[a-z0-9]{1})?(\.[a-z0-9](([a-z0-9-]{1,61})?[a-z0-9]{1})?)?(\.[a-zA-Z]{2,4})+$/) ? true : false;
    } catch (_) {
        return false;
    }
}

hostnameNitelik boş dizedir javascript:void(0)çok bunun için çalışır ve aynı zamanda doğrulayıcı çok IP adresi ekleyebilir, böylece. Yerel API'lerin çoğuna bağlı kalmak istiyorum ve umarım yakın gelecekte her şeyi desteklemeye başlar.

Soru stackoverflow, protokol veya ana makine adında herhangi bir nokta olmadan bir url için doğrulama yöntemi ister . Bu nedenle, URL sintaksını doğrulama meselesi değil, gerçekten çağırarak geçerli bir URL olup olmadığını kontrol etmek.

Url true var olup olmadığını ve tarayıcı içinden çağrılabilir olup olmadığını bilmek için çeşitli yöntemler denedim, ancak javascript ile çağrının yanıt başlığını test etmek için herhangi bir yol bulamadık:

• bir tutturma elemanının eklenmesi click()yöntemi ateşlemek için iyidir .
• ajax ile zorlu url'ye çağrı yapmak 'GET'iyidir, ancak CORSpolitikalar nedeniyle çeşitli sınırlamaları vardır ajaxve url belki de sunucumun etki alanının dışında herhangi bir şekilde kullanıldığında değildir .
• getirme API'sini kullanmanın ajax'a benzer bir çözümü vardır.
• diğer sorun sunucum httpsprotokol altında var ve güvenli olmayan URL'leri çağırırken bir istisna atar.

Yani, aklıma gelen en iyi çözüm CURLgibi bir şey denemek javascript kullanarak gerçekleştirmek için bazı araç elde etmektir curl -I <url>. Ne yazık ki herhangi bir şey bulamadım ve görünüşe göre bu mümkün değil. Bu konuda herhangi bir yorum takdir edecektir.

Ama sonunda, çalışan bir sunucum var PHPve Ajax'ı neredeyse tüm taleplerim için kullandığımda, sunucu tarafında kıvrılma isteğini gerçekleştirmek ve tarayıcıya geri dönmek için bir işlev yazdım.

'Stackoverflow' sorusundaki tek kelimelik url ile ilgili olarak beni https://daniserver.com.ar/stackoverflowdaniserver.com.ar kendi etki alanım olacak .

Bu, CS'deki en zor problemlerden biri gibi görünüyor;)

İşte benim için yeterince iyi ve burada gördüğüm diğerlerinden daha iyi çalışan başka bir eksik çözüm. IE11 desteklemek için bunun için bir girdi [type = url] kullanıyorum, aksi takdirde bunun yerine doğrulama gerçekleştirmek için window.URL kullanarak çok daha kolay olurdu:

const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
function isValidIpv4(ip) {
  if (!ipv4Regex.test(ip)) return false;
  return !ip.split('.').find(n => n > 255);
}

const domainRegex = /(?:[a-z0-9-]{1,63}\.){1,125}[a-z]{2,63}$/i;
function isValidDomain(domain) {
  return isValidIpv4(domain) || domainRegex.test(domain);
}

let input;
function validateUrl(url) {
  if (! /^https?:\/\//.test(url)) url = `http://${url}`; // assuming Babel is used
  // to support IE11 we'll resort to input[type=url] instead of window.URL:
  // try { return isValidDomain(new URL(url).host) && url; } catch(e) { return false; }
  if (!input) { input = document.createElement('input'); input.type = 'url'; }
  input.value = url;
  if (! input.validity.valid) return false;
  const domain = url.split(/^https?:\/\//)[1].split('/')[0].split('@').pop();
  return isValidDomain(domain) && url;
}

console.log(validateUrl('google'), // false
  validateUrl('user:pw@mydomain.com'),
  validateUrl('https://google.com'),
  validateUrl('100.100.100.100/abc'),
  validateUrl('100.100.100.256/abc')); // false

"Www.alanadim.com" gibi eksik girdileri kabul etmek için, bu durumlarda protokolün "http" olduğu varsayılarak ve adres geçerliyse geçerli URL döndürülürse geçerli olur. Geçersiz olduğunda false değerini döndürür.

IPv4 alan adlarını da destekler, ancak IPv6'yı desteklemez.

Benim durumumda tek gereksinimim, bir etiketin href'ine yerleştirildiğinde kullanıcı girdisinin göreli bir bağlantı olarak yorumlanmaması ve buradaki yanıtların ya bunun için biraz OTT olması ya da gereksinimlerimi karşılamamasına izin verilen URL'ler olmasıdır. ben ne ile gidiyor:

^https?://.+$

Aynı şey regex olmadan kolayca elde edilebilir.

bu benimle çalışıyor

function isURL(str) {
  var regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
  var pattern = new RegExp(regex); 
return pattern.test(str);
}

Giriş türünü değiştirebilirseniz, bu çözümün çok daha kolay olacağını düşünüyorum:

Girişinizde basit bir şekilde kullanabilirsiniz type="url"vecheckValidity() js .

Örneğin:

your.html

<input id="foo" type="url">

your.js

// The selector is JQuery, but the function is plain JS
$("#foo").on("keyup", function() {
    if (this.checkValidity()) {
        // The url is valid
    } else {
        // The url is invalid
    }
});

Bu meydan okurcasına en etkili yaklaşım değildir, ancak ihtiyacınız olan her şey için okunabilir ve oluşturulması kolaydır. Ve buradan regex / karmaşıklık eklemek daha kolay. İşte çok pragmatik bir yaklaşım

const validFirstBits = ["ftp://", "http://", "https://", "www."];
const invalidPatterns = [" ", "//.", ".."];

export function isUrl(word) {
// less than www.1.dk
if (!word || word.length < 8) return false;

// Let's check and see, if our candidate starts with some of our valid first bits
const firstBitIsValid = validFirstBits.some(bit => word.indexOf(bit) === 0);
if (!firstBitIsValid) return false;

const hasInvalidPatterns = invalidPatterns.some(
    pattern => word.indexOf(pattern) !== -1,
);

if (hasInvalidPatterns) return false;

const dotSplit = word.split(".");
if (dotSplit.length > 1) {
    const lastBit = dotSplit.pop(); // string or undefined
    if (!lastBit) return false;
    const length = lastBit.length;
    const lastBitIsValid =
        length > 1 || (length === 1 && !isNaN(parseInt(lastBit)));
    return !!lastBitIsValid;
}

    return false;
}

ÖLÇEK:

import { isUrl } from "./foo";

describe("Foo", () => {
    test("should validate correct urls correctly", function() {
        const validUrls = [
            "http://example.com",
            "http://example.com/blah",
            "http://127.0.0.1",
            "http://127.0.0.1/wow",
            "https://example.com",
            "https://example.com/blah",
            "https://127.0.0.1:1234",
            "ftp://example.com",
            "ftp://example.com/blah",
            "ftp://127.0.0.1",
            "www.example.com",
            "www.example.com/blah",
        ];

        validUrls.forEach(url => {
            expect(isUrl(url) && url).toEqual(url);
        });
    });

    test("should validate invalid urls correctly", function() {
        const inValidUrls = [
            "http:// foo.com",
            "http:/foo.com",
            "http://.foo.com",
            "http://foo..com",
            "http://.com",
            "http://foo",
            "http://foo.c",
        ];

        inValidUrls.forEach(url => {
            expect(!isUrl(url) && url).toEqual(url);
        });
    });
});

Mathias Bynens, iyi bilinen URL normal ifadelerinin bir listesini derledi test URL'leriyle . Yeni bir düzenli ifade yazmak için çok az neden var; size en uygun mevcut olanı seçin.

Ancak, bu normal ifadeler için karşılaştırma tablosu, URL doğrulamasını tek bir normal ifade ile yapmanın imkansız olduğunu da gösterir. Bynens listesindeki tüm regex'ler yanlış pozitifler ve yanlış negatifler üretir.

Varolan bir URL ayrıştırıcısını (örneğin new URL('http://www.example.com/')JavaScript'te) kullanmanızı ve ardından URL'nin ayrıştırılmış ve normalleştirilmiş formuna karşı gerçekleştirmek istediğiniz denetimleri uygulamanızı öneririm . bileşenleri. JavaScript URLarayüzünü kullanmanın, yalnızca tarayıcı tarafından gerçekten kabul edilen URL'leri kabul etmesinin ek avantajı vardır.

Ayrıca, teknik olarak yanlış URL'lerin hala işe yarayabileceğini unutmayın. Örneğin http://w_w_w.example.com/, http://www..example.com/, http://123.example.com/bütün geçersiz makine adı parçası var ama biliyorum her tarayıcı şikayetler olmadan bunları açmaya olacak ve bu geçersiz adlarında IP adreslerini belirtmek zaman/etc/hosts/ URL'ler bile işe ama sadece bilgisayarınızda olacaktır.

Bu nedenle soru, bir URL'nin geçerli olup olmadığı kadar değil, hangi URL'lerin çalıştığı ve belirli bir bağlamda izin verilmesi gerektiği sorusudur.

URL doğrulaması yapmak istiyorsanız, gözden kaçması kolay birçok ayrıntı ve kenar durumu vardır:

• URL'ler, aşağıdaki gibi kimlik bilgileri içerebilir http://user:password@www.example.com/ .
• Bağlantı noktası numaraları 0-65535 aralığında olmalıdır, ancak yine de joker bağlantı noktası 0'ı hariç tutmak isteyebilirsiniz.
• Bağlantı noktası numaralarının http://www.example.com:000080/ adresinde olduğu gibi önde gelen sıfırları olabilir .
• IPv4 adresleri hiçbir şekilde 0-255 aralığında 4 ondalık sayı ile sınırlandırılmamıştır. Bir ila dört tamsayı kullanabilirsiniz ve bunlar ondalık, sekizli veya onaltılık olabilir. URL'ler https: //010.010.000010.010/ , https: //0x8.0x8.0x0008.0x8/ , https: //8.8.2056/ , https: //8.526344/ , https: // 134744072 / tüm geçerlidir ve sadece yaratıcı yazma yolları https://8.8.8.8/ .
• Geridöngü adreslerine ( http://127.0.0.1/ ), özel IP adreslerine ( http://192.168.1.1 ), yerel bağlantı adreslerine ( http://169.254.100.200 ) ve benzerlerine izin verilmesi güvenlik üzerinde etkili olabilir veya gizlilik. Örneğin, bir forumdaki kullanıcı avatarlarının adresi olarak izin verirseniz, kullanıcıların tarayıcılarının yerel ağlarında ve internette istenmeyen ağ istekleri göndermesine neden olursunuz, bu tür istekler komik olabilir ve çok komik olmayan şeylere neden olabilir. evinde ol.
• Aynı nedenlerle, tam nitelikli olmayan ana bilgisayar adlarına, diğer bir deyişle noktalı olmayan ana bilgisayar adlarına olan bağlantıları silmek isteyebilirsiniz.
• Ancak ana makine adlarının her zaman bir noktaya sahip olabilir (gibi http://www.stackoverflow.com.).
• Bağlantının ana bilgisayar adı bölümü, IPv6 adresleri için http: // [:: 1] ' deki gibi köşeli ayraç içerebilir .
• IPv6 adreslerinin ayrıca özel ağlar veya yerel bağlantı adresleri vb.
• Belirli IPv4 adreslerini engellerseniz, örneğin https://127.0.0.1 ve https: // [:: ffff: 127.0.0.1] aynı kaynağı gösterdiğini unutmayın (makinenizin geridönüş aygıtı IPv6 için hazırsa) ).
• URL'lerin ana bilgisayar adı kısmı artık Unicode içerebilir, böylece karakter aralığı [-0-9a-zA-z]artık yeterli değildir.
• Üst düzey etki alanlarına yönelik birçok kayıt, örneğin izin verilen Unicode karakter kümesinde belirli kısıtlamalar tanımlar. Veya ad alanlarını ( co.ukve diğerleri gibi) alt bölümlere ayırırlar .
• Üst düzey alan adları ondalık basamak içermemelidir ve "xn--" IDN A etiketi öneki için tireye izin verilmez.
• Unicode üst düzey alan adları (ve "xn--" ile punycode kodlaması) yine de yalnızca harf içermelidir, ancak bunu normal ifadeyle kim kontrol etmek ister?

Bu sınırlamaların ve kuralların hangisi geçerli olduğu proje gereklilikleri ve zevkleri ile ilgilidir.

Kısa süre önce forumlarda, sosyal ağlarda veya benzerlerinde kullanıcı tarafından sağlanan URL'ler için uygun bir web uygulaması için bir URL doğrulayıcı yazdım. Kendiniz için bir üs olarak kullanmaktan çekinmeyin:

• (Açısal) kullanıcı arabirimi için JavaScript / Dizgi metni sürümü
• Arka uç için Perl sürümü

Ayrıca daha derinlemesine bilgiler içeren URL Doğrulamasının Kanlı Ayrıntıları adlı bir blog yazısı da yazdım .

İşlevi Match + olarak eğik çizgiler ve çalışmasıyla burada bir değişiklik yapmak için değiştiriyorum: (http: // ve https)

function isValidUrl(userInput) {
    var res = userInput.match(/(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/g);
    if(res == null)
       return false;
    else
       return true;
}

Geçerli bir protokol olduğundan emin olmak için çok basit bir kontrol ve alan adı uzantısının iki veya daha fazla karakter olması gerekir.

is_valid_url = ( $url ) => {

    let $url_object = null;

    try {
        $url_object = new URL( $url );
    } catch ( $error ) {
        return false;
    }

    const $protocol = $url_object.protocol;
    const $protocol_position = $url.lastIndexOf( $protocol );
    const $domain_extension_position = $url.lastIndexOf( '.' );

    return (
        $protocol_position === 0 &&
        [ 'http:', 'https:' ].indexOf( $protocol ) !== - 1 &&
        $domain_extension_position > 2 && $url.length - $domain_extension_position > 2
    );

};

Ayrıca desteklemeniz gerekiyorsa https://localhost:3000, [Devshed] s normal ifadesinin değiştirilmiş sürümünü kullanın.

    function isURL(url) {
        if(!url) return false;
        var pattern = new RegExp('^(https?:\\/\\/)?'+ // protocol
            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
            '((\\d{1,3}\\.){3}\\d{1,3}))|' + // OR ip (v4) address
            'localhost' + // OR localhost
            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
            '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
            '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
        return pattern.test(url);
    }

URL yapıcısını kullanarak, girdinin bir dize mi yoksa URL nesnesi mi olduğunu tanımlayan birkaç test vardır.

// Testing whether something is a URL
function isURL(url) {
    return toString.call(url) === "[object URL]";
}

// Testing whether the input is both a string and valid url:
function isUrl(url) {
    try {
        return toString.call(url) === "[object String]" && !!(new URL(url));
    } catch (_) {
        return false;  
    }
}

2020 Güncellemesi. Hem @iamnewton hem de @Fernando Chavez Herrera'nın mükemmel yanıtlarını genişletmek için @URL'ler yolunda kullanıldığını görmeye başladım .

Güncellenmiş normal ifade:

RegExp('(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+@]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$', 'i');

Sorgu dizesinde ve karma değerinde izin vermek istiyorsanız, şunu kullanın:

RegExp('(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+@]*)*(\\?[;&a-z\\d%_.~+=-@]*)?(\\#[-a-z\\d_@]*)?$', 'i');

Olduğu söyleniyor, @sorgu dizesi veya karma disallowing bir teknik inceleme kuralı olup olmadığından emin değilim .

Zaten çok sayıda yanıt var, ancak başka bir katkı daha var: Doğrudan URLçoklu dolgu geçerlilik kontrolünden alınan, tarayıcının yerleşik geçerlilik kontrolünden yararlanmak için bir inputöğe kullanın type="url":

var inputElement = doc.createElement('input');
inputElement.type = 'url';
inputElement.value = url;

if (!inputElement.checkValidity()) {
    throw new TypeError('Invalid URL');
}

Kaynak