चेक करें कि जावास्क्रिप्ट स्ट्रिंग URL है या नहीं

284

क्या कोई स्ट्रिंग URL है या नहीं यह जाँचने के लिए जावास्क्रिप्ट में एक तरीका है?

RegExes को बाहर रखा गया है क्योंकि URL की संभावना सबसे अधिक है जैसे stackoverflow; यह कहना है कि यह एक .com, wwwया नहीं हो सकता है http।

javascript  string  url 
— ब्रूनो
स्रोत
22
यदि यह गायब है http, तो यह डिफ़ॉल्ट रूप से कोई यूआरएल नहीं है।
— nfechner
1
@nfechner का कहना है कि यदि यह एक प्रोटोकॉल निर्दिष्ट नहीं करता है और बृहदान्त्र वर्ण का उपयोग करता है (अधिमानतः दो आगे स्लैश के साथ) तो यह एक URL नहीं है?
— jcolebrand
5
जैसा कि आप URL RFC में पढ़ सकते हैं , स्ट्रिंग को एक मान्य URL बनाने के लिए वास्तव में केवल एक हिस्सा है। मान्य URL इस तरह दिखते हैं:<scheme>:<scheme-specific-part>
— nfechner
1
— nguyên
8
आप कैसे परीक्षण करते हैं कि क्या कुछ URL अत्यधिक संदर्भ-निर्भर है और बहुत अधिक योग्यता के बिना अस्पष्ट है। क्या यह आपके लिए मायने रखता है कि यह URL RFC युक्ति के अनुरूप है, URL खोलने के लिए OS सिस्टम कॉल करने परhref काम करता है, एक एंकर तत्व के रूप में पार्स करता है, कॉल करते समय काम करता window.open(url)है, उस चीज़ की ओर इशारा करता है जो वास्तव में मौजूद है, ब्राउज़र स्थान में काम करता है बार, या उपरोक्त का एक संयोजन? आपको बहुत अलग-अलग उत्तर मिलेंगे, जिनके आधार पर आप इसकी परवाह करेंगे।
— रॉय टिंकर

जवाबों:

188

एक उत्तर के साथ एक संबंधित प्रश्न:

जावास्क्रिप्ट regex URL मिलान

या देवशेद की ओर से यह प्रतिलेख :

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);
}
— टॉम गुलेन
स्रोत
1
मुझे पता है लेकिन मैं अपने बुकमार्क में खोज कर रहा हूं और उनमें से ज्यादातर स्टैकओवरफ़्लो (बिना .com, आदि) के लिखे गए हैं
— ब्रूनो
3
@Bruno: यह बहुत संभावना है कि वे आंतरिक रूप से अलग शीर्षक और URL के साथ सहेजे जाते है, जैसे { title: "Stackoverflow", uri: "http://stackoverflow.com" } अद्यतन: वास्तव में, देखने के code.google.com/chrome/extensions/bookmarks.html
— मार्सेल Korpel
10
अपने उदाहरण का उपयोग करने की कोशिश कर रहा है। लेकिन मुझे फायरबग पर एक त्रुटि मिल रही है जो कह रही है invalid quantifier। कोई उपाय?
— सिसिर
125
फ़ंक्शन रिटर्न: SyntaxError: Invalid regular expression: /^(https?://)?((([a-zd]([a-zd-]*[a-zd])*).)+[a-z]{2,}|((d{1,3}.){3}d{1,3}))(:d+)?(/[-a-zd%_.~+]*)*(?[;&a-zd%_.~+=-]*)?(#[-a-zd_]*)?$/: Invalid group Google Chrome (संस्करण 30.0.1599.101) (मैक ओएस एक्स:
— 10.8.5
10
इस बात से अवगत रहें कि यदि आप एक स्ट्रिंग का उपयोग एक पैरामीटर के रूप में करते RegExpहैं तो आपको बैकस्लैश से दो बार बचना होगा - अन्यथा आपको अमान्य समूह जैसी त्रुटियां मिलती हैं ।
— काजल
165 
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);
}
— Zemljoradnik
स्रोत
13
Google खोज छवि लिंक के लिए विफल: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
— बिल davis
7
यह अनुपयोगी धीमा है
— हर्नान ईचे
3
@ HernánEche क्या आप धीमी गति से मतलब है ? start = new Date(); isURL("http://michalstefanow.com"); end = new Date(); diff = end - start; console.log(diff)मैंने एक केतली डाल दी, एक शौचालय में गया, मेरी माँ को बुलाया और कुछ ही समय में बात हो गई ...
— मंगल
62
इसके लिए लौटता trueहै aaa।
— एलेक्स नौमोव
1
यह बिल्कुल सही उत्तर नहीं होना चाहिए। यह कई परीक्षण मामलों को विफल करता है और इससे भी महत्वपूर्ण बात यह है कि यह आपके पृष्ठ को एक छोटी स्ट्रिंग पर भी लटका देता है: isURL('12345678901234567890123')कुछ और वर्ण जोड़ें और यह और भी बदतर है।
— Aamarks
142

आप URLकंस्ट्रक्टर का उपयोग करने का प्रयास कर सकते हैं : यदि यह फेंकता नहीं है, तो स्ट्रिंग एक मान्य URL है:

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

  return true;
}

'URL' शब्द RFC 3886 में परिभाषित किया गया है (URI के रूप में) ; यह एक स्कीम के नाम से शुरू होना चाहिए, और स्कीम का नाम http / https तक सीमित नहीं है।

उल्लेखनीय उदाहरण:

  • www.google.com मान्य URL नहीं है (लापता योजना)
  • javascript:void(0) मान्य URL है, हालांकि HTTP एक नहीं है
  • http://..होस्ट होने के साथ मान्य URL है.. ; क्या यह हल करता है यह आपके DNS पर निर्भर करता है
  • https://google..com मान्य URL है, ऊपर जैसा है

यदि आप जांचना चाहते हैं कि क्या स्ट्रिंग एक वैध HTTP URL है:

function isValidHttpUrl(string) {
  let url;

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

  return url.protocol === "http:" || url.protocol === "https:";
}
— पाव्लो
स्रोत
13
@AshD नहीं, यह नहीं है; उदाहरण के लिए आप hrefविशेषता के रूप में उपयोग नहीं कर सकते हैं <a>। मान्य URL को योजना नाम से शुरू करना चाहिए , जैसे https://।
— पावलो
3
नया URL ('जावास्क्रिप्ट: अलर्ट (23)')
— ब्लेड 0691
6
@ इस बात को सच isValidUrl("javascript:void(0)")
— मानिए
3
मुझे js के बारे में नई बातें सिखाने के लिए यह पसंद है! यह कोई गलत नकारात्मक नहीं है जो मुझे मिल सके। इसमें कुछ झूठी सकारात्मकताएँ हैं: http://..याhttp:///a
— aamarks
2
URL एज से काम करना शुरू कर रहा है, इसलिए नीचे दी गई हर चीज आपके अपेक्षा के अनुरूप काम नहीं कर सकती है। सुनिश्चित करें कि आप पहले संगतता की जांच करते हैं।
— टोनी टी।
97

एक नियमित अभिव्यक्ति का उपयोग करने के बजाय, मैं एक लंगर तत्व का उपयोग करने की सलाह दूंगा।

जब आप hrefएक की संपत्ति सेट करते हैं anchor, तो विभिन्न अन्य गुण सेट होते हैं।

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"

स्रोत

हालांकि, अगर मूल्य href लिए बाध्य है, एक वैध यूआरएल नहीं है, तो उन सहायक गुणों का मूल्य खाली स्ट्रिंग होगा।

संपादित करें: जैसा कि टिप्पणियों में बताया गया है: यदि एक अवैध यूआरएल का उपयोग किया जाता है, तो वर्तमान URL के गुणों को प्रतिस्थापित किया जा सकता है।

इसलिए, जब तक आप वर्तमान पृष्ठ के URL में नहीं जा रहे हैं, आप कुछ ऐसा कर सकते हैं:

function isValidURL(str) {
   var a  = document.createElement('a');
   a.href = str;
   return (a.host && a.host != window.location.host);
}
— ल्यूक
स्रोत
3
यह मामला नहीं है (क्रोम 48 में कम से कम)। यदि url a.hrefको अमान्य कर दिया गया है, तो parser.hostउस पृष्ठ का होस्टनाम लौटाएं जो आप वर्तमान में हैं, अपेक्षित नहीं है false।
— सैम बेकहम
2
गाह! वह अजीब है। मैं कसम खाता हूँ मैं यह परीक्षण! मुझे लगता है कि यह कहना उचित है कि इस अभ्यस्त को वर्तमान पृष्ठ पर कभी भी उपयोग नहीं करना है, इसलिए सशर्त बस बदला जा सकता है। मैं पोस्ट को संपादित करूँगा।
— ल्यूक
यह एक बहुत विशिष्ट उपयोग का मामला नहीं है, लेकिन यह तकनीक फ़ायरफ़ॉक्स ब्राउज़र विंडो (एडऑन डेवलपमेंट के लिए महत्वपूर्ण) के संदर्भ में काम नहीं करती है
— chrmod
@SamBeckham इस पद्धति का उपयोग करते समय यह निश्चित रूप से एक चिंता का विषय है, लेकिन मैं केवल यह बताना चाहता हूं कि यह एक विशेष व्यवहार नहीं है। आपको लगता है कि अवैध है अपने पृष्ठ पर एक लिंक है, तो तरह <a href="invalidurl">है, यह है आपके डोमेन में जाते हैं। यह वर्तमान url के अंत में जुड़ जाता है। इसलिए क्रोम आपको "पार्सर" तत्व से वर्तमान होस्टनाम देकर सही काम कर रहा है।
— 18
4
function isValidURL(str): regex का उपयोग करने से बहुत बेहतर है! धन्यवाद!
— रोड्रिगो
47

मैं URL के साथ या उसके बिना मान्य करने के लिए नीचे फ़ंक्शन का उपयोग कर रहा हूं 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
स्निपेट का विस्तार करें

— विकासदीप सिंह
स्रोत
2
एक अच्छा समाधान लगता है! क्या आप कुछ कोने के मामलों में यह दिखाते हुए कुछ परीक्षण जोड़ सकते हैं (उदाहरण के लिए इन टिप्पणियों को देखें )?
— बसज
@ बस्ज ने परीक्षण मामलों को जोड़ा। कृपया जाँच करें
— विकासदीप सिंह
बुरा नहीं है, http: //⌘.ws या 142.42.1.1 पास करने में विफल रहता है और यह http: //.www.foo.bar./ की अनुमति देता है, लेकिन यह शीर्ष रेटेड उत्तरों सहित कुछ अन्य रेगेक्स की तरह लटका नहीं है।
— 15
@aamarks मैंने आपका उत्तर चेक किया। आपका जवाब https://sdfasdp.pppppppppppयानी वापसी के लिए असफल हो रहा है, trueलेकिन मेरा रिटर्न falseमुझे उम्मीद है कि मुझे लगता है।
— विकासदीप सिंह
4
इसके लिए सही वापसी sadf@gmail.com... यह होना चाहिए? मुझे लगता है कि यह नहीं होना चाहिए
— ज़ोहैब अली
35

जावास्क्रिप्ट का उपयोग करने के लिए यूआरएल को मान्य करने के लिए नीचे दिखाया गया है

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;
  }
}
— कविता रेड्डी
स्रोत
3
रेगेक्स के कई हिस्सों को काफी हद तक कम किया जा सकता है: ए) (http|https)से (?:https?); बी) :{0,1}से :?; ग) [0-9]से\d
— दिमित्री परज़ित्स्की
28

एक पुस्तकालय पर भरोसा करें : https://www.npmjs.com/package/valid-url

import { isWebUri } from 'valid-url';
// ...
if (!isWebUri(url)) {
    return "Not a valid url.";
}
— माइकल बुश
स्रोत
यह मुझे अजीब यूआरएल के साथ बहुत परेशानी देता है जो वास्तव में ब्राउज़र द्वारा पार्स किए जाते हैं, जैसे: {यूआरएल में एक
— विलीफ्रॉग
23

स्वीकार किए गए उत्तर पर सुधार ...

  • प्रोटोकॉल के रूप में ftp / ftps की जाँच करें
  • बैकस्लैश (\\) के लिए डबल भागने है
  • यह सुनिश्चित करता है कि डोमेन में एक डॉट और एक एक्सटेंशन है (.com .io .xyz)
  • पूर्ण बृहदान्त्र (:) पथ में अनुमति देता है http://thingiverse.com/download:1894343
  • एम्परसैंड (&) को पथ में अनुमति देता है जैसे http://en.wikipedia.org/wiki/Procter_&_Gamble

  • पथ में @ प्रतीक की अनुमति देता है जैसे 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);
}
— मिव्राबुआ टिम
स्रोत
5
नहीं, यह स्वीकृत उत्तर नहीं होना चाहिए। दूसरों में से कुछ की तरह यह केवल 33 चरित्र स्ट्रिंग पर लटका रहता है: isurL ('123456789014545898923236767890123') और कई एज केस परीक्षणों में विफल रहता है: foo.com/blah_blah_(ikikipedia)_(again ) // गलत तरीके से गलत रिटर्न।
— aamarks
2
ऐसा इसलिए है क्योंकि लोकलहोस्ट: 8080 वैध URL नहीं है।
— शेन
1
काम का नमूना: runkit.com/shanekenyon87/5bc0e57263c77b0012db05dc
— शेन
— फीट
यह काम करने के लिए प्रतीत नहीं होता है: लंबे इनपुट पर लटका हुआ (जैसे @ आंसर ने कहा)
— छंदमेल
13

यहाँ एक और तरीका है।

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'));
स्निपेट का विस्तार करें

— रयान ब्राइस
स्रोत
शैक्षिक कोड! यहां का तंत्र संभवतः new URL(string)पावलो के कोड के काम करने के तरीके के समान है । दोनों परीक्षणों में मेरे द्वारा परीक्षण किए गए सभी किनारे मामलों के समान परिणाम हैं। मुझे उसका कोड पसंद है क्योंकि यह सरल है और इसमें तत्वों का निर्माण शामिल नहीं है, लेकिन आपका कुछ गुना तेज है (शायद इसलिए कि यह पहले इस्तेमाल के बाद एल पैदा नहीं करता है)।
— 18:05
1
धन्यवाद! मैंने आपकी सलाह पर अमल किया। हालाँकि जागरूक रहें: पुराने ब्राउज़र और / या मोबाइल डिवाइस WebView ने शायद <input type = url> एलिमेंट को लागू नहीं किया है; इस प्रकार इनपुट मूल्य को एक नियमित पाठ (कोई URL सत्यापन) की तरह ही माना जाएगा। REF: developer.mozilla.org/en-US/docs/Web/HTML/Element/input/url
— पाणिनी लंचर
10

(मेरे पास ValidURL उदाहरण पर टिप्पणी करने के लिए प्रतिनिधि नहीं है ; इसलिए इसे उत्तर के रूप में पोस्ट करें।)

जबकि प्रोटोकॉल सापेक्ष URL का उपयोग प्रोत्साहित नहीं किया जाता है ( प्रोटोकॉल-सापेक्ष URL ), वे कभी-कभी नियोजित होते हैं। ऐसे URL को नियमित अभिव्यक्ति के साथ मान्य करने के लिए प्रोटोकॉल भाग वैकल्पिक हो सकता है, जैसे:

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

जैसा कि अन्य ने उल्लेख किया है, नियमित अभिव्यक्ति URL को मान्य करने के लिए सबसे अच्छा अनुकूल तरीका नहीं लगता है।

— को ला
स्रोत
मैंने सोचा था कि यह बहुत अच्छा था, लेकिन यह mathiasbynens.be/demo/url-regex पर कई परीक्षणों में विफल रहता है , और फिर यह लटका हुआ हैisValidURL("https://d1f4470da51b49289906b3d6cbd65074@app.getsentry.com/13176")
— aamarks
हां, जैसा मैंने कहा, मैंने केवल प्रोटोकॉल भाग पर टिप्पणी की है। मैंने हैंडल करने के लिए प्रमाणीकरण खंड जोड़ा @। यह मेरे ब्राउज़रों में लटका नहीं है ।
— को ला ला
क्षमा करें, मैं इनका मूल्यांकन करने के लिए इनमें से कई के माध्यम से जा रहा था और यह याद किया कि आपका दिए गए उत्तर पर टिप्पणी कर रहा था। मुझे लगता है कि जब मैंने पहली बार इस पृष्ठ का दौरा किया था, तो मुझे सुधारने में मदद मिली थी। अब फांसी नहीं।
— Aamarks
9

आप URL देशी API का उपयोग कर सकते हैं :

  const isUrl = string => {
      try { return Boolean(new URL(string)); }
      catch(e){ return false; }
  }
— अरल रोका
स्रोत
3
@ पावलो द्वारा प्रदान किए गए उत्तर के समान ही दिखता है, केवल परिवर्तनशील नाम बदल गए हैं;)
— मुनीम मुन्ना
2
अब तक इसके लिए जाँच करने के लिए वास्तव में एक सरल देशी तरीका होना चाहिए - यह उत्तर बहुत ही आशाजनक लग रहा था, लेकिन यह जल्दी ही सही है जैसा कि ऊपर उल्लिखित @Basar।
— जीरो_कोल
8

जैसा कि उल्लेख किया गया है कि पूर्ण रेगेक्स मायावी है, लेकिन फिर भी एक उचित दृष्टिकोण प्रतीत होता है (विकल्प सर्वर साइड टेस्ट या नए प्रयोगात्मक URL API हैं )। हालाँकि उच्च रैंकिंग उत्तर अक्सर आम यूआरएल के लिए झूठे होते हैं लेकिन इससे भी बदतर आपके ऐप / पेज को मिनटों के लिए सरल स्ट्रिंग के रूप में फ्रीज कर देगा isURL('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')। यह कुछ टिप्पणियों में बताया गया है, लेकिन अधिकांश ने शायद इसे देखने के लिए एक खराब मूल्य दर्ज नहीं किया है। उस तरह से लटकाए जाने से वह कोड किसी भी गंभीर एप्लिकेशन में अनुपयोगी हो जाता है। मुझे लगता है कि यह कोड में बार-बार केस असंवेदनशील सेट के कारण है ((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|' ...। 'मैं' को बाहर निकालो और यह लटका नहीं है, लेकिन निश्चित रूप से वांछित के रूप में काम नहीं करेगा। लेकिन यहां तक ​​कि अनदेखी के मामले में उन परीक्षणों के झंडे के साथ उच्च यूनिकोड मानों को अस्वीकार कर दिया जाता है जिनकी अनुमति है।

पहले से ही सबसे अच्छा उल्लेख किया गया है:

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

यह Github सेगमेंटियो / is-url से आता है । एक कोड रिपॉजिटरी के बारे में अच्छी बात यह है कि आप परीक्षण और किसी भी मुद्दे को देख सकते हैं और इसके माध्यम से परीक्षण स्ट्रिंग भी चला सकते हैं। एक शाखा है जो स्ट्रिंग को लापता प्रोटोकॉल की अनुमति देती है google.com, हालांकि आप शायद बहुत अधिक धारणा बना रहे हैं। रिपॉजिटरी को अपडेट कर दिया गया है और मैं यहां दर्पण रखने की कोशिश पर योजना नहीं बना रहा हूं। RegEx redos से बचने के लिए इसे अलग-अलग परीक्षणों में तोड़ दिया गया है, जिसका उपयोग DOS हमलों के लिए किया जा सकता है (मुझे नहीं लगता कि आपको क्लाइंट साइड js के साथ इस बारे में चिंता करनी होगी, लेकिन आपको अपने पेज के बारे में इतनी देर तक लटकने की चिंता है कि आपकी आगंतुक आपकी साइट को छोड़ता है)।

एक अन्य रिपॉजिटरी है जिसे मैंने देखा है कि यह dperini / regex-weburl.js पर isurL के लिए बेहतर हो सकता है , लेकिन यह अत्यधिक जटिल है। इसमें मान्य और अमान्य URL की एक बड़ी परीक्षण सूची है। ऊपर वाला सरल अभी भी सभी सकारात्मकता को पार करता है और केवल कुछ अजीब नकारात्मक और http://a.b--c.de/साथ ही विशेष ips को अवरुद्ध करने में विफल रहता है ।

जो भी आप चुनते हैं, उसे इस फ़ंक्शन के माध्यम से चलाएं, जिसे मैंने अपने ब्राउज़र के डेवलपर टूल इनपेक्टर का उपयोग करते हुए dperini / regex-weburl.js पर परीक्षणों से अनुकूलित किया है।

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

और फिर 'ए' के ​​उस तार का परीक्षण करें।

इससे पहले कि आप एक बहुत बढ़िया रेगेक्स पोस्ट करें, और अधिक जानकारी के लिए Mathias Bynens द्वारा isurL regex की यह तुलना देखें ।

— aamarks
स्रोत
मैंने आपका उत्तर जांचा। आपका उत्तर sdfasdp.ppppppppppp के लिए विफल हो रहा है अर्थात वापस लौट रहा है, लेकिन उम्मीद झूठी है
— विकासदीप सिंह
1
मुझे लगता है कि यह एक मान्य URL है, संरचनात्मक रूप से। मानक के विशेषज्ञ नहीं, लेकिन मुझे नहीं लगता कि .com भाग की लंबाई पर कोई सीमा है (मुझे पता है कि .online वैध है)
— aamarks
1
मुझे बमुश्किल पता था कि कुछ महीने पहले रेगेक्स कैसे लिखा जाता है। समस्या गंभीर है। मेरे द्वारा उद्धृत रेगेक्स के दोनों isURL('a'.repeat(100))लाखों बार / सेकंड को पूरा कर सकते हैं (डपरिनि से अधिक जटिल वास्तव में तेज है)। फॉर्म के कुछ उच्च रैंकिंग उत्तर ([a-zA-Z] +) * को एक बार पूरा करने में घंटों लगेंगे। अधिक जानकारी के लिए RegEx redos देखें।
— Aamarks
6

मैं उस पोस्ट पर टिप्पणी नहीं कर सकता जो सबसे नज़दीकी # 5717133 है , लेकिन नीचे मैंने बताया है कि कैसे @ टॉम-गुलेन रेगेक्स काम कर रहा है।

/^(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
— iamnewton
स्रोत
2
यह मेरे लिए काम करता है लेकिन मुझे बैकस्लैश को बैकस्लैश करने की जरूरत है। var pattern = new 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');
— फर्नांडो शावेज हरेरा
अधिक परीक्षण के मामलों के लिए w3resource.com/javascript-exercises/… की जाँच करें
— केवल शाह
5

Validator.js का उपयोग करें

ES6

import isURL from 'validator/lib/isURL'

isURL(string)

कोई ईएस 6 नहीं

var validator = require('validator');

validator.isURL(string)

आप वैकल्पिक फ़ंक्शन optionsको दूसरे तर्क के रूप में पारित करके इस फ़ंक्शन के व्यवहार को भी ठीक कर सकते हैंisURL

यहाँ डिफ़ॉल्ट optionsवस्तु है:

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_whitelistऔर host_blacklistमेजबानों के सरणियों हो सकता है। वे नियमित अभिव्यक्ति का भी समर्थन करते हैं।

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
— इलिच
स्रोत
1
अच्छा! छोटी लाइब्रेरी (40k से कम की न्यूनतम), लोकप्रिय लाइब्रेरी (npm पर 3M साप्ताहिक डाउनलोड), आपको अपने विशेष उपयोग के मामले के लिए URL की वैधता को निर्दिष्ट करने पर बहुत अधिक लचीलापन देता है, और URL के अलावा कई अन्य सत्यापनकर्ता भी हैं। यह अब तक का सबसे अच्छा जवाब है, IMHO।
— जावीद जमा २
4

URL "स्ट्रिंग" को मान्य करने के लिए मैं एक फ़ंक्शन का उपयोग कर रहा हूं:

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

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

यह फ़ंक्शन बूलियन लौटाएगा कि क्या स्ट्रिंग एक URL है।

उदाहरण:

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
— क्रिस
स्रोत
4

यह शुद्ध रेगेक्स के साथ करना काफी मुश्किल है क्योंकि URL में कई 'असुविधाएँ' हैं।

  1. उदाहरण के लिए डोमेन नाम में हाइफ़न पर जटिल प्रतिबंध हैं:

    ए। इसे बीच में लगातार कई हाइफ़न रखने की अनुमति है।

    ख। लेकिन डोमेन नाम का पहला चरित्र और अंतिम चरित्र एक हाइफ़न नहीं हो सकता है

    सी। तृतीय और चतुर्थ वर्ण दोनों हाइफ़न नहीं हो सकते

  2. इसी तरह पोर्ट नंबर केवल 1-65535 की रेंज में हो सकता है। यह जांचना आसान है कि क्या आप पोर्ट वाले हिस्से को निकालते हैं और intएक रेगुलर एक्सप्रेशन के साथ चेक करना काफी मुश्किल है।

  3. मान्य डोमेन एक्सटेंशन की जांच करने का कोई आसान तरीका भी नहीं है। कुछ देशों में दूसरे स्तर के डोमेन होते हैं (जैसे कि 'co.uk'), या विस्तार एक लंबा शब्द हो सकता है जैसे कि '.internant'। और नए TLD को नियमित रूप से जोड़ा जाता है। इस प्रकार की चीजों को केवल हार्ड-कोडित सूची के खिलाफ जांचा जा सकता है। (देखें https://en.wikipedia.org/wiki/Top-level_domain )

  4. फिर चुंबक उरोज, एफटीपी पते आदि हैं। इन सभी की अलग-अलग आवश्यकताएं हैं।

फिर भी, यहाँ एक ऐसा फंक्शन है जिसे छोड़कर बाकी सब कुछ बहुत ही महत्वपूर्ण है:

  • केस 1. सी
  • किसी भी 1-5 अंकों की पोर्ट संख्या को स्वीकार करता है
  • किसी भी विस्तार को स्वीकार करता है 2-13 वर्ण
  • एफ़टीपी, चुंबक, आदि को स्वीकार नहीं करता ...

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] + ']');
}
स्निपेट का विस्तार करें

— Caner
स्रोत
1

मुझे लगता है कि मूल URL API का उपयोग करना जटिल रेपेक्स पैटर्न से बेहतर है जैसा कि @pavlo ने सुझाव दिया है। इसकी कुछ कमियां हैं, जिन्हें हम कुछ अतिरिक्त कोड द्वारा ठीक कर सकते हैं। निम्न मान्य url के लिए यह दृष्टिकोण विफल रहता है।

//cdn.google.com/script.js

इससे बचने के लिए हम पहले से लापता प्रोटोकॉल जोड़ सकते हैं। यह अमान्य url के बाद भी पता लगाने में विफल रहता है।

http://w
http://..

तो पूरे url की जाँच क्यों करें? हम सिर्फ डोमेन की जांच कर सकते हैं। मैंने यहाँ से डोमेन को सत्यापित करने के लिए regex उधार लिया था ।

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

इसके लिए hostnameविशेषता खाली स्ट्रिंग है javascript:void(0), इसलिए यह उसके लिए भी काम करता है, और आप आईपी एड्रेस वेरिफ़ायर भी जोड़ सकते हैं। मैं देशी एपीआई के सबसे से चिपकना चाहता हूं, और आशा करता हूं कि यह निकट भविष्य में सब कुछ का समर्थन करना शुरू कर देगा।

— मुनीम मुन्ना
स्रोत
दिलचस्प है, लेकिन अभी भी regex पर काम करने की आवश्यकता हो सकती है क्योंकि यह अब झूठे नकारात्मक पेश किया new URLहै जो मेरे द्वारा किए गए परीक्षणों में नहीं है। यह कॉलिंग है: http://142.42.1.1 //falseऔर उच्च यूनिकोड स्ट्रिंग्स को अवरुद्ध करना।
— आमेर
1

सवाल एक यूआरएल के लिए एक सत्यापन विधि पूछता है stackoverflow, जैसे कि प्रोटोकॉल में या होस्टनाम में किसी भी बिंदु के बिना। तो, यह url sintax को मान्य करने की बात नहीं है, लेकिन यदि यह एक मान्य url है, तो वास्तव में इसे कॉल करके जाँच कर रहा है।

मैंने यह जानने के लिए कई तरीके आज़माए कि क्या url सच मौजूद है और ब्राउज़र के भीतर से कॉल करने योग्य है, लेकिन जावास्क्रिप्ट के साथ कॉल करने के लिए प्रतिक्रिया के हेडर का परीक्षण करने का कोई तरीका नहीं मिला:

  • एंकर तत्व जोड़ना click()विधि को फायर करने के लिए ठीक है ।
  • चुनौतीपूर्ण url के साथ ajax कॉल करना 'GET'ठीक है, लेकिन क्या CORSनीतियों के कारण इसकी विभिन्न सीमाएँ हैं और यह उपयोग करने का मामला नहीं है ajax, क्योंकि url शायद मेरे सर्वर के डोमेन के बाहर है।
  • भ्रूण एपीआई का उपयोग करने से अजाक्स के समान वर्कअराउंड होता है।
  • अन्य समस्या यह है कि मेरे पास httpsप्रोटोकॉल के तहत मेरा सर्वर है और गैर-सुरक्षित यूआरएल कॉल करते समय एक अपवाद फेंकता है।

तो, सबसे अच्छा समाधान जो मैं सोच सकता हूं कि कुछ CURLऐसा प्रयास करके जावास्क्रिप्ट का उपयोग करने के लिए कुछ उपकरण प्राप्त करना है curl -I <url>। दुर्भाग्य से मुझे कोई नहीं मिला और आशंका में यह संभव नहीं है। मैं इस पर किसी भी टिप्पणी की सराहना करूंगा।

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

' https://daniserver.com.ar/stackoverflowस्टैकओवरफ़्लो ' प्रश्न पर एकल शब्द url के बारे में, यह मुझे आगे ले जाएगा , जहाँ daniserver.com.ar मेरा अपना डोमेन है।

— डैनियल फॉरे
स्रोत
ओपी को शायद इस बात का संकेत देना चाहिए था कि उसकी मंशा क्या थी। समस्या निश्चित रूप से आपकी आवश्यकताओं पर निर्भर करती है और चाहे झूठी सकारात्मक को बाहर करना या झूठे नकारात्मक को शामिल करना अधिक महत्वपूर्ण है। जैसा कि कहा गया है कि समस्या का कोई उत्तर नहीं है। क्या आप वास्तव में fooइसे http या https या .com या .es या अनगिनत प्रत्ययों में ले सकते हैं और मान सकते हैं? क्या आप रसोई सिंक को तब तक फेंकते रहते हैं जब तक आप एक सच्चे नहीं हो जाते?
— Aamarks
1

यह सीएस में सबसे कठिन समस्याओं में से एक लगता है;)

यहां एक और अधूरा समाधान है जो मेरे लिए काफी अच्छा काम करता है और जो मैंने यहां देखा है उससे बेहतर है। IE11 का समर्थन करने के लिए मैं इसके लिए एक इनपुट [type = url] का उपयोग कर रहा हूं, अन्यथा इसके बजाय सत्यापन करने के लिए window.URL का उपयोग करना अधिक सरल होगा:

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.mydomain.com" जैसे अधूरे इनपुट्स को स्वीकार करने के लिए, यह मान्य होगा कि उन मामलों में प्रोटोकॉल "http" है और यदि पता वैध है तो वैध URL लौटाएं। अमान्य होने पर यह झूठी हो जाती है।

यह IPv4 डोमेन को भी सपोर्ट करता है, लेकिन IPv6 को नहीं।

— Rosenfeld
स्रोत
1

मेरे मामले में मेरी एकमात्र आवश्यकता यह है कि उपयोगकर्ता इनपुट को किसी टैग के हाइपर में रखे जाने पर एक रिश्तेदार लिंक के रूप में व्याख्या नहीं की जाएगी और यहां उत्तर या तो इसके लिए थोड़ा OTT थे या अनुमत URL मेरी आवश्यकताओं को पूरा नहीं कर रहे थे, इसलिए यह मैं इसके साथ जा रहा हूँ:

^https?://.+$

एक ही बात regex के बिना बहुत आसानी से हासिल किया जा सकता है।

— rdans
स्रोत
1

यह मेरे साथ काम कर रहा है

function isURL(str) {
  var regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
  var pattern = new RegExp(regex); 
return pattern.test(str);
}
— HeshamSalama
स्रोत
1
यह जवाब कविता रेड्डी ने 4 साल पहले ही दे दिया था।
— aamarks
मैंने इसे और अधिक सरल और सार बना दिया
— HeshamSalama
1

यदि आप इनपुट प्रकार बदल सकते हैं, तो मुझे लगता है कि यह समाधान बहुत आसान होगा:

आप type="url"अपने इनपुट में सरल उपयोग कर सकते हैं और इसे checkValidity()js में देख सकते हैं

उदाहरण के लिए:

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
    }
});
— डैनियल रॉड्रिग्ज़
स्रोत
1

यह रक्षात्मक रूप से सबसे प्रभावी दृष्टिकोण नहीं है, लेकिन जो भी आपको आवश्यक है, उसे पढ़ना और पढ़ना आसान है। और यहाँ से regex / जटिलता जोड़ना आसान है। तो यहाँ एक बहुत ही व्यावहारिक दृष्टिकोण है

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

परीक्षा:

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

मैथियास ब्येनेंस ने प्रसिद्ध URL रीगेक्स की एक सूची तैयार की है परीक्षण यूआरएल के साथ । एक नई नियमित अभिव्यक्ति लिखने का कोई कारण नहीं है; बस एक मौजूदा एक चुनें जो आपको सबसे अच्छा लगे।

लेकिन उन रेगीक्स के लिए तुलना तालिका यह भी बताती है कि एकल नियमित अभिव्यक्ति के साथ URL सत्यापन करना असंभव है। Bynens की सूची में सभी regexes झूठी सकारात्मक और गलत नकारात्मक उत्पन्न करते हैं।

मेरा सुझाव है कि आप एक मौजूदा URL पार्सर (उदाहरण के लिए new URL('http://www.example.com/')जावास्क्रिप्ट में) का उपयोग करें और फिर उन चेक को लागू करें जिन्हें आप URL के सम्मान के पार्स और सामान्यीकृत रूप के खिलाफ प्रदर्शन करना चाहते हैं। इसके घटक हैं। जावास्क्रिप्ट URLइंटरफ़ेस का उपयोग करने का अतिरिक्त लाभ है कि यह केवल ऐसे URL को स्वीकार करेगा जो वास्तव में ब्राउज़र द्वारा स्वीकार किए जाते हैं।

आपको यह भी ध्यान रखना चाहिए कि तकनीकी रूप से गलत URL अभी भी काम कर सकते हैं। उदाहरण के लिए http://w_w_w.example.com/, http://www..example.com/, http://123.example.com/सब गलत होस्ट नाम हिस्सा है, लेकिन हर ब्राउज़र मैं जानता हूँ कि शिकायतों के बिना उन्हें खोलने की कोशिश करेंगे, और आप में उन लोगों के अवैध नामों के लिए आई पी पते प्रदान जब/etc/hosts/ जैसे URL भी काम करेगा, लेकिन केवल अपने कंप्यूटर पर।

इसलिए सवाल यह है कि एक यूआरएल वैध है या नहीं, बल्कि यह कि कौन से URL काम करते हैं और उन्हें किसी विशेष संदर्भ में अनुमति दी जानी चाहिए।

यदि आप URL सत्यापन करना चाहते हैं तो बहुत सारे विवरण और किनारे मामले हैं जिन्हें अनदेखा करना आसान है:

  • URL में क्रेडेंशियल शामिल हो सकते हैं http://user:password@www.example.com/ ।
  • पोर्ट संख्या 0-65535 की सीमा में होनी चाहिए, लेकिन आप अभी भी वाइल्डकार्ड पोर्ट 0 को बाहर करना चाह सकते हैं।
  • पोर्ट संख्याओं में http://www.example.com:000080/ के रूप में अग्रणी शून्य हो सकते हैं ।
  • IPv4 पते 0-255 की सीमा में 4 दशमलव पूर्णांक तक सीमित नहीं हैं। आप एक से चार पूर्णांक का उपयोग कर सकते हैं, और वे दशमलव, अष्टक या षोडश आधारी हो सकते हैं। URLs https: //010.010.000010.010/ , https: //0x8.0x8.0x0008.0x8/ , https: //8.8.2056/ , https: //8.526344/ , https: 134744072 / सभी मान्य हैं और लिखने का सिर्फ रचनात्मक तरीका https://8.8.8.8/ ।
  • लूपबैक पते ( http://127.0.0.1/ ), निजी आईपी पते ( http://192.168.1.1 ), लिंक-स्थानीय स्क्रिप्ट ( http://169.254.100.200 ) और इसी तरह सुरक्षा पर प्रभाव पड़ सकता है गोपनीयता। यदि, उदाहरण के लिए, आप उन्हें एक मंच में उपयोगकर्ता अवतारों के पते के रूप में अनुमति देते हैं, तो आप उपयोगकर्ताओं के ब्राउज़रों को उनके स्थानीय नेटवर्क में अवांछित नेटवर्क अनुरोध भेजने के लिए और चीजों के इंटरनेट में इस तरह के अनुरोध मजाकिया हो सकते हैं और इतनी हास्यास्पद चीजें नहीं हैं। आपके घर में
  • समान कारणों से, आप बिना किसी बिंदु के होस्टनाम में दूसरे शब्दों में, पूरी तरह से योग्य होस्टनामों के लिंक को नहीं छोड़ना चाह सकते हैं।
  • लेकिन होस्टनाम में हमेशा एक अनुगामी बिंदु (जैसे में) हो सकता है http://www.stackoverflow.com. ) हो सकता है।
  • किसी लिंक के होस्टनाम भाग में IPv6 पतों के लिए कोण कोष्ठक हो सकते हैं जैसे http: // [:: 1] ।
  • IPv6 पतों में निजी नेटवर्क या लिंक-लोकल एड्रेस आदि भी हैं।
  • यदि आप कुछ IPv4 पतों को ब्लॉक करते हैं, तो ध्यान रखें कि उदाहरण के लिए https://127.0.0.1 और https: // [:: ffff: 127.0.0.1] समान संसाधन को इंगित करें (यदि आपकी मशीन का लूपबैक डिवाइस IPv6 तैयार है )।
  • URL के होस्टनाम भाग में अब यूनिकोड हो सकता है, ताकि चरित्र श्रेणी [-0-9a-zA-z] निश्चित रूप से पर्याप्त नहीं रह जाती है।
  • शीर्ष-स्तरीय डोमेन के लिए कई रजिस्ट्रियां विशिष्ट प्रतिबंधों को परिभाषित करती हैं, उदाहरण के लिए यूनिकोड वर्णों के अनुमत सेट पर। या वे अपने नामस्थान (जैसे co.ukऔर कई अन्य) को वश में कर लेते हैं ।
  • शीर्ष-स्तरीय डोमेन में दशमलव अंक नहीं होने चाहिए, और जब तक IDN A- लेबल उपसर्ग "xn--" के लिए हाइफ़न की अनुमति नहीं है।
  • यूनिकोड शीर्ष-स्तरीय डोमेन (और "xn--" के साथ उनके पंचकोश एन्कोडिंग) में अभी भी केवल अक्षर होना चाहिए लेकिन जो एक regex में जांचना चाहता है?

इन सीमाओं और नियमों में से कौन सा लागू होता है, यह परियोजना की आवश्यकताओं और स्वाद का सवाल है।

मैंने हाल ही में एक वेब ऐप के लिए एक URL सत्यापनकर्ता लिखा है जो मंचों, सामाजिक नेटवर्क, या उस तरह के उपयोगकर्ता-आपूर्ति वाले URL के लिए उपयुक्त है। अपने स्वयं के लिए एक आधार के रूप में इसका उपयोग करने के लिए स्वतंत्र महसूस करें:

मैंने अधिक गहराई से जानकारी के साथ एक ब्लॉग पोस्ट द जीरी विवरण ऑफ़ URL वैलिडेशन भी लिखा है ।

— गुइडो फ़्लहर
स्रोत
1

मैं फ़ंक्शन को स्लैश और उसके काम के साथ यहां मिलान + में परिवर्तन करता हूं: (http: // और 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;
}
— आशीष गुप्ता
स्रोत
0

यह सुनिश्चित करने के लिए कि एक वैध प्रोटोकॉल है, और डोमेन एक्सटेंशन दो या दो से अधिक वर्णों का होना चाहिए।

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

};
— माइकल Ecklund
स्रोत
0

यदि आपको भी समर्थन करने की आवश्यकता है https://localhost:3000तो [Devshed] s regex के इस संशोधित संस्करण का उपयोग करें।

    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);
    }
— मार्क हेथरिंगटन
स्रोत
0

URL कंस्ट्रक्टर का उपयोग करने वाले कुछ परीक्षण हैं जो इस बात को उजागर नहीं करते हैं कि इनपुट एक स्ट्रिंग या URL ऑब्जेक्ट है या नहीं।

// 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;  
    }
}
— greg.arnott
स्रोत
0

2020 अद्यतन। @Iamnewton और @Fernando Chavez Herrera से उत्कृष्ट उत्तर पर दोनों का विस्तार करने के लिए मैंने @URL के पथ में उपयोग किया जाना शुरू कर दिया है ।

तो अद्यतन regex है:

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

यदि आप इसे क्वेरी स्ट्रिंग और हैश में उपयोग करना चाहते हैं, तो उपयोग करें:

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

यह कहा जा रहा है, मुझे यकीन नहीं है कि अगर @क्वेरी स्ट्रिंग या हैश में व्हाइटपॉपर नियम है ।

— दोहरे चरित्र वाला
स्रोत
0

पहले से ही बहुत सारे उत्तर हैं, लेकिन यहां एक और योगदान है: सीधे URLपॉलीफिल वैधता जांच से लिया गया , ब्राउज़र की अंतर्निहित वैधता जांच का लाभ उठाने के लिए एक inputतत्व का उपयोग type="url"करें:

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

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

स्रोत

— ब्रूनो फिंगर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.