Cómo obtener la URL de la imagen de HTML string usando expresiones regulares

Te damos la bienvenida a nuestro sitio web, aquí vas a hallar la solucíon de lo que buscabas.

Solución:

Descripción

=]|='[^']*'|="[^"]*"|=[^'"][^s>]*)*?ssrc=['"]([^"]*)['"]?)(?:[^>=]|='[^']*'|="[^"]*"|=[^'"s]*)*"s?/?> 

Esta expresión regular hará lo siguiente:

• Esta expresión regular captura toda la etiqueta IMG
• Coloca la fuente attribute valor en el grupo de captura 1, sin comillas si existen.
• Permitir attributes tener comillas simples, dobles o sin comillas
• Puede modificarse para validar cualquier número de otros attributes
• Evite casos extremos difíciles que tienden a dificultar el análisis de HTML

Ejemplo

Demo en vivo

https://regex101.com/r/qW9nG8/1

Texto de ejemplo

Tenga en cuenta el caso de borde difícil en la primera línea donde estamos buscando un droide específico.

some text


more text

Partidos de muestra

• El grupo de captura 0 obtiene la etiqueta IMG completa
• El grupo de captura 1 obtiene solo el src attribute valor

[0][0] = 
[0][1] = http://website/ThisIsTheDroidYourLookingFor.jpeg

[1][0] = 
[1][1] = http://website/someurl.jpeg

[2][0] = 
[2][1] = https://en.wikipedia.org/wiki/File:BH_LMC.png

Explicación

NODE                     EXPLANATION
----------------------------------------------------------------------
  =]                    any character except: '>', '='
----------------------------------------------------------------------
     |                        OR
----------------------------------------------------------------------
      ='                       '=''
----------------------------------------------------------------------
      [^']*                    any character except: ''' (0 or more
                               times (matching the most amount
                               possible))
----------------------------------------------------------------------
      '                        '''
----------------------------------------------------------------------
     |                        OR
----------------------------------------------------------------------
      ="                       '="'
----------------------------------------------------------------------
      [^"]*                    any character except: '"' (0 or more
                               times (matching the most amount
                               possible))
----------------------------------------------------------------------
      "                        '"'
----------------------------------------------------------------------
     |                        OR
----------------------------------------------------------------------
      =                        '='
----------------------------------------------------------------------
      [^'"]                    any character except: ''', '"'
----------------------------------------------------------------------
      [^s>]*                  any character except: whitespace (n,
                               r, t, f, and " "), '>' (0 or more
                               times (matching the most amount
                               possible))
----------------------------------------------------------------------
    )*?                      end of grouping
----------------------------------------------------------------------
    s                       whitespace (n, r, t, f, and " ")
----------------------------------------------------------------------
    src=                     'src='
----------------------------------------------------------------------
    ['"]                     any character of: ''', '"'
----------------------------------------------------------------------
    (                        group and capture to 1:
----------------------------------------------------------------------
      [^"]*                    any character except: '"' (0 or more
                               times (matching the most amount
                               possible))
----------------------------------------------------------------------
    )                        end of 1
----------------------------------------------------------------------
    ['"]?                    any character of: ''', '"' (optional
                             (matching the most amount possible))
----------------------------------------------------------------------
  )                        end of look-ahead
----------------------------------------------------------------------
  (?:                      group, but do not capture (0 or more times
                           (matching the most amount possible)):
----------------------------------------------------------------------
    [^>=]                    any character except: '>', '='
----------------------------------------------------------------------
   |                        OR
----------------------------------------------------------------------
    ='                       '=''
----------------------------------------------------------------------
    [^']*                    any character except: ''' (0 or more
                             times (matching the most amount
                             possible))
----------------------------------------------------------------------
    '                        '''
----------------------------------------------------------------------
   |                        OR
----------------------------------------------------------------------
    ="                       '="'
----------------------------------------------------------------------
    [^"]*                    any character except: '"' (0 or more
                             times (matching the most amount
                             possible))
----------------------------------------------------------------------
    "                        '"'
----------------------------------------------------------------------
   |                        OR
----------------------------------------------------------------------
    =                        '='
----------------------------------------------------------------------
    [^'"s]*                 any character except: ''', '"',
                             whitespace (n, r, t, f, and " ") (0
                             or more times (matching the most amount
                             possible))
----------------------------------------------------------------------
  )*                       end of grouping
----------------------------------------------------------------------
  "                        '"'
----------------------------------------------------------------------
  s?                      whitespace (n, r, t, f, and " ")
                           (optional (matching the most amount
                           possible))
----------------------------------------------------------------------
  /?                      '/' (optional (matching the most amount
                           possible))
----------------------------------------------------------------------
  >                        '>'
----------------------------------------------------------------------

Este es el patrón de expresiones regulares que debe usar:

(http[^s]+ (jpg | jpeg | png | tiff) b)

Traducción:

• Encuentre todo lo que comience con “http”
• No se permiten espacios en blanco
• Termina con uno de los siguientes jpg, jpeg, png, tiff

Función regex:

func matches(for regex: String!, in text: String!) -> [String]     
    do 
        let regex = try RegularExpression(pattern: regex, options: [])
        let nsString = text as NSString
        let results = regex.matches(in: text, range: NSMakeRange(0, nsString.length))
        return results.map  nsString.substring(with: $0.range)
     catch let error as NSError 
        print("invalid regex: (error.localizedDescription)")
        return []
    

Uso:

var matched = matches(for: "(http[^\s]+(jpg|jpeg|png|tiff)\b)", in: String(htmlStr))

Nota:

• emparejado regresa como un array con emparejamiento string objetos
• Este código fue escrito para Swift 3

Solo un pequeño ajuste al patrón me da esto:

let string = "some text and other text ;and then more text and more text"

let matches = string.regex("]+src*=".*?"['/']>")

devuelve un array con el fósforo.

Reseñas y valoraciones

Tienes la opción de añadir valor a nuestro contenido informacional tributando tu veteranía en las anotaciones.

---

---

Utiliza Nuestro Buscador