Bir URL'nin geçerli olup olmadığı nasıl kontrol edilir

Bir dizenin geçerli bir URL olup olmadığını nasıl kontrol edebilirim?

Örneğin:

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

Bu geçerli bir URL ise, bunun bir resim dosyasına göre olup olmadığını nasıl kontrol edebilirim?

URIRuby ile dağıtılan modülü kullanın :

require 'uri'

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

Gibi Alexander Günther yorumlar dedi bir dize, eğer denetler içeren bir URL.

Dize olmadığını kontrol etmek olduğunu URL kullanın:

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

Yalnızca web URL'lerini ( httpveya https) kontrol etmek istiyorsanız , şunu kullanın:

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

Yukarıdaki yanıtlara benzer şekilde, bu normal ifadeyi kullanmayı biraz daha doğru buluyorum:

URI::DEFAULT_PARSER.regexp[:ABS_URI]

Bu, URI.regexpherhangi bir nedenle boşluklara izin veren URL'lerin aksine boşluklu URL'leri geçersiz kılar .

Yakın zamanda farklı URI rgexps için sağlanan bir kısayol buldum. Herhangi birinden URI::DEFAULT_PARSER.regexp.keysdoğrudan erişebilirsiniz URI::#{key}.

Örneğin, :ABS_URIregexp'e adresinden erişilebilir URI::ABS_URI.

Mevcut cevaplarla ilgili sorun, bir URI'nin bir URL olmamasıdır .

Bir URI ayrıca bir konum belirleyici, bir ad veya her ikisi olarak sınıflandırılabilir. "Tekdüzen Kaynak Konum Belirleyicisi" (URL) terimi, bir kaynağın tanımlanmasına ek olarak, birincil erişim mekanizmasını (örneğin, ağ "konumu") açıklayarak kaynağın konumlandırılması için bir araç sağlayan URI'lerin alt kümesine karşılık gelir.

URL'ler URI'lerin bir alt kümesi olduğundan, özellikle URI'ler için eşleşmenin istenmeyen değerlerle başarılı bir şekilde eşleşeceği açıktır. Örneğin, URN'ler :

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

Bununla birlikte, bildiğim kadarıyla Ruby'nin URL'leri ayrıştırmak için varsayılan bir yolu yok, bu yüzden bunu yapmak için büyük olasılıkla bir cevher ihtiyacınız olacak. URL'leri özellikle HTTP veya HTTPS biçiminde eşleştirmeniz gerekiyorsa, aşağıdaki gibi bir şey yapabilirsiniz:

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

Adreslenebilir mücevheri tercih ederim . URL'leri daha akıllıca işlediğini buldum.

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

Bu oldukça eski bir giriş, ancak devam edip katkıda bulunacağımı düşündüm:

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

Şimdi şöyle bir şey yapabilirsiniz:

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

Benim için şu normal ifadeyi kullanıyorum:

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

Seçenek:

• i - büyük / küçük harfe duyarlı değil
• x - normal ifadede boşlukları yoksay

URL doğrulamasını kontrol etmek için bu yöntemi ayarlayabilirsiniz:

def valid_url?(url)
  return false if url.include?("<script")
  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

Kullanmak için:

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

Yanlış URL'lerle test etme:

• http://ruby3arabi - sonuç geçersiz
• http://http://ruby3arabi.com - sonuç geçersiz
• http:// - sonuç geçersiz
• http://test.com\n<script src=\"nasty.js\"> (Sadece "<script" i kontrol edin)

Doğru URL'lerle test edin:

• http://ruby3arabi.com - sonuç geçerlidir
• http://www.ruby3arabi.com - sonuç geçerlidir
• https://www.ruby3arabi.com - sonuç geçerlidir
• https://www.ruby3arabi.com/article/1 - sonuç geçerlidir
• https://www.ruby3arabi.com/websites/58e212ff6d275e4bf9000000?locale=en - sonuç geçerlidir

Bu biraz eski ama işte bunu nasıl yapıyorum. URL'yi ayrıştırmak için Ruby'nin URI modülünü kullanın. Ayrıştırılabiliyorsa, geçerli bir URL'dir. (Ancak bu erişilebilir anlamına gelmez.)

URI birçok şemayı destekler, ayrıca özel şemaları kendiniz ekleyebilirsiniz:

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 modülü hakkında daha fazla bilgi için belgelere bakın .

Genel olarak,

/^#{URI::regexp}$/

iyi çalışacaktır, ancak yalnızca eşleştirmek istiyorsanız httpveya httpsbunları seçenek olarak yönteme aktarabilirsiniz:

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

Şu gibi protokolleri reddetmek istiyorsanız, bu biraz daha iyi çalışma eğilimindedir. ftp:// .

Ayrıca bir normal ifade de kullanabilirsiniz, belki http://www.geekzilla.co.uk/View2D3B0109-C1B2-4B4E-BFFD-E8088CBC85FD.htm gibi bir şey, bu normal ifadenin doğru olduğunu varsayarak (tam olarak kontrol etmedim) aşağıdakiler url'nin geçerliliğini gösterin.

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
}

Yukarıdaki örnek çıktılar:

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