Analyseur de query string
name=Ada&city=New%20York&q=hello+world se découpe en trois paires : name Ada, city New York et q hello world. Analysez une query string en noms et valeurs ordonnés, ou construisez-en une bien encodée à partir de vos paires. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Les query strings d'une URL transportent filtres, balises de campagne, pagination et champs de formulaire après le point d'interrogation d'une adresse. Les lire à la main est source d'erreurs : les espaces peuvent apparaître comme des signes plus ou comme percent-twenty, les esperluettes séparent les champs, l'égal sépare les noms des valeurs, et un échappement pourcent mal formé peut corrompre toute une ligne de journal. Cet analyseur de query string convertit dans les deux sens avec un seul contrat. Le mode parse accepte une requête brute (avec ou sans point d'interrogation initial), décode chaque clé et valeur, et renvoie une liste ordonnée de paires plus une carte d'objet simple pour les clés uniques. Le mode serialize accepte les mêmes paires ou une carte d'objet plat et émet une query string correctement encodée en pourcent, prête à coller après un chemin.
Comment les query strings encodent les paires clé-valeur
Un fragment de requête typique ressemble à name equals Ada ampersand city equals New percent-twenty York. L'esperluette est le séparateur de champs ; le premier égal de chaque champ sépare le nom du paramètre de sa valeur. Les valeurs (et parfois les noms) sont encodées en pourcent pour que espaces, esperluettes, lettres non ASCII et caractères réservés survivent au transit par navigateurs, proxies et outils d'analytique.
De nombreux serveurs traitent aussi un plus nu comme un espace selon les règles application/x-www-form-urlencoded des formulaires HTML ; cette capacité le fait par défaut à l'analyse, et vous pouvez le désactiver si vous avez besoin d'un plus littéral. Les champs vides issus d'esperluettes finales ou doublées sont ignorés afin de ne pas inventer de clés fantômes vides. Un paramètre sans signe égal est traité comme une clé avec valeur chaîne vide, comme dans les bibliothèques serveur courantes.
Lorsque la même clé apparaît plusieurs fois, chaque occurrence est conservée dans la liste ordonnée de paires pour ne pas perdre les filtres multi-sélection ni les balises répétées ; la carte d'objet compagnon utilise last-wins pour que les clients simples obtiennent encore un dictionnaire plat. L'encodage utilise encodeURIComponent sur chaque clé et valeur pour que les séparateurs réservés ne fuient jamais dans la chaîne assemblée.
Où un analyseur de query string gagne sa place
Les services backend qui journalisent les requêtes entrantes ont besoin d'un moyen fiable de transformer la partie recherche d'une URL en champs structurés pour les métriques et le support, sans écrire un découpeur improvisé qui gère mal les signes plus ou l'Unicode. Les applications frontend qui reconstruisent des puces de filtre à partir du search de l'emplacement actuel ont besoin de paires ordonnées pour que les facettes multi-valeurs survivent à un aller-retour encode et decode.
Les pipelines QA et CI comparent des vecteurs de requête de référence entre Node et navigateurs pour qu'un espace soit toujours percent-twenty à l'encodage et qu'un plus en entrée style formulaire devienne encore un espace à l'analyse. Les équipes de support collent des liens à demi encodés depuis des tickets et ont besoin d'un décodeur qui échoue clairement sur les escapes tronqués au lieu d'inventer des caractères.
Les auteurs de cursus qui enseignent les fondations du web veulent une page dédiée à la lecture et l'écriture des paramètres de requête plutôt que d'enterrer le sujet sous un encodeur pourcent générique ou un constructeur UTM, car l'intention de recherche diffère : qui cherche un analyseur de query string veut de la structure, pas seulement de l'échappement de caractères. Une validation échouée ne consomme pas le solde.
Gardez les requêtes sous les limites de longueur documentées, figez les paires ordonnées dans les tests, et vous obtiendrez des cartes de paramètres reproductibles pour tableaux de bord, plugins LMS et workers de bord sans monter votre propre boîte à outils URL complète.
Cas d’usage
Construire des query strings sortantes sûres
Sérialisez filtres, balises et champs de formulaire en une query string correctement encodée en pourcent afin que les caractères réservés n'inventent jamais de paramètres supplémentaires.
Questions fréquentes
Comment analyser une query string d'URL en paires clé-valeur ?
Mettez mode à parse (ou omettez-le) et envoyez text avec le fragment de requête, avec ou sans ?
Comment sérialiser des paires en query string ?
La réponse inclut encoded (et query) avec chaque nom et valeur encodés en pourcent et joints par &.
Que se passe-t-il si une séquence pourcent est mal formée ?
Les échecs de validation ne sont pas facturés.
Le signe plus est-il lu comme une espace ?
Oui, par défaut, car les formulaires web envoient les espaces sous forme de signes plus : hello+world devient hello world. Vous pouvez désactiver ce comportement lorsqu'un plus doit rester littéral.
Que se passe-t-il quand le même nom apparaît deux fois ?
Toutes les occurrences sont gardées, dans l'ordre, pour ne perdre ni filtres à choix multiples ni étiquettes répétées. La vue simple nom-valeur ne garde que la dernière valeur de chaque nom.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/enc/query-string \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mode":"parse","op":"parse"}'const res = await fetch("https://api.kit.forhosting.com/enc/query-string", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mode": "parse",
"op": "parse"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/query-string",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mode": "parse",
"op": "parse"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/query-string", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mode":"parse","op":"parse"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mode":"parse","op":"parse"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/query-string", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"mode": "parse",
"op": "parse"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.query_string",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Les séquences pourcent mal formées échouent avec invalid_input au lieu d'un demi-résultat corrompu.
Comment les query strings encodent les paires clé-valeur
Le décodage valide chaque séquence pourcent avant le décodage hôte : un pourcent final isolé ou des chiffres non hexadécimaux après un pourcent lèvent invalid_input avec un message conscient de la position. Le chemin est un travail pur de chaînes sans réseau, sans graines aléatoires et sans horodatages d'horloge, de sorte que des entrées identiques produisent toujours le même JSON. Le tarif API des appels réussis est la base publiée de $0.002 par élément, et les échecs de validation ne consomment pas le solde prépayé.
Contrat d'entrée, forme de réponse et comportement d'erreur
Les échecs de validation ne consomment pas le solde prépayé. Les contrôles classiques incluent l'analyse de name equals Ada ampersand city equals New percent-twenty York, la sérialisation de paires avec espaces et esperluettes, et le rejet d'une valeur qui se termine par un pourcent nu. Envoyez un corps JSON avec mode à parse ou serialize. Pour parse, fournissez text (alias query, query_string, qs) contenant le fragment de requête. Un point d'interrogation initial optionnel est retiré ; un fragment de hachage après la requête est ignoré pour que coller une recherche complète du navigateur fonctionne encore. plus_as_space optionnel vaut true par défaut pour la conversion plus-vers-espace form-urlencoded. En succès, parse renvoie mode, plus_as_space, le text d'origine, une vue query normalisée, pairs comme tableau de chaînes key et value dans l'ordre, object comme carte last-wins des clés uniques, count comme nombre de paires, et encoded comme chaîne re-sérialisée à partir de ces paires pour comparer les allers-retours. Pour serialize, fournissez pairs comme tableau d'objets avec champs key et value ou comme carte d'objet plat. En succès, serialize renvoie mode, plus_as_space, les pairs normalisées, object, count, encoded et query (la même chaîne encodée sans point d'interrogation initial). Texte manquant en mode parse, pairs manquants en mode serialize, valeurs de mode non prises en charge, objets imbriqués dans une carte, chaînes trop longues et séquences pourcent mal formées échouent avec invalid_input et un message clair en anglais. Le tarif API en succès est la base publiée de $0.002 par élément.
Où un analyseur de query string gagne sa place
Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.
Cas d'intégration
Inspecter les paramètres d'URL entrants
Analysez les query strings des requêtes en paires clé-valeur ordonnées pour journaux, support et analytique sans maltraiter les signes plus ni les escapes pourcent.
Tests aller-retour et fixtures
Générez des vecteurs de référence parse et serialize pour la CI afin que les clés multi-valeurs et les valeurs Unicode restent stables entre runtimes.
Questions techniques
Les signes plus sont-ils traités comme des espaces ?
Oui par défaut à l'analyse (application/x-www-form-urlencoded). Mettez plus_as_space à false si vous devez conserver le + littéral avant le décodage pourcent.
Que coûte l'analyseur de query string ?
L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; l'entrée invalide n'est pas facturée.