So überprüfen Sie, ob eine URL gültig ist

Wie kann ich überprüfen, ob eine Zeichenfolge eine gültige URL ist?

Beispielsweise:

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

Wenn dies eine gültige URL ist, wie kann ich überprüfen, ob dies relativ zu einer Bilddatei ist?

Verwenden Sie das URImit Ruby verteilte Modul:

require 'uri'

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

Wie Alexander Günther in den Kommentaren sagte, wird geprüft, ob eine Zeichenfolge eine URL enthält .

Um zu überprüfen , ob die Zeichenfolge ist eine URL, zu verwenden:

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

Wenn Sie nur nach Web-URLs ( httpoder https) suchen möchten , verwenden Sie Folgendes:

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

Ähnlich wie bei den obigen Antworten finde ich die Verwendung dieses regulären Ausdrucks etwas genauer:

URI::DEFAULT_PARSER.regexp[:ABS_URI]

Dadurch werden URLs mit Leerzeichen ungültig, während URI.regexpLeerzeichen aus irgendeinem Grund zulässig sind.

Ich habe kürzlich eine Verknüpfung gefunden, die für die verschiedenen URI-Rgexps bereitgestellt wird. Sie können URI::DEFAULT_PARSER.regexp.keysdirekt von auf zugreifen URI::#{key}.

Auf den :ABS_URIregulären Ausdruck kann beispielsweise von zugegriffen werden URI::ABS_URI.

Das Problem mit den aktuellen Antworten ist, dass ein URI keine URL ist .

Ein URI kann weiter als Locator, Name oder beides klassifiziert werden. Der Begriff "Uniform Resource Locator" (URL) bezieht sich auf die Teilmenge von URIs, die zusätzlich zur Identifizierung einer Ressource ein Mittel zum Auffinden der Ressource bereitstellen, indem sie ihren primären Zugriffsmechanismus (z. B. ihren "Netzwerkstandort") beschreiben.

Da URLs eine Teilmenge von URIs sind, ist es klar, dass der Abgleich speziell für URIs erfolgreich mit unerwünschten Werten übereinstimmt. Zum Beispiel URNs :

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

Soweit ich weiß, hat Ruby jedoch keine Standardmethode zum Parsen von URLs. Daher benötigen Sie höchstwahrscheinlich ein Juwel, um dies zu tun. Wenn Sie URLs speziell im HTTP- oder HTTPS-Format abgleichen müssen, können Sie Folgendes tun:

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

Ich bevorzuge das adressierbare Juwel . Ich habe festgestellt, dass es URLs intelligenter behandelt.

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

Dies ist ein ziemlich alter Eintrag, aber ich dachte, ich würde weitermachen und dazu beitragen:

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

Jetzt können Sie so etwas tun wie:

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

Für mich verwende ich diesen regulären Ausdruck:

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

Möglichkeit:

• i - Groß- und Kleinschreibung wird nicht berücksichtigt
• x - Leerzeichen in Regex ignorieren

Sie können diese Methode festlegen, um die URL-Validierung zu überprüfen:

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

Um es zu benutzen:

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

Testen mit falschen URLs:

• http://ruby3arabi - Ergebnis ist ungültig
• http://http://ruby3arabi.com - Ergebnis ist ungültig
• http:// - Ergebnis ist ungültig

Test mit korrekten URLs:

• http://ruby3arabi.com - Ergebnis ist gültig
• http://www.ruby3arabi.com - Ergebnis ist gültig
• https://www.ruby3arabi.com - Ergebnis ist gültig
• https://www.ruby3arabi.com/article/1 - Ergebnis ist gültig
• https://www.ruby3arabi.com/websites/58e212ff6d275e4bf9000000?locale=en - Ergebnis ist gültig

Das ist ein bisschen alt, aber so mache ich es. Verwenden Sie Rubys URI-Modul, um die URL zu analysieren. Wenn es analysiert werden kann, ist es eine gültige URL. (Das heißt aber nicht zugänglich.)

URI unterstützt viele Schemata, und Sie können selbst benutzerdefinierte Schemata hinzufügen:

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}

Weitere Informationen zum URI-Modul finden Sie in der Dokumentation .

Allgemein,

/^#{URI::regexp}$/

funktioniert gut, aber wenn Sie nur übereinstimmen möchten httpoder https, können Sie diese als Optionen an die Methode übergeben:

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

Das funktioniert etwas besser, wenn Sie Protokolle wie ablehnen möchten ftp://.

Sie können auch einen regulären Ausdruck verwenden, z. B. http://www.geekzilla.co.uk/View2D3B0109-C1B2-4B4E-BFFD-E8088CBC85FD.htm, sofern dieser reguläre Ausdruck korrekt ist (ich habe ihn nicht vollständig überprüft) Zeige die Gültigkeit der 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
}

Das obige Beispiel gibt aus:

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