No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Expresiones Regulares

Curso de Expresiones Regulares

Alberto Alcocer (Beco)

Alberto Alcocer (Beco)

Uso de REGEX para descomponer querys GET

20/29
Recursos

Al hacer consultas a sitios web mediante el método GET se envían todas las variables al servidor a través de la misma URL.

La parte de esta url que viene luego del signo de interrogación ? se le llama query del request que es: variable1=valor1&variable2=valor2&... y así tantas veces como se necesite. En esta clase veremos como extraer estas variables usando expresiones regulares.

Aportes 46

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Para aquellos que usan un editor como Visual Studio Code al querer hacer una nueva línea en el replace debemos colocar el salto de línea: \n

Find: [\?&](\w+)=([^&\n]+)
Replace: \n - $1=$2

APUNTES DE BECO: Al hacer consultas a sitios web mediante el método GET se envían todas las variables al servidor a través de la misma URL.

La parte de esta url que viene luego del signo de interrogación ? se le llama query del request que es: variable1=valor1&variable2=valor2&… y así tantas veces como se necesite.

Creo que esta clase sintetiza todo el poder de las regex, desde la elaboración una expresión optimizada hasta la realización de un reemplazo funcional y aplicable a situaciones del día a día de un dessarrollador

No te creas tanto Alberto… Algunos somos muy friki… 🤓

Qué buen outfit

[\?&](\w+)=([^&\n]+)
Esta es la clase más completa y funcional hasta el momento

17. Mis apuntes sobre: “Uso de REGEX para descomponer querys GET”

Ejemplo de la clase:

[\?&](\w+)=([^&\n]+)

Otra forma de reemplazarlo

Find:

[\?&](\w+)=([^&\n]+)

Replace:

\n {variable:"$1", value:"$2"},

^?&=([^&\n]+) muy genial todo lo que se puede hacer con REGEX

[\?&](\w+)=([^&\n]+)

Como romper un query en cada una de sus variables

Con expresiones regulares se puede obtener una url con un método GET de http y despedazarlo entre cada variable y su valor. Esto se puede hacer mediante separar por agrupaciones la expresión y luego reemplazar todos los matches. La expresión regular puede ser esta: [\?&](\w+)=([^&]+)

Para obtener los queries de las urls: [\?&](\w+)=([^&\n]+) y podemos descomponerlas con: \n $1 => $2

Esta parte no la entendí

([^&\n]+)

Creo que lo único que le falta a este curso es un ejemplo de aplicación no solo usando Python, Java, Pearl o PHP sí no también hacerlo correr en PostgreSQL o MySQL por ejemplo. Se que hay formas de hacerlo y sería muy útil a la hora de construir consultas!!

Como analista de datos que soy, combinar la extrema potencia de RegEx con consultas SQL sería ideal.

Buen dia, les comparto mis notas(presiona Ctrl +Shift + L para el modo oscuro), espero que te sea util:
https://languid-spring-631.notion.site/Expresiones-Regulares-c6a8bef1cdec4f03a854164724ffee9f

Excelente

Qué buena clase de REGEX.
Felicitaciones.

[\?&]([A-z0-9]+)=([^&^\s]+)
Muy buena clase

A mi en atom me funciono remplazarlo asi:

\n\t- $1 => $2```
<h3>Respuesta usando expresiones regulares en Google Sheets</h3>

Dejo aquí una expresión regular que me ha valido para la descomposición de la URL de una búsqueda avanzada de Google
intitle:covid|coronavirus after:2019 ext:pdf site:who.int

Esta desarrollada con la función de sustitución (regexreplace) que sustituye (\w+)(:|=)(\w+) por CARACTER(10)&" - $1=$3"
CARACTER(10) es el salto de línea

=REGEXREPLACE("https://www.google.es/search?q=estrategia intitle:covid|coronavirus after:2019 ext:pdf site:who.int";"(\w+)(:|=)(\w+)";CARACTER(10)&" - $1=$3")

El resultado
https://www.google.es/search?
– q=estrategia
– intitle=covid|coronavirus
– after=2019
– ext=pdf
– site=who.int

Para responses con content-type de
application/x-www-form-urlencoded;charset=utf-8

Podemos extraer su data con casi la misma Regex:

[&]?(\w+)=([^&]*)

Excelente clase, qué power el de REGEX.

https://rsd.com/Emp/all/?Buscar=buscar&Empleado=carlos&no=10&TelCasa=ewr44&Celular=49&Puesto=re&FechaIngreso=43&NumeroCuenta=43&NoSeguro=444&Empresa=e
// agrupamos
[\?&](\w+)=([^&\n]+)

aplicando un replace quedaria 
 - Buscar => buscar 
 - Empleado => carlos 
 - no => 10 
 - TelCasa => ewr44 
 - Celular => 49 
 - Puesto => re 
 - FechaIngreso => 43 
 - NumeroCuenta => 43 
 - NoSeguro => 444 
 - Empresa => e
### **EXPLICACIÓN DE LA EXPRESIÓN REGULAR** La expresión regular dada es: \[\\?&]\(\w+)=(\[^&\n]+) Vamos a desglosarla paso a paso: **\[\\?&]** → Esta parte coincide con un ? o un &. * El ? marca el inicio de la cadena de consulta en una URL. * El & separa los diferentes parámetros en la consulta. * Los corchetes \[] indican que coincidirá con cualquiera de los caracteres dentro de ellos. **(\w+)** → Esta parte captura el nombre de la variable (clave del parámetro). * \w+ coincide con uno o más (+) caracteres de palabra (\w), que incluyen letras (a-z, A-Z), números (0-9) y guiones bajos (\_). * Los paréntesis () crean un **grupo de captura**, lo que significa que esta parte se almacenará como **Grupo 1** ($1). **=** → Coincide con el signo igual (=) que separa el nombre de la variable de su valor. **(\[^&\n]+)** → Esta parte captura el valor de la variable. * \[^&\n] significa **"cualquier carácter excepto & o un salto de línea (\n)"**. * El + significa que coincide con **uno o más** de estos caracteres. * Los paréntesis () crean otro **grupo de captura**, lo que significa que esta parte se almacenará como **Grupo 2** ($2). ### **CÓMO FUNCIONA EL PROCESO DE EXTRACCIÓN** Usando **buscar y reemplazar**, aplicamos el patrón para extraer las variables de una URL. #### **EJEMPLO 1:** **URL:** http : //b3co.com/?s=photography\&mode=search\&module=blog **Primera coincidencia:** * ?s=photography * $1 = s, $2 = photography * Se reemplaza con: - s => photography **Segunda coincidencia:** * \&mode=search * $1 = mode, $2 = search * Se reemplaza con: - mode => search **Tercera coincidencia:** * \&module=blog * $1 = module, $2 = blog * Se reemplaza con: - module => blog **Salida Final:** http : //b3co.com/ \- s => photography \- mode => search \- module => blog #### **EJEMPLO 2:** **URL:** https : //www.google.com/search?q=regex+platzi\&oq=regex+platzi\&aqs=chrome..69157j69160.6885j0j9\&sourceid=chrome\&ie=UTF-8 **URL base extraída:** https : //www.google.com/search **Variables extraídas:** - q => regex+platzi \- oq => regex+platzi \- aqs => chrome..69157j69160.6885j0j9 \- sourceid => chrome \- ie => UTF-8 #### **EJEMPLO 3:** **URL:** https : //co.search.yahoo.com/search?p=flickr\&fr=yfp-t\&fp=1\&toggle=1\&cop=mss\&ei=UTF-8 **URL base extraída:** https : //co.search.yahoo.com/search**Variables extraídas:** - p => flickr \- fr => yfp-t \- fp => 1 \- toggle => 1 \- cop => mss \- ei => UTF-8
El uso de \*\*expresiones regulares (REGEX)\*\* para descomponer las \*\*queries GET\*\* de URLs es muy útil para extraer parámetros y valores clave, especialmente en la manipulación de datos web. Una query GET en una URL tiene la forma: ``` <https://example.com/page?param1=value1&param2=value2&param3=value3> ``` Aquí, todo lo que viene después del signo de interrogación (`?`) es la \*\*cadena de consulta\*\* o \*\*query string\*\*, con los parámetros clave y sus valores. \### Pasos para descomponer una query GET 1\. \*\*Identificar el patrón básico de la query\*\*: Las queries GET suelen estar formadas por pares de \*\*clave=valor\*\* separados por el carácter `&`. 2\. \*\*Uso de REGEX para extraer parámetros y valores\*\*: Un patrón REGEX típico para descomponer una query string es el siguiente: ```regex (\[\w%]+)=(\[\w%]+) ``` Donde: \- `\[\w%]+` busca una secuencia de caracteres alfanuméricos o el símbolo `%` (para valores codificados en URL). \- El símbolo `=` separa el parámetro de su valor. \- Este patrón se repite para cada par clave-valor. \### Descomposición en Python usando REGEX Veamos cómo se puede usar esta expresión regular en Python para descomponer una query string: \#### Ejemplo de Código Python ```python import re \# Query string de ejemplo query = "param1=value1\&param2=value2\&param3=value3" \# Expresión regular para extraer pares clave-valor pattern = r'(\[\w%]+)=(\[\w%]+)' \# Usar findall para encontrar todos los pares clave-valor matches = re.findall(pattern, query) \# Mostrar resultados for match in matches: print(f"Parámetro: {match\[0]}, Valor: {match\[1]}") ``` \#### Salida: ``` Parámetro: param1, Valor: value1 Parámetro: param2, Valor: value2 Parámetro: param3, Valor: value3 ``` \### Explicación: \- `re.findall()` busca todas las coincidencias del patrón en la query string y devuelve una lista de tuplas donde cada tupla contiene un par clave-valor. \- Este enfoque es simple y puede manejar queries con múltiples parámetros. \### Ampliaciones para casos más complejos 1\. \*\*Soporte para valores codificados en URL\*\*: Si los valores de la query string están codificados, pueden contener caracteres especiales como `%20` para espacios. En ese caso, deberías incluir `%` y caracteres hexadecimales en tu expresión regular. ```regex (\[\w%]+)=(\[\w%]+) ``` Esto captura valores que están codificados en URL. 2\. \*\*Opcionalidad de parámetros vacíos\*\*: A veces, los valores de los parámetros pueden estar vacíos, por ejemplo: ``` <https://example.com/page?param1=value1&param2=&param3=value3> ``` Para manejar este caso, puedes ajustar la regex para que permita valores vacíos: ```regex (\[\w%]+)=(\[\w%]\*) ``` El asterisco (`\*`) en la segunda parte del patrón permite que el valor esté vacío. \### Usar REGEX en otras herramientas \#### 1. \*\*Bash con `grep` o `sed`\*\* En bash, puedes usar `grep` o `sed` para hacer algo similar. Por ejemplo: ```bash echo "param1=value1\&param2=value2" | grep -oP '(\w+)=(\w+)' ``` \#### 2. \*\*Uso en JavaScript\*\* En JavaScript, puedes usar la función `match()` o `exec()` para aplicar la expresión regular: ```javascript const query = "param1=value1\&param2=value2\&param3=value3"; const regex = /(\[\w%]+)=(\[\w%]+)/g; let match; while ((match = regex.exec(query)) !== null) { console.log(`Parámetro: ${match\[1]}, Valor: ${match\[2]}`); } ``` \#### 3. \*\*Herramientas para analizar URLs completas\*\* Si quieres trabajar con URLs completas y no solo la query string, puedes usar el siguiente patrón: ```regex https?:\\/\\/\[\w.-]+\\/\[\w.-]\*\\?(\[\w%=&]+) ``` Esto separa la URL principal de la query string. \### Conclusión El uso de \*\*expresiones regulares\*\* es una herramienta poderosa para descomponer queries GET y extraer parámetros de una URL. Esta técnica es especialmente útil cuando trabajas con URLs complejas, análisis de logs o procesamiento web.
otra forma de separar los querys```js \??&?(\w+)=(\w+) ```
tamalito
Alguien sabe como hacer que también poner en una variable la url a parte de las queris del get. var1 <https://b3co.com/> var2 s var3 mode ..etc

publicidad pagada por adiddas

Super interesante esta clase!

Es increible la forma de aprender en romper queries usando expresiones regulares y a la vez usando el “Replace All” para comprobar su funcionamiento. Definitivamente, el profe es todo un capo. Espero seguir aprendiendo mas con este tipo de profesores.

uffff que genial!

[\?&](\w+)=([^&\n]+)

Casi se me explota la cabeza en esta clase

genial

Excelente.

Super aquí se ve todo el potencial de las expresiones regulares.

Estupenda clase instructor Alberto, esta utilidad nos vendrá bien cuando queramos organizar los elementos de las URLs que manejemos. Acá comparto unas de las más comunes:
   

?$=([^&\n]+).*

Para cuando parámetros de url vengan con o sin valor, que en ocasiones puede pasar

[\?&](\w+)=([^&\n]*)

Muchos conocimientos aprendidos con @Beco, lo de las expresiones regulares ya no me hara correr ni tener pesadillas, muchas gracias.

?&=([^&\n]+) no entendí esta aparte ,como se puede se parar la variable para poder utilizarlo


Yo le agregué un poco más de sabor a la expresión regular para tomar en cuenta el -, ya que es muy común separar los queryParams por _ ó -
.
Ejemplo
.
https://www.instagram.com/p/BXB4zsUlW5Z/?taken-by=beco.mx&s_photo=fotografia&mode=search&module=blog
.
.
Find

[\?&]([\w-]+)=([^&\n]+)

.
Replace

\n - $1 => $2