Bagaimana cara memeriksa apakah URL valid

Bagaimana cara memeriksa apakah sebuah string adalah URL yang valid?

Sebagai contoh:

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

Jika ini adalah URL yang valid, bagaimana cara memeriksa apakah ini terkait dengan file gambar?

Gunakan URImodul yang didistribusikan dengan Ruby:

require 'uri'

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

Seperti yang dikatakan Alexander Günther di komentar, ia memeriksa apakah sebuah string berisi URL.

Untuk memeriksa apakah string itu URL, gunakan:

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

Jika Anda hanya ingin memeriksa URL web ( httpatau https), gunakan ini:

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

Mirip dengan jawaban di atas, saya merasa menggunakan regex ini sedikit lebih akurat:

URI::DEFAULT_PARSER.regexp[:ABS_URI]

Itu akan membuat URL dengan spasi tidak valid, bukan URI.regexpyang mengizinkan spasi karena beberapa alasan.

Saya baru saja menemukan pintasan yang disediakan untuk rgexps URI yang berbeda. Anda dapat mengakses salah satu URI::DEFAULT_PARSER.regexp.keyslangsung dari URI::#{key}.

Misalnya, :ABS_URIregexp dapat diakses dari URI::ABS_URI.

Masalah dengan jawaban saat ini adalah bahwa URI bukanlah URL .

URI selanjutnya dapat diklasifikasikan sebagai pencari lokasi, nama, atau keduanya. Istilah "Uniform Resource Locator" (URL) mengacu pada subset URI yang, selain mengidentifikasi sumber daya, menyediakan cara untuk menemukan sumber daya dengan menjelaskan mekanisme akses utamanya (misalnya, "lokasi" jaringannya).

Karena URL adalah bagian dari URI, jelas bahwa pencocokan khusus untuk URI akan berhasil mencocokkan nilai yang tidak diinginkan. Misalnya, URN :

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

Karena itu, sejauh yang saya tahu, Ruby tidak memiliki cara default untuk mengurai URL, jadi Anda kemungkinan besar memerlukan permata untuk melakukannya. Jika Anda perlu mencocokkan URL secara khusus dalam format HTTP atau HTTPS, Anda dapat melakukan sesuatu seperti ini:

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

Saya lebih suka permata Addressable . Saya telah menemukan bahwa ini menangani URL dengan lebih cerdas.

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

Ini adalah entri yang cukup lama, tetapi saya pikir saya akan terus maju dan berkontribusi:

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

Sekarang Anda dapat melakukan sesuatu seperti:

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

Bagi saya, saya menggunakan ekspresi reguler ini:

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

Pilihan:

• i - case insensitive
• x - abaikan spasi kosong di regex

Anda dapat menyetel metode ini untuk memeriksa validasi 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

Untuk menggunakannya:

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

Menguji dengan URL yang salah:

• http://ruby3arabi - hasil tidak valid
• http://http://ruby3arabi.com - hasil tidak valid
• http:// - hasil tidak valid

Uji dengan URL yang benar:

• http://ruby3arabi.com - hasilnya valid
• http://www.ruby3arabi.com - hasilnya valid
• https://www.ruby3arabi.com - hasilnya valid
• https://www.ruby3arabi.com/article/1 - hasilnya valid
• https://www.ruby3arabi.com/websites/58e212ff6d275e4bf9000000?locale=en - hasilnya valid

Ini agak tua tapi beginilah cara saya melakukannya. Gunakan modul URI Ruby untuk mengurai URL. Jika dapat diurai maka itu adalah URL yang valid. (Tapi itu tidak berarti dapat diakses.)

URI mendukung banyak skema, ditambah lagi Anda dapat menambahkan skema kustom sendiri:

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}

Lihat dokumentasi untuk informasi lebih lanjut tentang modul URI.

Secara umum,

/^#{URI::regexp}$/

akan bekerja dengan baik, tetapi jika Anda hanya ingin mencocokkan httpatau https, Anda dapat meneruskannya sebagai opsi ke metode:

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

Itu cenderung bekerja sedikit lebih baik, jika Anda ingin menolak protokol seperti ftp://.

Anda juga dapat menggunakan regex, mungkin sesuatu seperti http://www.geekzilla.co.uk/View2D3B0109-C1B2-4B4E-BFFD-E8088CBC85FD.htm dengan asumsi regex ini benar (saya belum sepenuhnya memeriksanya) tunjukkan validitas 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
}

Output contoh di atas:

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