N.º 252 — Cadena de consulta — Solución comentada

Cadena de consulta

Implementa ParseQuery<S> para que convierta una cadena de consulta como "a=1&b=2" en { a: "1"; b: "2" }. Una cadena vacía produce {}. El resultado debe ser un objeto plano; Flatten viene dado.

Intenta el puzle tú mismo

Par 5

Puzle

parse-query.ts

type Flatten<T> = { [K in keyof T]: T[K] }

type ParseQuery<S extends string> = ???

type ParseQuery<S extends string> = ???

Intento 1 de 5Aún sin comprobar

Sustituye ??? — tu solución se comprueba con los casos de abajo. Tab indenta; pulsa Escape y luego Tab para sacar el foco.

Comprobaciones

ParseQuery<'a=1&b=2'>—
→ { a: '1'; b: '2' }
ParseQuery<'x=9'>—
→ { x: '9' }
ParseQuery<''>—
→ {}
ParseQuery<'a=1&b=2&c=3'>—
→ { a: '1'; b: '2'; c: '3' }

Cómo se juzga una comprobación Igualdad exacta de tipos, no asignabilidad — una intersección no es lo mismo que el objeto aplanado.

Cómo le fue a todo el mundo

Menos de 5 personas han resuelto este puzle hasta ahora. La distribución aparece cuando la muestra sea lo bastante grande como para significar algo.

Juego corto

Menos caracteres

Aún no hay marcas públicas.

Archivo

Solución comentada

Publicado el 5 de septiembre de 2026

La solución

type ParseQuery<S extends string> =
  S extends `${infer K}=${infer V}&${infer Rest}`
    ? Flatten<{ [P in K]: V } & ParseQuery<Rest>>
    : S extends `${infer K}=${infer V}`
      ? { [P in K]: V }
      : {}

El error más común

type ParseQuery<S extends string> =
  S extends `${infer K}=${infer V}&${infer Rest}`
    ? { [P in K]: V } & ParseQuery<Rest>
    : S extends `${infer K}=${infer V}`
      ? { [P in K]: V }
      : {}

El análisis es del todo correcto; el ensamblaje no. Cada paso recursivo aporta otro &, así que tres pares producen { a: "1" } & { b: "2" } & { c: "3" } — una cadena de tres objetos que se comporta como el que la comprobación pide, pero que no lo es. La recursión que construye objetos casi siempre necesita aplanarse al final.

Línea por línea

`${infer K}=${infer V}&${infer Rest}`
La inferencia en literales de plantilla empareja desde la izquierda y toma la coincidencia más corta, así que K es "a", V es "1" y todo lo que sigue al primer & pasa a Rest. Un par por paso.
{ [P in K]: V }
K llega como un tipo literal de cadena, que es un conjunto de claves perfectamente válido para un tipo mapeado de un solo miembro. Así un nombre analizado se convierte en una propiedad real.
Flatten<... & ParseQuery<Rest>>
Aplanar en cada paso, y no solo al final, evita que la intersección se haga profunda, y el resultado de cada paso ya tiene la forma que el siguiente espera.

Para recordar

Analizar una cadena a nivel de tipos son tres preguntas: ¿hay separador?, ¿es un último elemento suelto?, ¿o está vacía? Pon esas tres ramas en el orden correcto y la recursión se escribe sola.