Hay una manera en JavaScript para comprobar si una cadena es un URL?

Expresiones regulares son excluidos debido a que la dirección es más probable que se escriben como stackoverflow; es decir, que no puede tener una .com, www o http.

  • Si falta la http, es por defecto, no la url.
  • es decir, que si no especifica un protocolo y utilizar el carácter de dos puntos (de preferencia con dos barras diagonales siguiente), entonces no es un URL?
  • porque el algo del anexar una .com, .net, .biz, .org, .gov, .mil, etc para el nombre y la prueba para ver si funciona, dado un cierto orden preferencial. Alternativamente, se pide a google si es probable que un nombre de dominio.
  • Como se puede leer en la URL RFC, la única parte realmente necesario para hacer una Cadena de una dirección URL válida es el colon. Válido Url aspecto: <scheme>:<scheme-specific-part>
  • ¿podría dar un ejemplo o dos o la dirección url que desea analizar y lo que usted espera obtener de él ?
  • La verdad es que estoy en la búsqueda de marcadores de Google chrome, así que tengo un montón de datos. Me puede mostrar todo el contenido de los marcadores de árbol y las direcciones url están subrayadas cuando les pantalla.
  • Pero aquellos marcado Url contienen un protocolo y similares.
  • Korpel Sí, pero cuando puedo visualizar el contenido de el árbol de favoritos el árbol debe tener una manera de saber la diferencia entre la url y el texto (un atributo ?).
  • Usted está hablando sobre el administrador de marcadores, no?
  • No estoy buscando directamente en Google Chrome de la API, así que voy a través del árbol de favoritos.
  • En code.google.com/chrome/extensions/bookmarks.html usted puede ver que los títulos y las direcciones Url se guardan en dos ‘campos’ en un ‘record’ (objeto).
  • consulte stackoverflow.com/a/3975573/572180
  • Cómo probar si algo es una dirección URL es altamente dependiente del contexto y demasiado vaga sin mayor calificación. Qué le importa a usted si cumple con la URL de la especificación RFC, funciona cuando hacer un sistema operativo de llamada para abrir la URL, analiza como un href en un elemento ancla, funciona cuando se llama a window.open(url), apunta a algo que realmente existe, funciona en la barra de dirección del navegador, o una combinación de los anteriores? Obtendrás respuestas muy distintas dependiendo de cuál de estos te importa.

InformationsquelleAutor Bruno | 2011-04-19

24 Comentarios

  1. 120

    Una pregunta relacionada con una respuesta:

    Javascript regex URL coincidencia

    O este Regexp de Devshed:

    function validURL(str) {
      var pattern = new RegExp('^(https?:\/\/)?'+ //protocol
        '((([a-z\d]([a-z\d-]*[a-z\d])*)\.)+[a-z]{2,}|'+ //domain name
        '((\d{1,3}\.){3}\d{1,3}))'+ //OR ip (v4) address
        '(\:\d+)?(\/[-a-z\d%_.~+]*)*'+ //port and path
        '(\?[;&a-z\d%_.~+=-]*)?'+ //query string
        '(\#[-a-z\d_]*)?$','i'); //fragment locator
      return !!pattern.test(str);
    }
    • Gracias por tu respuesta pero no los puedo usar regex.
    • ¿cómo viene? Es mejor resolver estos tipos de problemas.
    • Yo sé, pero yo estoy buscando en mis favoritos y la mayoría de ellos están escritos como stackoverflow (sin .com, etc.)
    • es muy probable que sean internamente guarda con títulos y URLs, como { title: "Stackoverflow", uri: "http://stackoverflow.com" } Actualización: de hecho, consulte code.google.com/chrome/extensions/bookmarks.html
    • tratando de usar su ejemplo. Pero estoy recibiendo un error en firebug que decir invalid quantifier. Alguna idea?
    • Tengo el mismo problema. Ver la respuesta correcta por debajo de Zemljoradnik
    • La función devuelve: SyntaxError: Invalid regular expression: /^(https?://)?((([a-zd]([a-zd-]*[a-zd])*).)+[a-z]{2,}|((d{1,3}.){3}d{1,3}))(:d+)?(/[-a-zd%_.~+]*)*(?[;&a-zd%_.~+=-]*)?(#[-a-zd_]*)?$/: Invalid group Google Chrome (Versión 30.0.1599.101) (Mac OS X 10.8.5)
    • no válido cuantificador SyntaxError: invalid cuantificador ‘(\#[-a-z\d]*)?$’,’i’);
    • Tenga en cuenta que si utiliza una cadena como parámetro para la RegExp tiene doble escapar de las barras – de lo contrario usted obtener errores como grupo no válido.
    • Esta respuesta da error con las Url con un puerto
    • Obtengo grupo no válido para el google.com
    • //cdn.google.com/script.js falla
    • Grupo no válido…arreglar por favor
    • Con Firefox 52.0.2, prueba con «largo» cadenas (no mucho en realidad, de 40 caracteres es suficiente) es increíblemente lento, hasta el punto de que tengo que matar a la secuencia de comandos. No sé si esto es un bug de Firefox o algo mal con la propia expresión.
    • De una manera más precisa ejemplo: falla para esta prueba: pattern.test('53d967a6-43b1-44a3-ac89-ad23d7adcef8_IL_B'). También falla en Chrome 58.0.3029.81. La eliminación de la _ caracteres de la URL funciona en torno a la cuestión.
    • Devuelve true con URL ssssss. Así que no creo que sea una respuesta correcta
    • responder a continuación es una buena mejora que funciona fuera de la caja stackoverflow.com/a/45567717/1158844
    • Ellos han rechazado a mi edición, pero necesita cambiar el protocolo parte de este '^((ft|htt)ps?:\\/\\/)?' para comprobar la ftp/ftps así como http/https.
    • Error en la dirección url válida web.archive.org/web/20170817095211/https://github.com/Microsoft/…
    • No se en en.m.wikipedia.org/wiki/C_Sharp_(programming_language)
    • http://www.google es una dirección URL válida de acuerdo con esta expresión.
    • http://www.jayakumar es una url válida? se devuelve true

  2. 160
    function isURL(str) {
      var pattern = new RegExp('^(https?:\/\/)?'+ //protocol
      '((([a-z\d]([a-z\d-]*[a-z\d])*)\.?)+[a-z]{2,}|'+ //domain name
      '((\d{1,3}\.){3}\d{1,3}))'+ //OR ip (v4) address
      '(\:\d+)?(\/[-a-z\d%_.~+]*)*'+ //port and path
      '(\?[;&a-z\d%_.~+=-]*)?'+ //query string
      '(\#[-a-z\d_]*)?$','i'); //fragment locator
      return pattern.test(str);
    }
    • devuelve false para «magnet:?xt=urn:btih:123»
    • devuelve false para http://en.wikipedia.org/wiki/Procter_&_Gamble
    • falla en la búsqueda de google los enlaces de imagen : http://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&docid=nIv5rk2GyP3hXM&tbnid=isiOkMe3nCtexM:&ved=0CAUQjRw&url=http%3A%2F%2Fanimalcrossing.wikia.com%2Fwiki%2FLion&ei=ygZXU_2fGKbMsQTf4YLgAQ&bvm=bv.65177938,d.aWc&psig=AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g&ust=1398298682009707
    • Esta expresión no para una gran cantidad de casos comunes. Se puede mejorar mediante la adición de un par de personajes más para el «puerto y la ruta de acceso» y «cadena de consulta» líneas, pero este enfoque probablemente no es la mejor idea. Ver mi respuesta para las alternativas.
    • este es inutilizable lento
    • Lo que quiere decir por lento? start = new Date(); isURL("http://michalstefanow.com"); end = new Date(); diff = end - start; console.log(diff) Puse agua a hervir, se fue a un cuarto de baño, llamé a mi mamá y la cosa fue hecha en ningún momento…
    • Para refrence bien, con las barras diagonales inversas es var pattern = new RegExp('^(https?:\\/\\/)?'+ '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ '((\\d{1,3}\\.){3}\\d{1,3}))'+ '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ '(\\?[;&a-z\d%_.~+=-]*)?'+ '(\\#[-a-z\d_]*)?$','i');
    • ¿por qué siempre que devolver true para mí, incluso mi str valor es «hwa».
    • Devuelve true para aaa.
    • //cdn.google.com/script.js falla
    • devuelve true para dfdsfdsfdfdsfsdfs
    • no funciona en thingiverse.com/download:1894343
    • Devolver true para https://sdfasd
    • Esto absolutamente no debe ser la respuesta correcta. Que falla en muchos de los casos de prueba y lo más importante es que se cuelga de su página en incluso una cadena corta: isURL('12345678901234567890123') añadir más personajes y es aun peor.
    • Por qué esta respuesta tiene 143 upvotes?
    • es sin duda válida, de trabajo de nivel superior TLD en algunas redes de Intranet. Trate de nslookup aaa y se una consulta al servidor DNS para que en lugar de rechazar de plano.
    • devolver true para ‘America/New_York’
    • no funciona, usted puede tipo de www y presentar omite esta expresión regular.
    • No está seguro de cómo esto tiene esto muchos upvotes. Devuelve true para asdsdasd.

  3. 83

    Lugar de utilizar una expresión regular, yo recomendaría hacer uso de un elemento delimitador.

    cuando se establece la href propiedad de un anchor, varias otras propiedades.

    var parser = document.createElement('a');
    parser.href = "http://example.com:3000/pathname/?search=test#hash";
    
    parser.protocol; //=> "http:"
    parser.hostname; //=> "example.com"
    parser.port;     //=> "3000"
    parser.pathname; //=> "/pathname/"
    parser.search;   //=> "?search=test"
    parser.hash;     //=> "#hash"
    parser.host;     //=> "example.com:3000"

    fuente

    Sin embargo, si el valor href está obligado a no es una url válida, entonces el valor de los auxiliares de propiedades va a ser la cadena vacía.

    Edición: como se señaló en los comentarios: si una dirección url no válida se utiliza, las propiedades de la actual dirección URL puede ser sustituido.

    Así que, mientras no se le está pasando en la dirección URL de la página actual, puedes hacer algo como:

    function isValidURL(str) {
       var a  = document.createElement('a');
       a.href = str;
       return (a.host && a.host != window.location.host);
    }
    • Este no es el caso (en Chrome 48 al menos). Si la dirección url pasa a a.href no es válido, parser.host devuelve el nombre de host de la página en la que estamos actualmente, no se espera false.
    • Gah! eso es raro. Juro que he probado! Creo que es justo decir que este no realmente tiene que ser utilizado EN la página actual, por lo que el condicional puede ser cambiada. Voy a editar el post.
    • no es muy típico caso de uso, pero esta técnica no funciona en el contexto del navegador Firefox (importante para el addon de desarrollo)
    • Este es sin duda un motivo de preocupación cuando se utiliza este método, pero yo sólo quiero señalar que este no es un comportamiento especial. Si usted tiene un enlace en su página no válida, como <a href="invalidurl">, que no ir a su dominio. Que se añade a la final de la url de la página actual. Así que Chrome está haciendo lo correcto al dar el nombre de host del «analizador» elemento».
    • function isValidURL(str): mucho mejor que usar regex! Gracias!
    • Manera bastante simple para hack de todo el problema. Estas propiedades son experimentales, sin embargo: developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
    • Devuelve true para https://abc
    • Bonito solución. Pero no puede gestionar chrome://extensions y devuelve true. Pero para las extensiones de Chrome, no es una URL válida.

  4. 64

    Puedes probar a utilizar URL constructor: si no tiro de la cadena es una URL válida:

    const isValidUrl = (string) => {
      try {
        new URL(string);
        return true;
      } catch (_) {
        return false;  
      }
    }
    • Esto produce una excepción para una cadena como http://www.google.com lo que indica que esta no es una URL válida, cuando se trata de una dirección URL válida
    • no, no; por ejemplo, no se puede utilizar como href atributo para <a>. Dirección URL válida debe comenzar con un esquema de nombre, por ejemplo,https://.
    • Se ve bien, espero que pronto deje la etapa experimental.
    • nueva URL(‘javascript:alert(23)’)
    • Como Pavlo dijo, tu comentario no es correcto. Trate de usar un elemento delimitador para enlazar una página externa… la url termina igual… (example.com/www.example.com) en lugar de ir a (example.com).
    • esto devuelve true isValidUrl("javascript:void(0)")
    • Me gusta este por enseñarme cosas nuevas acerca de js! No tiene falsos negativos que he podido encontrar. Tiene algunos falsos positivos: http://.. O http:///a
    • URL está trabajando a partir de Borde, de manera que todo debajo podría no funcionar como se espera. Asegúrese de comprobar la compatibilidad de primera.
    • Por lejos la mejor respuesta
    • Esto es mucho más sencillo de responder. Definitivamente más comprensible para las personas que no obtienen expresiones regulares.

  5. 30

    Para Validar la Url con javascript se muestra a continuación

    function ValidURL(str) {
      var regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
      if(!regex .test(str)) {
        alert("Please enter valid URL.");
        return false;
      } else {
        return true;
      }
    }
    • Varias partes de la expresión regular puede ser muy reducida: a) (http|https) a (?:https?); b) :{0,1} a :?; c) [0-9] a \d
  6. 30

    Estoy usando la siguiente función para validar la URL con o sin http/https:

    JS:

    function isValidURL(string) {
      var res = string.match(/(http(s)?:\/\/.)?(www\.)?[[email protected]:%._\+~#=]{2,256}\.[a-z]{2,6}\b([[email protected]:%_\+.~#?&//=]*)/g);
      return (res !== null)
    };
    
    var testCase1 = "http://en.wikipedia.org/wiki/Procter_&_Gamble";
    console.log(isValidURL(testCase1)); //return true
    
    var testCase2 = "http://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&docid=nIv5rk2GyP3hXM&tbnid=isiOkMe3nCtexM:&ved=0CAUQjRw&url=http%3A%2F%2Fanimalcrossing.wikia.com%2Fwiki%2FLion&ei=ygZXU_2fGKbMsQTf4YLgAQ&bvm=bv.65177938,d.aWc&psig=AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g&ust=1398298682009707";
    console.log(isValidURL(testCase2)); //return true
    
    var testCase3 = "https://sdfasd";
    console.log(isValidURL(testCase3)); //return false
    
    var testCase4 = "dfdsfdsfdfdsfsdfs";
    console.log(isValidURL(testCase4)); //return false
    
    var testCase5 = "magnet:?xt=urn:btih:123";
    console.log(isValidURL(testCase5)); //return false
    
    var testCase6 = "https://stackoverflow.com/";
    console.log(isValidURL(testCase6)); //return true
    
    var testCase7 = "https://w";
    console.log(isValidURL(testCase7)); //return false
    
    var testCase8 = "https://sdfasdp.ppppppppppp";
    console.log(isValidURL(testCase8)); //return false

    • Parece una buena solución! Podría agregar algunas pruebas que muestran que funciona en algunos casos de esquina (ver, por ejemplo, estos comentarios)?
    • añadido casos de prueba. Por favor, compruebe
    • No está mal, no pasa de http://⌘.ws o 142.42.1.1, y se permite http://.www.foo.bar./ pero no se bloquea como algunos de los otros regex incluyendo la parte superior nominal respuestas.
    • a continuación, se merecen un upvote 😉
    • He comprobado tu respuesta. Su respuesta está fallando para https://sdfasdp.ppppppppppp es decir, devolverle true pero la mía devuelve false que se espera que la creo.
    • añade esta prueba https://w así. Mi solución devuelve false para ésta y la de la prueba así https://sdfasdp.ppppppppppp
    • Creo que tanto el regex he citado el uso de {2} para el dominio, porque no hay ningún límite. El tuyo usa {2,6} pero sólo me miró y vio cosas que te gusta .los contadores como válido dominios. Ciertamente fácil cambiar ese término en cualquiera de estos.
    • ¿has comprobado que mi respuesta?
    • su devuelve true para [email protected]…debería? Supongo que no debe
    • Bastante bueno. Sin embargo, devuelve true para las cadenas que contienen espacios. Por ejemplo, «ejemplo ejemplo.io» devuelve true.
    • Esta falla cuando la URL tiene un puerto.
    • http://www.google es una dirección URL válida de acuerdo a esto.
    • http://www.google es una dirección URL válida de acuerdo a esto.

  7. 22

    Mejora en la aceptó responder…

    • De verificación para ftp/ftps como el protocolo de
    • Tiene el doble escape para barras diagonales inversas ( \ )
    • Se asegura de que los dominios tienen un punto y una extensión (.com .io .xyz)
    • Permite a los dos puntos (:) en el camino por ejemplo, http://thingiverse.com/download:1894343
    • Permite signo de y comercial (&) en la ruta e.g http://en.wikipedia.org/wiki/Procter_&_Gamble
    • Permite símbolo @ en el camino por ejemplo, https://medium.com/@techytimo

      isURL(str) {
        var pattern = new RegExp('^((ft|htt)ps?:\/\/)?'+ //protocol
        '((([a-z\d]([a-z\d-]*[a-z\d])*)\.)+[a-z]{2,}|'+ //domain name and extension
        '((\d{1,3}\.){3}\d{1,3}))'+ //OR ip (v4) address
        '(\:\d+)?'+ //port
        '(\/[-a-z\d%@_.~+&:]*)*'+ //path
        '(\?[;&a-z\d%@_.,~+&:=-]*)?'+ //query string
        '(\#[-a-z\d_]*)?$','i'); //fragment locator
        return pattern.test(str);
      }

  8. 11

    Aquí es otro método.

    JS:

    var elm;
    function isValidURL(u){
      if(!elm){
        elm = document.createElement('input');
        elm.setAttribute('type', 'url');
      }
      elm.value = u;
      return elm.validity.valid;
    }
    
    console.log(isValidURL('http://www.google.com/'));
    console.log(isValidURL('//google.com'));
    console.log(isValidURL('google.com'));
    console.log(isValidURL('localhost:8000'));

    • El código de educación! El mecanismo aquí es probablemente idéntico a cómo new URL(string) en Pavlo el código funciona. Ambas pruebas tienen idénticos resultados con todos los casos de borde que he probado. Me gusta su código porque es más simple y no implica la creación de elementos, pero el tuyo es un par de veces más rápido (probablemente porque no crea el después del primer uso).
    • Gracias! He implementado tu consejo. Ser conscientes, sin embargo: los navegadores más Antiguos y/o dispositivo móvil WebView de mayo no han implementado la <input type =url> elemento; por lo tanto el valor de la entrada será tratado como un texto normal (no la URL de validación). REF: developer.mozilla.org/en-US/docs/Web/HTML/Element/input/url
  9. 9

    (No tengo repeticiones para comentar sobre ValidURL ejemplo; por lo tanto este post como respuesta.)

    Mientras el uso del protocolo de direcciones Url relativas, no es recomendado (El Protocolo de la dirección URL relativa), que emplea a veces. Para validar dicha URL, con una expresión regular en el protocolo parte, podría ser opcional, por ejemplo:

    function isValidURL(str) {
        var pattern = new RegExp('^((https?:)?\/\/)?'+ //protocol
            '(?:\S+(?::\S*)[email protected])?' + //authentication
            '((([a-z\d]([a-z\d-]*[a-z\d])*)\.)+[a-z]{2,}|'+ //domain name
            '((\d{1,3}\.){3}\d{1,3}))'+ //OR ip (v4) address
            '(\:\d+)?(\/[-a-z\d%_.~+]*)*'+ //port and path
            '(\?[;&a-z\d%_.~+=-]*)?'+ //query string
            '(\#[-a-z\d_]*)?$','i'); //fragment locater
        if (!pattern.test(str)) {
            return false;
        } else {
            return true;
        }
    }

    Como otros señalaron, la expresión regular no parece ser el mejor enfoque para la validación de direcciones Url, aunque.

    • Al principio pensé que esto era bastante buena, pero no muchas de las pruebas en mathiasbynens.ser/demo/url-regex, y luego se cuelga en isValidURL("https://[email protected]/13176")
    • Sí, como he dicho, yo simplemente comentó en el protocolo de parte. He añadido la autenticación cláusula para controlar @. No se bloquea en mi los navegadores.
    • Lo siento, se me fue pasando por varias de estas a evaluar, y se perdió de que el suyo estaba comentando sobre la respuesta. Creo que su corrección, incluso me ayudó a empezar a trabajar en estas cuando visité por primera vez esta página. No colgar ahora.
  10. 6

    Que no puedo comentar en el post que es el más cercano #5717133, pero a continuación es la forma en que me di cuenta de cómo conseguir @tom-gullen regex de trabajo.

    /^(https?:\/\/)?((([a-z\d]([a-z\d-]*[a-z\d])*)\.)+[a-z]{2,}|((\d{1,3}\.){3}\d{1,3}))(\:\d+)?(\/[-a-z\d%_.~+]*)*(\?[;&a-z\d%_.~+=-]*)?(\#[-a-z\d_]*)?$/i
    • Esto funcionó para mí, pero necesitaba barra diagonal inversa las barras diagonales inversas. var pattern = new RegExp('(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*(\\?[;&a-z\\d%_.~+=-]*)?(\\#[-a-z\\d_]*)?$', 'i');
    • falso en localhost:8080
  11. 6

    Como ha señalado el perfecto regex es difícil de alcanzar, pero aún así parece ser un enfoque razonable (alternativas del lado del servidor de pruebas o la nueva experimentales URL DE LA API). Sin embargo, el alto rango de las respuestas son a menudo devolver false para el común de URLs pero aún peor va a congelar su aplicación/página durante varios minutos, incluso como simple una cadena como isURL('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'). Se ha señalado en algunos de los comentarios, pero la mayoría probablemente no ha introducido un valor incorrecto a ver. Colgando como que hace que el código no se puede utilizar en cualquier serios de aplicación. Creo que es debido a la repetición de mayúsculas y minúsculas establece en el código como ((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|' .... Sacar el ‘yo’ y no se bloquea, pero no funciona como se desea. Pero incluso con la de ignorar caso de la bandera de los exámenes de rechazar altos valores unicode que están permitidos.

    La mejor ya se mencionó es:

    function isURL(str) {
      return /^(?:\w+:)?\/\/([^\s\.]+\.\S{2}|localhost[\:?\d]*)\S*$/.test(str); 
    }

    Que viene desde Github segmentio/es-url. La cosa buena acerca de un repositorio de código se puede ver la prueba y de todos los problemas y también la prueba de las cadenas de ejecutar a través de él. Hay una rama que permitiría a las cadenas de falta de protocolo como google.com, aunque probablemente estás haciendo demasiadas suposiciones, a continuación,. El repositorio ha sido actualizado y no estoy pensando en tratar de mantener un espejo aquí. Se ha roto en pruebas separadas para evitar RegEx rehacer que pueden ser explotadas por los ataques de DOS (creo que no tiene que preocuparse de que con el lado del cliente js, pero usted no tiene que preocuparse de su página colgando durante tanto tiempo que su visitante sale de su sitio).

    Hay otro repositorio he visto que puede ser incluso mejor para isURL en dperini/regex-weburl.js, pero es muy complejo. Una mayor lista de pruebas de válidos y de las direcciones Url. El simple sobre pasa todos los aspectos positivos y sólo no cuadra un par de impares negativos como http://a.b--c.de/ así como el especial de ips.

    Cualquiera que usted elija, ejecute a través de esta función que he adaptado de las pruebas en dperini/regex-weburl.js, mientras que el uso de su navegador las Herramientas de Desarrollador de inpector.

    function testIsURL() {
    //should match
    console.assert(isURL("http://foo.com/blah_blah"));
    console.assert(isURL("http://foo.com/blah_blah/"));
    console.assert(isURL("http://foo.com/blah_blah_(wikipedia)"));
    console.assert(isURL("http://foo.com/blah_blah_(wikipedia)_(again)"));
    console.assert(isURL("http://www.example.com/wpstyle/?p=364"));
    console.assert(isURL("https://www.example.com/foo/?bar=baz&inga=42&quux"));
    console.assert(isURL("http://✪df.ws/123"));
    console.assert(isURL("http://userid:[email protected]:8080"));
    console.assert(isURL("http://userid:[email protected]:8080/"));
    console.assert(isURL("http://[email protected]"));
    console.assert(isURL("http://[email protected]/"));
    console.assert(isURL("http://[email protected]:8080"));
    console.assert(isURL("http://[email protected]:8080/"));
    console.assert(isURL("http://userid:[email protected]"));
    console.assert(isURL("http://userid:[email protected]/"));
    console.assert(isURL("http://142.42.1.1/"));
    console.assert(isURL("http://142.42.1.1:8080/"));
    console.assert(isURL("http://➡.ws/䨹"));
    console.assert(isURL("http://⌘.ws"));
    console.assert(isURL("http://⌘.ws/"));
    console.assert(isURL("http://foo.com/blah_(wikipedia)#cite-1"));
    console.assert(isURL("http://foo.com/blah_(wikipedia)_blah#cite-1"));
    console.assert(isURL("http://foo.com/unicode_(✪)_in_parens"));
    console.assert(isURL("http://foo.com/(something)?after=parens"));
    console.assert(isURL("http://☺.damowmow.com/"));
    console.assert(isURL("http://code.google.com/events/#&product=browser"));
    console.assert(isURL("http://j.mp"));
    console.assert(isURL("ftp://foo.bar/baz"));
    console.assert(isURL("http://foo.bar/?q=Test%20URL-encoded%20stuff"));
    console.assert(isURL("http://مثال.إختبار"));
    console.assert(isURL("http://例子.测试"));
    console.assert(isURL("http://उदाहरण.परीक्षा"));
    console.assert(isURL("http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com"));
    console.assert(isURL("http://1337.net"));
    console.assert(isURL("http://a.b-c.de"));
    console.assert(isURL("http://223.255.255.254"));
    console.assert(isURL("postgres://u:[email protected]:5702/db"));
    console.assert(isURL("https://[email protected]/13176"));
    //SHOULD NOT MATCH:
    console.assert(!isURL("http://"));
    console.assert(!isURL("http://."));
    console.assert(!isURL("http://.."));
    console.assert(!isURL("http://../"));
    console.assert(!isURL("http://?"));
    console.assert(!isURL("http://??"));
    console.assert(!isURL("http://??/"));
    console.assert(!isURL("http://#"));
    console.assert(!isURL("http://##"));
    console.assert(!isURL("http://##/"));
    console.assert(!isURL("http://foo.bar?q=Spaces should be encoded"));
    console.assert(!isURL("//"));
    console.assert(!isURL("//a"));
    console.assert(!isURL("///a"));
    console.assert(!isURL("///"));
    console.assert(!isURL("http:///a"));
    console.assert(!isURL("foo.com"));
    console.assert(!isURL("rdar://1234"));
    console.assert(!isURL("h://test"));
    console.assert(!isURL("http://shouldfail.com"));
    console.assert(!isURL("://should fail"));
    console.assert(!isURL("http://foo.bar/foo(bar)baz quux"));
    console.assert(!isURL("ftps://foo.bar/"));
    console.assert(!isURL("http://-error-.invalid/"));
    console.assert(!isURL("http://a.b--c.de/"));
    console.assert(!isURL("http://-a.b.co"));
    console.assert(!isURL("http://a.b-.co"));
    console.assert(!isURL("http://0.0.0.0"));
    console.assert(!isURL("http://10.1.1.0"));
    console.assert(!isURL("http://10.1.1.255"));
    console.assert(!isURL("http://224.1.1.1"));
    console.assert(!isURL("http://1.1.1.1.1"));
    console.assert(!isURL("http://123.123.123"));
    console.assert(!isURL("http://3628126748"));
    console.assert(!isURL("http://.www.foo.bar/"));
    console.assert(!isURL("http://www.foo.bar./"));
    console.assert(!isURL("http://.www.foo.bar./"));
    console.assert(!isURL("http://10.1.1.1"));}

    Y, a continuación, la prueba de que la cadena de ‘a.

    Ver este comparación de isURL regex por Mathias Bynens para obtener más información antes de publicar un aparentemente gran regex.

    • He comprobado tu respuesta. Su respuesta está fallando para sdfasdp.ppppppppppp es decir, que devuelve true, pero se espera es falso
    • Creo que es una URL válida, estructuralmente. No es un experto en el estándar, pero no creo que hay un límite en la duración de la .com parte (que yo conozco .online es de fiar).
    • Yo apenas sabía cómo escribir una expresión regular de un par de meses atrás. El problema es grave. Tanto de la expresión regular que he citado puede completar isURL('a'.repeat(100)) millones de veces/sec (el más complejo de dperini es más rápido). Algunos de los de alto rango de las respuestas de la forma ([a-zA-Z]+)* llevaría horas para completar esa vez. Buscar RegEx rehacer para obtener más información.
  12. 5

    Puede utilizar el URL de la API nativa:

      const isUrl = string => {
    try { return Boolean(new URL(string)); }
    catch(e){ return false; }
    }
    • isUrl('https://w') devuelve true
    • Se ve muy similar a la respuesta proporcionada por @pavlo, sólo los nombres de las variables cambiado 😉
    • no debe ser una simple método nativo para comprobar esto por ahora – esta respuesta se veía muy prometedor, pero devuelve true pronto como @Basj mencionados anteriormente.
    • están a la derecha. Este caso no está contemplado. Gracias!
    • es una URL válida
  13. 4

    Una función que he estado usando para validar una URL «cadena» es:

    var matcher = /^(?:\w+:)?\/\/([^\s\.]+\.\S{2}|localhost[\:?\d]*)\S*$/;
    function isUrl(string){
    return matcher.test(string);
    }

    Esta función devolverá un valor booleano si la cadena es una dirección URL.

    Ejemplos:

    isUrl("https://google.com");     //true
    isUrl("http://google.com");      //true
    isUrl("http://google.de");       //true
    isUrl("//google.de");            //true
    isUrl("google.de");              //false
    isUrl("http://google.com");      //true
    isUrl("http://localhost");       //true
    isUrl("https://sdfasd");         //false
  14. 2

    Esto es bastante difícil de hacer con puro regex porque Url muchos de los ‘inconvenientes’.

    1. Por ejemplo los nombres de dominio han complicado las restricciones en los guiones:

      una. Es permitido tener muchas guiones consecutivos en el medio.

      b. pero el primer carácter y el último carácter del nombre de dominio no puede ser un guión

      c. El 3 y 4 de carácter no puede ser un guión

    2. Del mismo modo el número de puerto sólo puede estar en el rango de 1 a 65535. Esto es fácil de comprobar si extrae el puerto de parte y convertir a int, pero muy difícil de verificar con una expresión regular.

    3. También no hay ninguna manera fácil de comprobar válido extensiones de dominio. Algunos países han los dominios de segundo nivel(tales como » co.reino unido’), o la extensión puede ser una larga palabra tal como».internacional’. Y los nuevos Tld se añaden regularmente. Este tipo de cosas sólo pueden comprobarse en contra de una lista codificada. (ver https://en.wikipedia.org/wiki/Top-level_domain)

    4. Entonces hay imán direcciones url, direcciones ftp etc. Todas estas tienen diferentes requisitos.

    Sin embargo, aquí es una función que se encarga de casi todo, excepto:

    • Caso 1. c
    • Acepta cualquier 1-5 dígitos del número de puerto
    • Acepta cualquier extensión 2-13 chars
    • No acepta ftp, imanes, etc…

    JS:

    function isValidURL(input) {
    pattern = '^(https?:\\/\\/)?' + //protocol
    '((([a-zA-Z\\d]([a-zA-Z\\d-]{0,61}[a-zA-Z\\d])*\\.)+' + //sub-domain + domain name
    '[a-zA-Z]{2,13})' + //extension
    '|((\\d{1,3}\\.){3}\\d{1,3})' + //OR ip (v4) address
    '|localhost)' + //OR localhost
    '(\\:\\d{1,5})?' + //port
    '(\\/[a-zA-Z\\&\\d%_.~+-:@]*)*' + //path
    '(\\?[a-zA-Z\\&\\d%_.,~+-:@=;&]*)?' + //query string
    '(\\#[-a-zA-Z&\\d_]*)?$'; //fragment locator
    regex = new RegExp(pattern);
    return regex.test(input);
    }
    let tests = [];
    tests.push(['', false]);
    tests.push(['http://en.wikipedia.org/wiki/Procter_&_Gamble', true]);
    tests.push(['https://sdfasd', false]);
    tests.push(['http://www.google.com/url?sa=i&rct=j&q=&esrc=s&source=images&cd=&docid=nIv5rk2GyP3hXM&tbnid=isiOkMe3nCtexM:&ved=0CAUQjRw&url=http%3A%2F%2Fanimalcrossing.wikia.com%2Fwiki%2FLion&ei=ygZXU_2fGKbMsQTf4YLgAQ&bvm=bv.65177938,d.aWc&psig=AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g&ust=1398298682009707', true]);
    tests.push(['https://stackoverflow.com/', true]);
    tests.push(['https://w', false]);
    tests.push(['aaa', false]);
    tests.push(['aaaa', false]);
    tests.push(['oh.my', true]);
    tests.push(['dfdsfdsfdfdsfsdfs', false]);
    tests.push(['google.co.uk', true]);
    tests.push(['test-domain.MUSEUM', true]);
    tests.push(['-hyphen-start.gov.tr', false]);
    tests.push(['hyphen-end-.com', false]);
    tests.push(['https://sdfasdp.international', true]);
    tests.push(['https://sdfasdp.pppppppp', false]);
    tests.push(['https://sdfasdp.ppppppppppppppppppp', false]);
    tests.push(['https://sdfasd', false]);
    tests.push(['https://sub1.1234.sub3.sub4.sub5.co.uk/?', true]);
    tests.push(['http://www.google-com.123', false]);
    tests.push(['http://my--testdomain.com', false]);
    tests.push(['http://my2nd--testdomain.com', true]);
    tests.push(['http://thingiverse.com/download:1894343', true]);
    tests.push(['https://medium.com/@techytimo', true]);
    tests.push(['http://localhost', true]);
    tests.push(['localhost', true]);
    tests.push(['localhost:8080', true]);
    tests.push(['localhost:65536', true]);
    tests.push(['localhost:80000', false]);
    tests.push(['magnet:?xt=urn:btih:123', true]);
    for (let i = 0; i < tests.length; i++) {
    console.log('Test #' + i + (isValidURL(tests[i][0]) == tests[i][1] ? ' passed' : ' failed') + ' on ["' + tests[i][0] + '", ' + tests[i][1] + ']');
    }

  15. 1

    La pregunta se le pide a un método de validación para una url como stackoverflow, sin protocolo o de cualquier punto en el nombre de host. Así, no es una cuestión de la validación de sintaxis url, pero la comprobación de si es una url válida, por el hecho de llamarlo.

    He intentado varios métodos para saber si la dirección url de verdad existe y se puede llamar desde dentro del navegador, pero no se encontró ningún modo a prueba con javascript en la cabecera de respuesta de la llamada:

    • la adición de un elemento delimitador es buena para la cocción de la click() método.
    • hacer llamadas ajax a la difícil url con 'GET' está bien, pero tiene varias limitaciones debido a CORS políticas y no es el caso de la utilización de ajax, para que la url tal vez fuera de mi dominio del servidor.
    • el uso de la captura de la API tiene una solución similar a ajax.
    • otro problema es que tengo mi servidor en https protocolo y lanza una excepción cuando se llama a no seguros url.

    Así, la mejor solución que se me ocurre es conseguir alguna herramienta para realizar CURL con javascript intentar algo como curl -I <url>. Lamentablemente no encontré ninguna y en apariencia no es posible. Agradezco cualquier comentario sobre este.

    Pero, al final, tengo un servidor que ejecuta PHP y como puedo usar Ajax para casi todas mis peticiones, me escribió una función en el lado del servidor para realizar el curl de solicitud de allí y volver al navegador.

    Con respecto a la palabra única url sobre la pregunta de stackoverflow’ que me va a llevar a https://daniserver.com.ar/stackoverflow, donde daniserver.com.la ar es mi propio dominio.

    • El OP probablemente se han indicado más de lo que su intención fue. El problema, ciertamente, varía de acuerdo a sus necesidades y si es más importante para descartar falsos positivos o incluir falsos negativos. Como el problema se declaró no parece haber ninguna respuesta para mí. ¿Puede realmente tomar foo y asumir que es http o https o .com o .es o cualquiera de los innumerables sufijos? ¿Te sigue tirando el fregadero de la cocina hasta llegar a una verdadera?
  16. 1

    En mi caso mi único requisito es que la entrada del usuario, no debe interpretarse como un vínculo relativo cuando se coloca en el href de una etiqueta y las respuestas fueron un poco OTT para que o permitido Url no encuentro a mis necesidades, así que esto es lo que voy con todo:

    ^https?://.+$

    Lo mismo podría lograrse con bastante facilidad sin regex.

  17. 1

    esta trabajando conmigo

    function isURL(str) {
    var regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
    var pattern = new RegExp(regex); 
    return pattern.test(str);
    }
    • Esta respuesta ya fue dada de arriba hace 4 años por kavitha Reddy.
  18. 1

    Si se puede cambiar el tipo de entrada, creo que esta solución sería mucho más fácil:

    Usted simplemente puede utilizar type="url" en su entrada y la verificación con checkValidity() en js

    E. g:

    your.html

    <input id="foo" type="url">

    your.js

    //The selector is JQuery, but the function is plain JS
    $("#foo").on("keyup", function() {
    if (this.checkValidity()) {
    //The url is valid
    } else {
    //The url is invalid
    }
    });
  19. 0

    Creo que el uso de los nativos URL DE LA API es mejor que un complejo de patrones de regex como @pavlo sugerido. Tiene algunos inconvenientes, a pesar de que podemos arreglar por algún código extra. Este enfoque falla de la siguiente dirección url válida.

    //cdn.google.com/script.js

    Podemos agregar la falta de protocolo de antemano para evitar que. También falla para detectar siguiente dirección url no válida.

    http://w
    http://..

    Así que ¿por qué compruebe la dirección url completa? podemos comprobar el dominio. He tomado prestada la expresión regular para comprobar el dominio de aquí.

    function isValidUrl(string) {
    if (string && string.length > 1 && string.slice(0, 2) == '//') {
    string = 'http:' + string; //dummy protocol so that URL works
    }
    try {
    var url = new URL(string);
    return url.hostname && url.hostname.match(/^([a-z0-9])(([a-z0-9-]{1,61})?[a-z0-9]{1})?(\.[a-z0-9](([a-z0-9-]{1,61})?[a-z0-9]{1})?)?(\.[a-zA-Z]{2,4})+$/) ? true : false;
    } catch (_) {
    return false;
    }
    }

    La hostname atributo es una cadena vacía para javascript:void(0), por lo que funciona para que también, y usted puede también agregar la dirección IP verificador demasiado. Me gustaría que se adhieren a la API nativa de la mayoría, y esperamos que empiece a apoyar todo lo que en un futuro cercano.

    • Muy interesante, pero todavía tiene que trabajar en el regex como es introducido los falsos negativos que new URL no tiene en las pruebas que he hecho. Esto es llamado: http://142.42.1.1 //false y el bloqueo de alta cadenas unicode.
  20. 0

    Este parece ser uno de los problemas más difíciles en el CS 😉

    Aquí otra solución incompleta que funciona bastante bien para mí y mejor que los otros que he visto aquí. Estoy usando un input[type=url] para este fin de apoyar IE11, de lo contrario sería mucho más simple usando la ventana.URL para realizar la validación lugar:

    JS:

    const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
    function isValidIpv4(ip) {
    if (!ipv4Regex.test(ip)) return false;
    return !ip.split('.').find(n => n > 255);
    }
    const domainRegex = /(?:[a-z0-9-]{1,63}\.){1,125}[a-z]{2,63}$/i;
    function isValidDomain(domain) {
    return isValidIpv4(domain) || domainRegex.test(domain);
    }
    let input;
    function validateUrl(url) {
    if (! /^https?:\/\//.test(url)) url = `http://${url}`; //assuming Babel is used
    //to support IE11 we'll resort to input[type=url] instead of window.URL:
    //try { return isValidDomain(new URL(url).host) && url; } catch(e) { return false; }
    if (!input) { input = document.createElement('input'); input.type = 'url'; }
    input.value = url;
    if (! input.validity.valid) return false;
    const domain = url.split(/^https?:\/\//)[1].split('/')[0].split('@').pop();
    return isValidDomain(domain) && url;
    }
    console.log(validateUrl('google'), //false
    validateUrl('user:[email protected]'),
    validateUrl('https://google.com'),
    validateUrl('100.100.100.100/abc'),
    validateUrl('100.100.100.256/abc')); //false

    Para aceptar incompleta de los insumos, tales como «www.mydomain.com» también hará válida suponiendo que el protocolo es «http» en esos casos y el regreso de la dirección URL válida si la dirección es válida. Devuelve false cuando no válido.

    También es compatible con IPv4 dominios, pero no IPv6.

  21. 0

    Aquí tienes una muy sencilla comprobación para asegurarse de que no hay un protocolo válido, y la extensión de dominio debe ser de dos o más caracteres.

    is_valid_url = ( $url ) => {
    let $url_object = null;
    try {
    $url_object = new URL( $url );
    } catch ( $error ) {
    return false;
    }
    const $protocol = $url_object.protocol;
    const $protocol_position = $url.lastIndexOf( $protocol );
    const $domain_extension_position = $url.lastIndexOf( '.' );
    return (
    $protocol_position === 0 &&
    [ 'http:', 'https:' ].indexOf( $protocol ) !== - 1 &&
    $domain_extension_position > 2 && $url.length - $domain_extension_position > 2
    );
    };
  22. 0

    Uso validator.js

    ES6

    import isURL from 'validator/lib/isURL'
    isURL(string)

    No ES6

    var validator = require('validator');
    validator.isURL(string)

    También puede ajustar esta función del comportamiento pasando opcional options objeto como el segundo argumento de isURL

    Aquí es el predeterminado options objeto:

    let options = {
    protocols: [
    'http',
    'https',
    'ftp'
    ],
    require_tld: true,
    require_protocol: false,
    require_host: true,
    require_valid_protocol: true,
    allow_underscores: false,
    host_whitelist: false,
    host_blacklist: false,
    allow_trailing_dot: false,
    allow_protocol_relative_urls: false,
    disallow_auth: false
    }
    isURL(string, options)

    host_whitelist y host_blacklist pueden ser matrices de los ejércitos. También el soporte de expresiones regulares.

    let options = {
    host_blacklist: ['foo.com', 'bar.com'],
    }
    isURL('http://foobar.com', options) //=> true
    isURL('http://foo.bar.com/', options) //=> true
    isURL('http://qux.com', options) //=> true
    isURL('http://bar.com/', options) //=> false
    isURL('http://foo.com/', options) //=> false
    options = {
    host_blacklist: ['bar.com', 'foo.com', /\.foo\.com$/],
    }
    isURL('http://foobar.com', options) //=> true
    isURL('http://foo.bar.com/', options) //=> true
    isURL('http://qux.com', options) //=> true
    isURL('http://bar.com/', options) //=> false
    isURL('http://foo.com/', options) //=> false
    isURL('http://images.foo.com/', options) //=> false
    isURL('http://cdn.foo.com/', options) //=> false
    isURL('http://a.b.c.foo.com/', options) //=> false
  23. 0

    Este es definitivamente no es el enfoque más efectivo, pero es legible y fácil forma a lo que usted necesita. Y es más fácil agregar regex/complejidad de aquí. Así que aquí es un enfoque muy pragmático

    const validFirstBits = ["ftp://", "http://", "https://", "www."];
    const invalidPatterns = [" ", "//.", ".."];
    export function isUrl(word) {
    //less than www.1.dk
    if (!word || word.length < 8) return false;
    //Let's check and see, if our candidate starts with some of our valid first bits
    const firstBitIsValid = validFirstBits.some(bit => word.indexOf(bit) === 0);
    if (!firstBitIsValid) return false;
    const hasInvalidPatterns = invalidPatterns.some(
    pattern => word.indexOf(pattern) !== -1,
    );
    if (hasInvalidPatterns) return false;
    const dotSplit = word.split(".");
    if (dotSplit.length > 1) {
    const lastBit = dotSplit.pop(); //string or undefined
    if (!lastBit) return false;
    const length = lastBit.length;
    const lastBitIsValid =
    length > 1 || (length === 1 && !isNaN(parseInt(lastBit)));
    return !!lastBitIsValid;
    }
    return false;
    }

    PRUEBA:

    import { isUrl } from "./foo";
    describe("Foo", () => {
    test("should validate correct urls correctly", function() {
    const validUrls = [
    "http://example.com",
    "http://example.com/blah",
    "http://127.0.0.1",
    "http://127.0.0.1/wow",
    "https://example.com",
    "https://example.com/blah",
    "https://127.0.0.1:1234",
    "ftp://example.com",
    "ftp://example.com/blah",
    "ftp://127.0.0.1",
    "www.example.com",
    "www.example.com/blah",
    ];
    validUrls.forEach(url => {
    expect(isUrl(url) && url).toEqual(url);
    });
    });
    test("should validate invalid urls correctly", function() {
    const inValidUrls = [
    "http://foo.com",
    "http:/foo.com",
    "http://.foo.com",
    "http://foo..com",
    "http://.com",
    "http://foo",
    "http://foo.c",
    ];
    inValidUrls.forEach(url => {
    expect(!isUrl(url) && url).toEqual(url);
    });
    });
    });

Dejar respuesta

Please enter your comment!
Please enter your name here