अगर URL मान्य है तो कैसे जांच करें

Question

यदि स्ट्रिंग एक वैध URL है तो मैं कैसे जांच सकता हूं?

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

http://hello.it => yes
http:||bra.ziz, => no

यदि यह एक मान्य URL है तो मैं कैसे जांच सकता हूं कि यह किसी छवि फ़ाइल के सापेक्ष है या नहीं?

Comments

आपके द्वारा प्रदान किया गया url एक पूर्ण url प्रतीत हो रहा है, एक छवि फ़ाइल के सापेक्ष आपका क्या मतलब है

— johannes

मैं चश्मे के साथ एक UriValidator पोस्ट किया ।

— JJD

Answer 1

URIरूबी के साथ वितरित मॉड्यूल का उपयोग करें :

require 'uri'

if url =~ URI::regexp
    # Correct URL
end

जैसे अलेक्जेंडर गुंथर ने टिप्पणियों में कहा, यह जांचता है कि क्या एक स्ट्रिंग में एक URL है।

यह जांचने के लिए स्ट्रिंग है एक यूआरएल, उपयोग करें:

url =~ /\A#{URI::regexp}\z/

यदि आप केवल वेब URL ( httpया https) की जांच करना चाहते हैं , तो इसका उपयोग करें:

url =~ /\A#{URI::regexp(['http', 'https'])}\z/

Comments

यह काम नहीं लगता है: 'http://:5984/asdf' =~ URI::regexp और 'http::5984/asdf' =~ URI::regexpदोनों वापस 0. मैं उन्हें शून्य वापस करने की उम्मीद करता हूं क्योंकि उनमें से कोई भी वैध यूआरआई नहीं है।

— awendt

नहीं है: 5984 पोर्ट 5984 लोकलहोस्ट पर?

— mxcl

यह वास्तव में जांचता है कि क्या एक चर में एक वैध यूआरएल है। यह एक मान्य URL के रूप में " उदाहरण com" को स्वीकार करेगा । क्योंकि इसमें एक शामिल है। लेकिन यह उपयोगी नहीं है यदि आप पूरी बात की उम्मीद करते हैं कि यह यूआरएल है।

— अलेक्जेंडर गुंथर

gotqn: यह RFC 1738 के अनुसार एक मान्य URL नहीं है।

— मिकेल एस

इसका उपयोग न करें, यह इतना बुरा है कि "http:"यह regexp गुजरता है।

— २३:५५ पर स्माइली

Answer 2

ऊपर दिए गए उत्तर के समान, मुझे लगता है कि इस रेगेक्स का उपयोग थोड़ा अधिक सटीक होगा:

URI::DEFAULT_PARSER.regexp[:ABS_URI]

वह URL को रिक्त स्थान के साथ अमान्य कर देगा, URI.regexpजिसका विरोध किसी कारण से रिक्त स्थान की अनुमति देता है।

मुझे हाल ही में एक शॉर्टकट मिला है जो विभिन्न यूआरआई rgexps के लिए प्रदान किया गया है। आप URI::DEFAULT_PARSER.regexp.keysसीधे किसी से भी एक्सेस कर सकते हैं URI::#{key}।

उदाहरण के लिए, :ABS_URIregexp से पहुँचा जा सकता है URI::ABS_URI।

Comments

यदि आप किसी भी बिंदु पर URI.parse का उपयोग करने की योजना बनाते हैं, तो यह निश्चित रूप से जाने का तरीका है। URI :: regexp कुछ URL से मेल खाता है जो बाद में URI.parse का उपयोग करते समय विफल हो जाएगा। पारितोषिक के लिए धन्यवाद।

— मार्कक्वेजडा

अफसोस की बात है, यह केवल रूबी 1.9 पर उपलब्ध है, 1.8 नहीं।

— स्टीव मैडसेन

लेकिन, यह काम करता है /^#{URI.regexp}$/:। मुसीबत यह है कि URI.regexpलंगर नहीं है। अंतरिक्ष के साथ एक स्ट्रिंग URI के हिस्से के रूप में अंतरिक्ष को मान्य नहीं कर रही है, लेकिन सब कुछ अंतरिक्ष में अग्रणी है। यदि वह टुकड़ा एक वैध यूआरआई की तरह दिखता है, तो मैच सफल होता है।

— स्टीव मैडसेन

अपने प्रस्तावों में अपेंडेंट की टिप्पणी लागू करना: 'http://:5984/asdf' =~ URI::DEFAULT_PARSER.regexp[:ABS_URI]0 देता है, शून्य नहीं; 'http::5984/asdf'=~ URI::DEFAULT_PARSER.regexp[:ABS_URI]0 देता है; 'http://:5984/asdf' =~ /^#{URI.regexp}$/0 देता है; 'http::5984/asdf' =~ /^#{URI.regexp}$/साथ ही 0 देता है। उपरोक्त रेगेक्स में से कोई भी पूरी तरह से सही नहीं है, हालांकि वे केवल बहुत ही विषम परिस्थितियों में विफल होते हैं और ज्यादातर मामलों में यह कोई बड़ी बात नहीं है।

— स्कैले

FYI करें,URI::DEFAULT_PARSER.regexp[:ABS_URI]/\A\s*#{URI::regexp}\s*\z/

— एड

Answer 3

वर्तमान उत्तरों के साथ समस्या यह है कि एक URI एक URL नहीं है ।

एक यूआरआई को एक लोकेटर, एक नाम या दोनों के रूप में वर्गीकृत किया जा सकता है। "यूनिफ़ॉर्म रिसोर्स लोकेटर" (URL) शब्द यूआरआई के सबसेट को संदर्भित करता है, जो एक संसाधन की पहचान करने के अलावा, इसके प्राथमिक एक्सेस तंत्र (जैसे, इसके नेटवर्क "स्थान") का वर्णन करके संसाधन का पता लगाने का एक साधन प्रदान करता है।

चूंकि URL URI का एक उपसमूह हैं, इसलिए यह स्पष्ट है कि URI के लिए विशेष रूप से मिलान सफलतापूर्वक अवांछित मानों से मेल खाएगा। उदाहरण के लिए, URNs :

 "urn:isbn:0451450523" =~ URI::regexp
 => 0 

कहा जा रहा है, जहां तक ​​मुझे पता है, रूबी के पास URL पार्स करने का कोई डिफ़ॉल्ट तरीका नहीं है, इसलिए आपको ऐसा करने के लिए एक रत्न की आवश्यकता होगी। यदि आपको विशेष रूप से HTTP या HTTPS प्रारूप में URL का मिलान करने की आवश्यकता है, तो आप ऐसा कुछ कर सकते हैं:

uri = URI.parse(my_possible_url)
if uri.kind_of?(URI::HTTP) or uri.kind_of?(URI::HTTPS)
  # do your stuff
end

Comments

@Philip मददगार और उचित दोनों था। आपका बहुत बहुत धन्यवाद!

— फॉटेनस

uri.kind_of?(URI::HTTP)दोनों मामलों (http और https) के लिए पर्याप्त लगता है, कम से कम रूबी 1.9.3 में।

— एंड्रिया सालिसेटी

अभी भी जोंट्स के जवाब के तहत @skalee द्वारा वर्णित मुद्दों से ग्रस्त है

— akostadinov

सारांश, URI.parse(string_to_be_checked).kind_of?(URI::HTTP)काम अच्छी तरह से करता है।

— बेन

इसके अतिरिक्त, हमारे डेटाबेस में एक बहुत ही सामान्य गलतफहमी से पता चलता है कि लोग कई तरह के झमेले डालते हैं: http:///neopets.comजो दुर्भाग्य से वैध भी है। होस्टनाम की उपस्थिति की जाँच करना इसे ठीक करता है:uri = URI(str) ; %w[http https].include?(uri.scheme) && !uri.host.nil?

— शेन

Answer 4

मुझे पता योग्य मणि पसंद है । मैंने पाया है कि यह URL को अधिक समझदारी से हैंडल करता है।

require 'addressable/uri'

SCHEMES = %w(http https)

def valid_url?(url)
  parsed = Addressable::URI.parse(url) or return false
  SCHEMES.include?(parsed.scheme)
rescue Addressable::URI::InvalidURIError
  false
end

Comments

मैंने अभी पता देने योग्य :: URI.parse () को अजीब स्ट्रिंग्स के साथ देखा कि यह क्या अस्वीकार करता है। इसने पागल सामान स्वीकार कर लिया। हालाँकि, यह स्वीकार नहीं किया गया पहला स्ट्रिंग ":-)" था। हम्म।

— एमवी

यह इतने सारे उत्थान कैसे प्राप्त करता है? Addressable::URI.parseअमान्य इनपुट के साथ शून्य वापस नहीं आता है।

— कचरा उठाने वाला

Answer 5

यह एक काफी पुरानी प्रविष्टि है, लेकिन मुझे लगा कि मैं आगे बढ़कर योगदान दूंगा:

String.class_eval do
    def is_valid_url?
        uri = URI.parse self
        uri.kind_of? URI::HTTP
    rescue URI::InvalidURIError
        false
    end
end

अब आप कुछ ऐसा कर सकते हैं:

if "http://www.omg.wtf".is_valid_url?
    p "huzzah!"
end

Comments

यह उपरोक्त समाधानों की तुलना में बहुत बेहतर काम करता है । यह ऊपर सूचीबद्ध कैवियट नहीं है, और यह भी जावास्क्रिप्ट की तरह यूरिस स्वीकार नहीं करता है: अलर्ट ('स्पैम')।

— bchurchill

लेकिन यह भी मेल खाता है http:/, जो आप नहीं चाहते हो सकता है।

— बो जीन्स

Answer 6

मेरे लिए, मैं इस नियमित अभिव्यक्ति का उपयोग करता हूं:

/^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix

विकल्प:

• i - असंवेदनशील मामला
• x - regex में व्हॉट्सएप को नजरअंदाज करें

URL सत्यापन की जाँच करने के लिए आप यह विधि सेट कर सकते हैं:

def valid_url?(url)
  url_regexp = /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
  url =~ url_regexp ? true : false
end

इसके प्रयेाग के लिए:

valid_url?("http://stackoverflow.com/questions/1805761/check-if-url-is-valid-ruby")

गलत URL के साथ परीक्षण:

• http://ruby3arabi - परिणाम अमान्य है
• http://http://ruby3arabi.com - परिणाम अमान्य है
• http:// - परिणाम अमान्य है

सही URL के साथ परीक्षण करें:

• http://ruby3arabi.com - परिणाम मान्य है
• http://www.ruby3arabi.com - परिणाम मान्य है
• https://www.ruby3arabi.com - परिणाम मान्य है
• https://www.ruby3arabi.com/article/1 - परिणाम मान्य है
• https://www.ruby3arabi.com/websites/58e212ff6d275e4bf9000000?locale=en - परिणाम मान्य है

Comments

निम्नलिखित को मान्य के रूप में चिह्नित किया गया है: "http://test.com\n<script src=\"nasty.js\">"और कोई भी डोमेन जो 683 TLD में से एक का उपयोग करता है जो 5 वर्णों से अधिक लंबा है, या जिसमें दो या अधिक लगातार हाइफ़न हैं, को अमान्य के रूप में चिह्नित किया गया है। 0-65535 रेंज के बाहर पोर्ट नंबर की अनुमति है। एफ़टीपी और आईपी पते स्पष्ट रूप से अस्वीकृत हैं, लेकिन ध्यान देने योग्य हैं।

— एड्रियन

त्वरित url जाँच के लिए यहाँ आसानी से सबसे अच्छा लागू समाधान। धन्यवाद

— किसी दिन १

Answer 7

यह थोड़ा पुराना है लेकिन यहाँ है कि मैं इसे कैसे करता हूं। URL को पार्स करने के लिए रूबी के URI मॉड्यूल का उपयोग करें। यदि इसे पार्स किया जा सकता है तो यह एक मान्य URL है। (लेकिन इसका मतलब सुलभ नहीं है।)

URI कई योजनाओं का समर्थन करता है, साथ ही आप स्वयं कस्टम योजनाएँ भी जोड़ सकते हैं:

irb> uri = URI.parse "http://hello.it" rescue nil
=> #<URI::HTTP:0x10755c50 URL:http://hello.it>

irb> uri.instance_values
=> {"fragment"=>nil,
 "registry"=>nil,
 "scheme"=>"http",
 "query"=>nil,
 "port"=>80,
 "path"=>"",
 "host"=>"hello.it",
 "password"=>nil,
 "user"=>nil,
 "opaque"=>nil}

irb> uri = URI.parse "http:||bra.ziz" rescue nil
=> nil


irb> uri = URI.parse "ssh://hello.it:5888" rescue nil
=> #<URI::Generic:0x105fe938 URL:ssh://hello.it:5888>
[26] pry(main)> uri.instance_values
=> {"fragment"=>nil,
 "registry"=>nil,
 "scheme"=>"ssh",
 "query"=>nil,
 "port"=>5888,
 "path"=>"",
 "host"=>"hello.it",
 "password"=>nil,
 "user"=>nil,
 "opaque"=>nil}

URI मॉड्यूल के बारे में अधिक जानकारी के लिए दस्तावेज़ देखें ।

Comments

मैं एक segfault को ठीक करने की कोशिश कर रहा था। उपयोग करना URI.parseवास्तव में रूबी 2.5.5 में इसका कारण था - मैंने नीचे दिए गए कुछ अजीब मामलों का बुरा नहीं मानने पर @jonuts जवाब में नीचे स्विच किया। मेरे उद्देश्यों के लिए मुझे परवाह नहीं थी इसलिए यह आदर्श था।

— एल n00b

Answer 8

सामान्य रूप में,

/^#{URI::regexp}$/

अच्छी तरह से काम करेगा, लेकिन यदि आप केवल मिलान करना चाहते हैं httpया https, आप उन तरीकों से विकल्प के रूप में पारित कर सकते हैं:

/^#{URI::regexp(%w(http https))}$/

यदि आप प्रोटोकॉल को अस्वीकार करना चाहते हैं, तो यह थोड़ा बेहतर काम करता है ftp://।

Answer 9

आप एक regex का उपयोग भी कर सकते हैं, शायद http://www.geekzilla.co.uk/View2D3B0109-C1B2-4B4E-BFFD-E8088CBC85FD.htm जैसी कोई चीज़ इस rexx को सही मान रही है (मैंने इसे पूरी तरह से जाँच नहीं किया है) url की वैधता दिखाएं।

url_regex = Regexp.new("((https?|ftp|file):((//)|(\\\\))+[\w\d:\#@%/;$()~_?\+-=\\\\.&]*)")

urls = [
    "http://hello.it",
    "http:||bra.ziz"
]

urls.each { |url|
    if url =~ url_regex then
        puts "%s is valid" % url
    else
        puts "%s not valid" % url
    end
}

उपरोक्त उदाहरण आउटपुट:

http://hello.it is valid
http:||bra.ziz not valid

Comments

Mailto योजना के बारे में क्या? या टेलनेट, गोफर, एनएनटीपी, rsync, ssh, या अन्य योजनाओं में से कोई? URL केवल HTTP और FTP की तुलना में थोड़ा अधिक जटिल हैं।

— म्यू बहुत कम है

URL को मान्य करने के लिए regex लिखना मुश्किल है। क्यों परेशान?

— रिमीयन

@ रिमियन, आपको परेशान करना होगा क्योंकि सभी URIकर सकते हैं वास्तव में टूट गया है। ऊपर दिए गए इतने सारे उत्कीर्ण जवाबों के तहत टिप्पणियां देखें। यकीन नहीं होता कि अगर जैनी का जवाब सही है, लेकिन उम्मीद है कि लोग इसे ज्यादा गंभीरता से लेंगे। TBH मैं समाप्त कर url.start_with?("http://") || url.start_with?("https://")रहा हूं क्योंकि मुझे केवल HTTP की आवश्यकता है और उपयोगकर्ताओं को उचित URL का उपयोग करने के लिए जिम्मेदार होना चाहिए।

— अकोस्टाडिनोव