ForHosting KIT · Outils pour développeurs

Embellisseur JavaScript

L’embellisseur JavaScript transforme un code compressé ou irrégulièrement espacé en une présentation plus facile à examiner, expliquer et réviser.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Collez un script minifié, un fragment regroupé, un gestionnaire intégré ou du code généré : vous obtenez une mise en page déterministe, indentée de deux espaces, avec des sauts après les instructions. L’analyseur protège chaînes, gabarits littéraux, commentaires et expressions régulières tout en formatant la ponctuation structurelle. Il refuse aussi les crochets, parenthèses et accolades incompatibles ou inachevés.

Rendez sa lisibilité au JavaScript compressé

Le JavaScript livré aux navigateurs est souvent minifié afin de réduire le temps de transfert, mais cette représentation compacte est pénible à suivre. Corps de fonctions, déclarations de variables, appels, conditions et retours peuvent tenir sur une seule ligne continue. Cet embellisseur rétablit une hiérarchie visuelle stable sans exécuter le programme transmis. Les accolades ouvrantes commencent des blocs indentés, les accolades fermantes reviennent au niveau précédent et les points-virgules terminant une instruction créent un saut lorsqu’ils se trouvent hors d’une expression parenthésée. Chaque niveau utilise deux espaces : plusieurs passages donnent donc un résultat prévisible, adapté à une note, un ticket, une revue ou un éditeur. L’outil est particulièrement utile lorsque la seule source disponible vient d’un navigateur, d’un dossier de compilation, d’un script intégré ou d’une réponse de diagnostic. Il ne renomme pas les variables, ne décompose pas les modules regroupés, ne reconstitue pas les cartes de sources et ne prétend pas retrouver le style de l’auteur. Son rôle est précis : révéler clairement la structure visible du programme tout en conservant ses caractères significatifs.

Protégez chaînes, commentaires, gabarits et expressions régulières

La ponctuation change de sens selon le contexte JavaScript ; un formateur fiable ne peut donc pas couper le texte à chaque accolade ou point-virgule. Un point-virgule placé dans un message entre guillemets est une donnée. Les crochets d’une expression régulière définissent une classe de caractères. Une accolade dans un gabarit littéral peut appartenir au contenu, et la ponctuation d’un commentaire ne doit pas modifier la structure. L’analyseur suit ainsi les chaînes entre guillemets simples ou doubles, les échappements, les gabarits littéraux, les commentaires de ligne et de bloc ainsi que les expressions régulières. La mise en forme structurelle n’intervient qu’en dehors de ces zones protégées. Les parenthèses sont également suivies afin de conserver sur une ligne les points-virgules d’un en-tête for classique. Ce balayage déterministe n’utilise ni réseau, ni horloge, ni hasard, ni modèle, ni évaluation. Une entrée identique produit toujours la même sortie et le JavaScript transmis n’est jamais exécuté. Le résultat facilite l’examen humain et les traitements suivants, sans remplacer un analyseur complet de la norme ni le formateur propre à un projet.

Repérez les délimiteurs incomplets avant de poursuivre

Une demande de mise en forme survient souvent après une copie depuis un emplacement peu pratique, opération qui peut omettre un caractère à l’une des extrémités. L’embellisseur maintient une pile imbriquée de délimiteurs structurels et compare chaque fermeture à son ouverture. Une parenthèse, un crochet ou une accolade fermante inattendue déclenche immédiatement une erreur d’entrée non valide. Si le texte se termine avec un délimiteur ouvrant encore en attente, l’opération échoue également au lieu de produire un résultat seulement présentable. Les délimiteurs situés dans des chaînes, commentaires, gabarits littéraux et expressions régulières protégés sont considérés comme du contenu. Cette vérification reste volontairement ciblée : des délimiteurs équilibrés ne prouvent pas que les identifiants, opérateurs, déclarations, modules ou flux de contrôle constituent du JavaScript valide, et l’outil n’exécute aucun code. Elle avertit néanmoins des troncatures et discordances courantes avant l’emploi d’un extrait dans une documentation, une revue, une comparaison ou un analyseur spécialisé. Le formatage peut s’effectuer localement dans le navigateur ; les requêtes API automatisées utilisent le prix de base publié de $0.002 par élément.

Cas d’usage

Examiner une ressource minifiée du navigateur

Déployez un script compressé en blocs indentés et lignes d’instructions avant de suivre une fonction, un gestionnaire ou un appel suspect.

Préparer un extrait pour une revue

Appliquez une mise en page déterministe au JavaScript généré ou irrégulier afin que la revue porte sur le comportement et la structure.

Contrôler un fragment copié

Repérez parenthèses, crochets et accolades absents ou incompatibles avant de placer le code dans une documentation ou un autre outil.

Questions fréquentes

Quelle mise en forme l’embellisseur applique-t-il ?

Il indente chaque niveau de bloc de deux espaces et place sur de nouvelles lignes les instructions terminées par un point-virgule hors des expressions parenthésées.

L’outil exécute-t-il le JavaScript transmis ?

Non. Il effectue un balayage déterministe du texte sans jamais évaluer ni exécuter le code fourni.

Les chaînes, commentaires, gabarits et expressions régulières sont-ils préservés ?

Oui. Leur contenu reste protégé des sauts structurels pendant l’analyse du code environnant.

Une ponctuation équilibrée garantit-elle un JavaScript valide ?

Non. L’outil vérifie les délimiteurs et les limites de formatage, mais ne valide pas toute la syntaxe ECMAScript.

Combien coûte une requête API ?

Chaque requête API applique le prix de base publié de $0.002. La version pour navigateur peut fonctionner localement sans requête API.

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

POSThttps://api.kit.forhosting.com/dev2/beautify-js

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/dev2/beautify-js \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"javascript":"function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"}'

const res = await fetch("https://api.kit.forhosting.com/dev2/beautify-js", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "javascript": "function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev2/beautify-js",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "javascript": "function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/beautify-js", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"javascript":"function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"javascript":"function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/beautify-js", 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

{
  "javascript": "function greet(name){const message=`Hello, ${name}!`;console.log(message);return message;}"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev2.beautify_js",
  "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

par requête$0.002

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.

Consulter la documentation complète du KIT →