Visionneuse JSON Bash — jless & JQ_COLORS

Quand vous avez besoin d'un visualiseur JSON en bashpour l'exploration interactive plutôt que pour les scripts, le pipe standard jq .montre ses limites — la sortie défile au-delà du haut du terminal et vous n'avez aucun moyen de revenir en arrière dans une réponse API de 300 lignes. Ce guide couvre les outils conçus spécifiquement pour visualiser du JSON interactivement dans le terminal : jless (arbre réductible avec navigation style vim), JQ_COLORS pour les thèmes de couleurs personnalisés, jq -C | less -Rpour la pagination colorée, les alias shell pour l'usage quotidien, et fx comme alternative basée sur Node.js. Pour les scripts, CI/CD et les flux de validation, consultez le guide complémentaire Formater du JSON en Bash. Pour un visualiseur dans le navigateur sans installation, l'outil Embellisseur JSON fonctionne instantanément. Les exemples sont testés sur Bash 5.x (macOS via Homebrew, Ubuntu 22.04+) et sont compatibles avec Bash 3.2+ (shell système macOS).

Visualisation JSON Interactive vs. Scriptée

Rediriger du JSON vers jq .est le bon choix quand vous voulez une sortie formatée pour un petit payload, ou quand le résultat alimente une autre commande. C'est le mauvais choix quand vous avez besoin d'explorerune réponse API à 200 champs — la sortie défile au-delà de la fenêtre du terminal et ne vous laisse aucun moyen de naviguer, réduire des sections ou rechercher un champ spécifique sans relancer la commande avec un filtre. Les visualiseurs JSON interactifs affichent la même sortie formatée et colorée dans un paginateur persistant où vous contrôlez la navigation. Les données sont identiques ; la différence est l'interface.

# jq . — la sortie défile hors de l'écran pour les grandes réponses
curl -s https://api.github.com/users/torvalds | jq .
# Plus de 300 lignes défilent — vous perdez le contexte immédiatement

# jless — ouvre un paginateur interactif, rien ne défile hors de l'écran
curl -s https://api.github.com/users/torvalds | jless
# Document complet visible, réductible, recherchable avec j/k/h/l

jless — Visualiseur JSON Interactif

jlessest un visualiseur JSON en terminal conçu spécifiquement pour cet usage. Contrairement à un simple pipe jq, il affiche le document sous la forme d'un arbre réductible persistant : chaque objet et tableau peut être développé ou réduit indépendamment avec l et h, la navigation utilise les touches style vim, et la recherche incrémentale trouve instantanément n'importe quelle clé ou valeur. Il transmet l'entrée de manière incrémentale, ouvrant ainsi les grands fichiers et les réponses API en moins d'une seconde quelle que soit leur taille — alors que jq met en mémoire tampon l'intégralité du document avant d'afficher quoi que ce soit. Je me tourne instinctivement vers jless dès qu'une réponse API est trop grande pour être parcourue d'un coup d'œil.

Installation

# macOS
brew install jless

# Linux — binaire précompilé depuis GitHub Releases
curl -sL https://github.com/PaulJuliusMartinez/jless/releases/latest/download/jless-x86_64-unknown-linux-gnu.tar.gz \
  | tar xz
sudo mv jless /usr/local/bin/

# Vérifier
jless --version

Utilisation de base

# Ouvrir un fichier local — le visualiseur arbre interactif se lance immédiatement
jless api-response.json

# Rediriger n'importe quel flux JSON directement vers jless
curl -s https://api.github.com/users/torvalds | jless

# Ouvrir avec tous les nœuds réduits au niveau supérieur (point de départ utile pour les grands documents)
jless --mode line api-response.json

# Charger un élément de tableau spécifique et le visualiser isolément
jq '.[0]' deployments.json | jless

Navigation et recherche en pratique

# Dans jless :
#
#   j / ↓        descendre
#   k / ↑        monter
#   l / →        développer le nœud (ou Entrée)
#   h / ←        réduire le nœud
#   H            réduire actuel + tous les frères → vue d'ensemble de haut niveau
#   L            développer tout récursivement
#
#   /            lancer la recherche vers l'avant — tapez un nom de clé et appuyez sur Entrée
#   n / N        résultat de recherche suivant / précédent
#
#   g / gg       aller au début
#   G            aller à la fin
#   q            quitter

Référence des Raccourcis Clavier de jless

Tous les raccourcis sont disponibles immédiatement après l'ouverture de jless — aucune configuration requise. Le modèle de navigation est intentionnellement identique à vim pour que la mémoire musculaire existante soit transférable.

jq -C | less -R — Pagination Colorée Sans Outils Supplémentaires

Si jless n'est pas installé et que vous avez besoin d'une vue défilable et colorée d'une réponse JSON, jq -C . | less -R est une solution de repli capable. L'option -C force les codes couleur ANSI même quand stdout est un pipe (normalement jq les supprime), et -Rindique à less de rendre ces codes au lieu de les imprimer comme du texte littéral. Le résultat est un document entièrement coloré et défilable — sans la structure d'arbre interactif de jless. La navigation dans less utilise les touches fléchées ou les touches style vim j/k, et / déclenche la recherche textuelle intégrée de less.

# Paginateur coloré de base
jq -C . response.json | less -R

# Depuis une réponse curl — -s empêche la barre de progression de corrompre le flux JSON
curl -s https://api.github.com/repos/jqlang/jq | jq -C . | less -R

# Trier les clés pour faciliter la lecture visuelle, puis paginer
jq -CS . config.json | less -R
# -C = forcer la couleur, -S = trier les clés (les deux options combinées)

# Ajouter un alias pour ne plus jamais taper le pipe complet
alias jqv='jq -C . | less -R'
# Utilisation : cat response.json | jqv
#          ou : curl -s https://api.example.com/status | jqv

JQ_COLORS — Thèmes de Couleurs Personnalisés

JQ_COLORSest une variable d'environnement qui remplace le schéma de couleurs ANSI par défaut de jq. Elle prend une chaîne de sept codes d'attribut ANSI;couleur séparés par des deux-points, un par type JSON dans cet ordre fixe : null : false : true : nombres : chaînes : tableaux : objets. Chaque code est au format attribut;couleuroù l'attribut est 0 (normal), 1 (gras), 2 (atténué) ou 4 (souligné), et la couleur est un numéro de couleur ANSI standard (30–37 = standard, 90–97 = vif).

# Référence des couleurs ANSI pour construire JQ_COLORS :
#   Attributs :  0=normal  1=gras  2=atténué  4=souligné
#   Couleurs :   30=noir  31=rouge  32=vert  33=jaune
#                34=bleu   35=magenta  36=cyan  37=blanc
#   Vives :      90=noir-vif  91=rouge-vif  92=vert-vif  93=jaune-vif
#                94=bleu-vif  95=magenta-vif  96=cyan-vif  97=blanc-vif
#
# Ordre : null : false : true : nombres : chaînes : tableaux : objets

# Thème à contraste élevé pour terminaux sombres (recommandé)
export JQ_COLORS="1;30:0;91:0;92:0;93:0;32:1;96:1;96"
# null=gris-atténué, false=rouge-vif, true=vert-vif,
# nombres=jaune-vif, chaînes=vert, tableaux=cyan-gras, objets=cyan-gras

# Thème style Solarized
export JQ_COLORS="2;37:0;35:0;35:0;36:0;33:1;34:1;34"
# null=blanc-atténué, false=magenta, true=magenta,
# nombres=cyan, chaînes=jaune, tableaux=bleu-gras, objets=bleu-gras

# Minimal (clés en gras uniquement, tout le reste simple)
export JQ_COLORS="0;90:0;39:0;39:0;39:0;39:1;39:1;39"

# Ajouter le thème choisi à ~/.bashrc ou ~/.zshrc pour qu'il s'applique à chaque appel de jq
echo 'export JQ_COLORS="1;30:0;91:0;92:0;93:0;32:1;96:1;96"' >> ~/.bashrc
source ~/.bashrc

# Tester le thème
echo '{"active":true,"errors":null,"count":42,"tags":["api","v2"],"meta":{"version":"1.0"}}' | jq .

Alias Shell pour la Visualisation JSON Quotidienne

Les commandes pour la visualisation JSON interactive sont verbeuses par défaut. Un petit ensemble d'alias dans ~/.bashrc ou ~/.zshrctransforme jless et la pagination colorée en commandes d'un seul mot qui s'intègrent naturellement dans n'importe quel flux de travail. Les alias ci-dessous se composent — jv et jvp acceptent tous deux une entrée redirigée ou un nom de fichier comme premier argument.

# Ajouter à ~/.bashrc ou ~/.zshrc

# jv — visualiseur interactif (jless si disponible, paginateur coloré en solution de repli)
jv() {
  if command -v jless &>/dev/null; then
    jless "$@"
  else
    jq -C . "$@" | less -R
  fi
}

# jvp — visualiser avec les clés triées alphabétiquement (utile pour comparer des réponses)
alias jvp='jq -CS . | less -R'

# jvc — visualiser depuis le presse-papiers (macOS)
alias jvc='pbpaste | jless'

# jvf — visualiser et filtrer : jvf '.users[0]' response.json
jvf() {
  local filter="$1"; shift
  jq -C "$filter" "$@" | less -R
}

# Recharger sans redémarrer le terminal
source ~/.bashrc

# Exemples d'utilisation après avoir ajouté les alias ci-dessus

# Visualiser n'importe quel fichier ou réponse redirigée
jv deployment-config.json
curl -s https://api.github.com/users/torvalds | jv

# Visualiser trié (facile à parcourir alphabétiquement)
cat feature-flags.json | jvp

# Explorer un sous-document interactivement
jvf '.database' infra/app-config.json
jvf '.users[] | select(.role == "admin")' users.json

bat — Visualisation de Fichiers JSON avec Coloration Syntaxique

bat est un remplacement de cat avec coloration syntaxique, numéros de ligne et un paginateur intégré. Pour les fichiers JSON sur disque, il offre une expérience de lecture propre, façon éditeur, sans ouvrir un éditeur de texte complet. Contrairement à jless, bat affiche le fichier en texte statique — sans réduction, sans recherche, sans navigation au-delà du défilement. Son point fort est la clarté visuelle pour les fichiers statiques de taille moyenne (configs, fixtures, payloads de test) où vous voulez la coloration syntaxique et les numéros de ligne mais n'avez pas besoin de navigation d'arbre interactive.

# macOS
brew install bat

# Debian / Ubuntu (le binaire peut s'appeler batcat)
apt-get install -y bat
# alias bat=batcat   # à ajouter à ~/.bashrc si nécessaire sur Ubuntu

# Visualiser un fichier JSON avec coloration syntaxique et numéros de ligne
bat config/feature-flags.json

# Désactiver le paginateur — imprimer directement dans le terminal (utile dans les scripts)
bat --paging=never api-response.json

# Combiner avec jq : formater avec jq, visualiser avec bat (préserve la coloration JSON de bat)
jq '.' response.json | bat --language=json --paging=never

fx — Explorateur JSON Interactif en Node.js

fx est un visualiseur JSON interactif basé sur Node.js. Son interface est similaire à jless — arbre réductible, navigation clavier, recherche — mais ajoute deux fonctionnalités absentes de jless : le support de la souris (clic pour développer/réduire les nœuds) et la possibilité de saisir une expression JavaScript dans la barre inférieure pour filtrer le document en temps réel. Pour les équipes déjà sous Node.js, fx est un choix naturel et ne nécessite pas de binaire séparé. Pour les environnements de terminal pur sans Node, jless est le choix le plus léger.

# Installer globalement via npm
npm install -g fx

# Ou exécuter sans installer (npx met le paquet en cache)
curl -s https://api.github.com/users/torvalds | npx fx

# Utilisation interactive de base
fx api-response.json
curl -s https://api.github.com/repos/jqlang/jq | fx

# Dans fx : les touches fléchées naviguent, Entrée développe/réduit, / recherche
# La barre inférieure accepte les expressions JavaScript pour le filtrage en direct :
#   .name           → afficher uniquement le champ "name"
#   .repos.slice(0,5) → 5 premiers repos

# fx fonctionne aussi comme formateur non interactif (comme jq . mais avec syntaxe JS)
# Passez une expression JavaScript en argument — pas de mode interactif
echo '{"users":[{"id":1,"name":"Thomas Dupont"},{"id":2,"name":"Claire Martin"}]}' \
  | fx '.users[0].name'
# Thomas Dupont

# Enchaîner avec map pour les transformations de tableau
cat deployments.json | fx '.items.map(d => ({id: d.deploy_id, status: d.state}))'

Erreurs Courantes

Ces quatre erreurs reviennent régulièrement quand les développeurs commencent à utiliser les visualiseurs JSON en terminal — chacune a une correction claire une fois que vous comprenez pourquoi elle survient.

# Réponse API de 300 lignes — les 280 premières défilent immédiatement
curl -s https://api.github.com/users/torvalds | jq .
# Seule la partie inférieure de la sortie est visible — impossible de revenir en arrière

# Le document complet reste accessible dans jless — rien n'est perdu
curl -s https://api.github.com/users/torvalds | jless
# j/k pour défiler, h/l pour réduire/développer, / pour rechercher

# Seulement 6 valeurs — jq utilise les valeurs par défaut silencieusement, sans indication du pourquoi
export JQ_COLORS="1;30:0;91:0;92:0;93:0;32:1;96"
echo '{"ok":true}' | jq .  # couleurs inchangées — aucune erreur affichée

# Exactement 7 valeurs — 6 deux-points
export JQ_COLORS="1;30:0;91:0;92:0;93:0;32:1;96:1;96"

# Vérifier le compte avant d'ajouter au profil shell
echo "$JQ_COLORS" | tr -cd ':' | wc -c   # doit afficher 6

# La sortie de jless est pour les yeux humains — la rediriger produit du bruit
jless response.json | grep "request_id"
# Sortie : codes d'échappement ANSI et séquences de curseur, pas du texte propre

# Utilisez jq pour l'extraction programmatique — propre et composable
jq -r '.request_id' response.json | grep "req_"

# Utilisez jless uniquement comme point final du terminal — rien après lui
jless response.json

# -C sans -R : les séquences d'échappement s'impriment comme du texte brut
jq -C . response.json | less
# Sortie : ^[[1;34m"status"^[[0m: ^[[0;32m"ok"^[[0m ...

# -C avec -R : les codes ANSI sont rendus comme de vraies couleurs
jq -C . response.json | less -R
# Sortie : JSON coloré, propre et lisible

jless vs jq vs bat vs fx — Comparaison des Visualiseurs Interactifs

Les quatre outils affichent du JSON coloré, mais leurs capacités interactives diffèrent significativement. Choisissez selon que vous avez besoin de navigation réductible, de recherche ou de support souris — et selon que Node.js est déjà dans votre environnement.

Pour la plupart des situations : installez jless une fois et utilisez-le comme visualiseur interactif par défaut. Gardez jq -C . | less -R comme solution de repli pour les environnements où vous ne pouvez pas installer de binaires supplémentaires. Ajoutez fx si votre équipe est principalement Node.js et apprécie la navigation souris ou le filtrage JavaScript en direct.

Questions Fréquemment Posées

# Ouvrir le fichier dans jless, puis appuyer sur / pour rechercher
jless api-response.json
# Dans jless : tapez /  →  "request_id"  →  Entrée  →  n pour la correspondance suivante

# Alternative avec jq : extraire et afficher toutes les clés correspondantes sur stdout
jq '.. | objects | with_entries(select(.key == "request_id"))' api-response.json

# Ouvrir la réponse dans jless
curl -s https://api.github.com/repos/jqlang/jq | jless
# Dans jless :
#   H            → réduire toutes les clés de niveau supérieur
#   j/k          → naviguer jusqu'à la clé voulue
#   l            → développer uniquement cette branche
#   gg           → retourner à la racine
#   G            → sauter au dernier élément

# Thème à contraste élevé pour terminaux sombres — à ajouter à ~/.bashrc ou ~/.zshrc
export JQ_COLORS="1;30:0;91:0;92:0;93:0;32:1;96:1;96"
# null=gris, false=rouge-vif, true=vert-vif,
# nombres=jaune-vif, chaînes=vert, tableaux/objets=cyan-vif

# Tester immédiatement sans recharger le shell
echo '{"active":true,"errors":0,"tags":["api","v2"]}' | jq .

# Petit payload — jq . convient parfaitement
echo '{"status":"ok","version":"2.4.1"}' | jq .

# Grande réponse imbriquée — jless est plus adapté
curl -s https://api.github.com/repos/jqlang/jq | jless
# → arbre interactif, aucune sortie ne défile hors de l'écran

# Exploration interactive avec jless
curl -s https://api.github.com/users/torvalds | jless

# Paginateur coloré en solution de repli (sans réduction, mais défilable avec couleur)
curl -s https://api.github.com/users/torvalds | jq -C . | less -R

# tmux côte à côte : diviser horizontalement, puis exécuter jless dans chaque volet
tmux split-window -h
# Volet gauche :  jless response-v1.json
# Volet droit : jless response-v2.json

# Ou utiliser diff sur la sortie normalisée par jq pour un diff textuel
diff <(jq -S . response-v1.json) <(jq -S . response-v2.json)

Outils Associés

L'outil Embellisseur JSON vous offre la même vue réductible et colorée que jless — directement dans le navigateur, sans installation et sans terminal requis.