verificar verificador urls sospechosas segura saber paginas pagina maliciosa link falso comprobar como archivos analizar analiza analisis ruby

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



verificador de paginas web (9)

¿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?


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 .


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


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:// .


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


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.


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

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


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


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/