ruby - verificador - Cómo verificar si una URL es válida

verificador de paginas web

Question

¿Cómo puedo verificar si una cadena es una URL válida?

Por ejemplo:

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

Si esta es una URL válida, ¿cómo puedo verificar si esto es relativo a un archivo de imagen?

Answer 1

Al igual que las respuestas anteriores, me parece que el uso de esta expresión regular es un poco más preciso:

URI::DEFAULT_PARSER.regexp[:ABS_URI]

Eso invalidará las URL con espacios, a diferencia de URI.regexp que permite espacios por algún motivo.

Recientemente encontré un atajo para los diferentes rgexps de URI. Puede acceder a cualquiera de URI::DEFAULT_PARSER.regexp.keys directamente desde URI::#{key} .

Por ejemplo, se puede acceder a la :ABS_URI regexp :ABS_URI desde URI::ABS_URI .

Answer 2

El problema con las respuestas actuales es que un URI no es una URL .

Un URI se puede clasificar además como un localizador, un nombre o ambos. El término "Localizador uniforme de recursos" (URL) se refiere al subconjunto de URI que, además de identificar un recurso, proporciona un medio para ubicar el recurso describiendo su mecanismo de acceso primario (por ejemplo, su "ubicación" de red).

Dado que las URL son un subconjunto de URI, está claro que la coincidencia específica para URI coincidirá con éxito con los valores no deseados. Por ejemplo, URNs :

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

Dicho esto, hasta donde yo sé, Ruby no tiene una forma predeterminada de analizar las URL, por lo que lo más probable es que necesite una joya para hacerlo. Si necesita unir direcciones URL específicamente en formato HTTP o HTTPS, podría hacer algo como esto:

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

Answer 3

En general,

/^#{URI::regexp}$/

funcionará bien, pero si solo desea hacer coincidir http o https , puede pasarlos como opciones al método:

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

Eso tiende a funcionar un poco mejor, si quiere rechazar protocolos como ftp:// .

Answer 4

Esta es una entrada bastante antigua, pero pensé en seguir adelante y contribuir:

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

Ahora puedes hacer algo como:

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

Answer 5

Esto es un poco viejo, pero así es como lo hago. Use el módulo URI de Ruby para analizar la URL. Si se puede analizar, entonces es una URL válida. (Pero eso no significa accesible.)

URI admite muchos esquemas, además puede agregar esquemas personalizados usted mismo:

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}

Consulte la documentación para obtener más información sobre el módulo URI.

Answer 6

Para mí, uso esta expresión regular:

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

Opción:

• i - caso insensible
• x - ignore el espacio en blanco en expresiones regulares

Puede configurar este método para verificar la validación de 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

Para usarlo:

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

Pruebas con URL incorrectas:

• http://ruby3arabi - el resultado no es válido
• http://http://ruby3arabi.com - el resultado no es válido
• http:// - el resultado no es válido

Prueba con las URL correctas:

• http://ruby3arabi.com - resultado es válido
• http://www.ruby3arabi.com - el resultado es válido
• https://www.ruby3arabi.com - el resultado es válido
• https://www.ruby3arabi.com/article/1 - el resultado es válido
• https://www.ruby3arabi.com/websites/58e212ff6d275e4bf9000000?locale=en - el resultado es válido

Answer 7

Prefiero la gema direccionable . Descubrí que maneja las URL de forma más inteligente.

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

Answer 8

También podría usar una expresión regular, tal vez algo como http://www.geekzilla.co.uk/View2D3B0109-C1B2-4B4E-BFFD-E8088CBC85FD.htm suponiendo que esta expresión regular es correcta (no la he comprobado completamente) la siguiente muestra la validez de la 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
}

El ejemplo anterior muestra:

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

Answer 9

Use el módulo URI distribuido con Ruby:

require ''uri''
if url =~ URI::regexp
# Correct URL
end

Como dijo Alexander Günther en los comentarios, comprueba si una cadena contiene una URL.

Para verificar si la cadena es una URL, use:

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

Si solo desea buscar URLs web ( http o https ), use esto:

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