ForHosting KIT · Outils pour développeurs

Minifiez les espaces JavaScript et mesurez le gain

Ce minificateur d’espaces JavaScript supprime les commentaires de ligne, les commentaires de bloc et les espaces de mise en forme inutiles à l’exécution.

● BetaGratuit · dans votre navigateur
Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Il préserve les chaînes, les littéraux de gabarit, les expressions régulières, les opérateurs et les limites d’identifiants, ainsi que les sauts de ligne susceptibles de modifier l’insertion automatique des points-virgules. Le résultat comprend le code compact, les nombres d’octets UTF-8 avant et après traitement et le pourcentage économisé. Vous obtenez ainsi une compression prévisible sans renommage, réécriture, dépendance, accès réseau ni chaîne de bundling complète.

Compactez le code sans réécrire le programme

Cette capacité remplit une mission précise : supprimer les commentaires et réduire les espaces non significatifs. Elle ne renomme pas les variables, ne simplifie pas les constantes, ne réordonne pas les expressions, ne modifie pas les propriétés et ne convertit pas la syntaxe moderne. Cette portée limitée facilite l’inspection et la comparaison avec l’original. Envoyez le JavaScript dans le champ javascript, ou employez les alias code ou text, pour recevoir le code compact accompagné de mesures UTF-8 exactes. L’analyseur reconnaît les chaînes entre guillemets, les gabarits et les expressions régulières avant d’interpréter les marqueurs de commentaire. Une URL dans une chaîne ou une barre dans une expression régulière reste donc une donnée du programme. Un espace n’est réintroduit que si deux jetons voisins risquent d’en former un nouveau. Les identifiants restent séparés, tandis que la mise en forme autour des virgules, accolades et principaux opérateurs disparaît. Il s’agit de compression, pas d’obscurcissement : les noms et la structure restent lisibles, sans service réseau caché ni modèle non déterministe.

Préservez les jetons et les sauts de ligne significatifs

Les espaces sont souvent facultatifs en JavaScript, mais ils ne sont pas toujours dénués de sens. Coller des caractères d’identifiant peut créer un autre nom ; réunir deux signes plus peut produire un opérateur d’incrémentation ; supprimer un saut après return, throw, break, continue ou yield peut changer l’insertion automatique du point-virgule. Le minificateur découpe donc l’entrée en jetons et décide à chaque limite, au lieu d’appliquer une expression régulière globale. Il conserve les sauts importants dans ces cas et sépare les opérateurs ambigus. Les commentaires ne sont reconnus qu’en dehors des chaînes, gabarits et expressions régulières. Durant le même passage, il vérifie les délimiteurs : chaque parenthèse, crochet ou accolade fermante doit correspondre à la dernière ouverture. Un délimiteur isolé ou mal imbriqué déclenche une erreur d’entrée invalide plutôt qu’un résultat douteux. Les commentaires, chaînes, gabarits et expressions régulières non terminés échouent également clairement. Cette validation est structurelle, sans constituer un parseur JavaScript complet.

Mesurez le gain et intégrez un résultat déterministe

La réponse indique original_bytes et minified_bytes en UTF-8, mesure pertinente pour les fichiers transférés par HTTP ou stockés comme ressources web. Elle fournit aussi reduction_percent, arrondi à deux décimales, afin de simplifier les contrôles, tableaux de bord et notes de version. L’algorithme étant déterministe, une entrée donnée produit toujours le même code et les mêmes nombres. Une chaîne de production peut envoyer du code généré, écrire le champ javascript renvoyé dans ses artefacts et imposer un gain minimal sans installer de paquet. Un système documentaire peut compacter des exemples intégrés, tandis qu’un déploiement léger peut réduire des utilitaires écrits à la main sans bundling ni renommage. La capacité coûte $0.002 par requête API ; l’exécution dans le navigateur peut employer la même implémentation pure. Avant la production, exécutez les tests du programme obtenu comme après tout traitement de source. L’outil protège les limites lexicales et l’équilibre des délimiteurs, mais les tests restent la meilleure garantie dans les contextes grammaticaux inhabituels.

Compacter une ressource de navigateur générée

Supprimez commentaires et mise en forme avant publication, tout en gardant des identifiants lisibles pour le diagnostic.

Réduire des scripts utilitaires autonomes

Diminuez le volume transféré d’un petit script sans adopter de bundler, de renommage de variables ni d’étape lourde.

Suivre les économies sur le code source

Consignez octets originaux, octets minifiés et pourcentage de réduction dans un rapport de version ou un contrôle qualité.

Que supprime cette capacité ?

Elle retire les commentaires de ligne et de bloc, ainsi que les espaces inutiles à la séparation des jetons et à certaines limites d’insertion automatique.

Renomme-t-elle les variables ou modifie-t-elle les expressions ?

Non. Elle effectue uniquement une compression lexicale prudente, sans renommage, simplification, réorganisation ni transpilation.

Comment la réduction de taille est-elle calculée ?

Les deux tailles sont mesurées en octets UTF-8. Le pourcentage correspond à leur différence divisée par la taille originale, arrondie à deux décimales.

Que se passe-t-il si les délimiteurs sont déséquilibrés ?

La requête échoue avec une erreur d’entrée invalide si des parenthèses, crochets ou accolades sont isolés ou mal imbriqués.

Les caractères de commentaire dans les chaînes sont-ils supprimés ?

Non. Les chaînes, gabarits et expressions régulières sont analysés comme littéraux ; leurs barres internes sont donc conservées.

Quel est le prix d’une requête API ?

Chaque requête API coûte $0.002. Une entrée refusée par la validation produit une erreur, jamais du code minifié.

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.

POSThttps://api.kit.forhosting.com/dev2/minify-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é.

curl -X POST https://api.kit.forhosting.com/dev2/minify-js \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"javascript":"function add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"}'
{
  "javascript": "function add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev2.minify_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.

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

HTTPCodeSignification
401unauthorizedClé API absente ou invalide : vérifiez l’en-tête Authorization.
402insufficient_balanceSolde insuffisant : rechargez votre compte pour lancer cette tâche.
404unknown_typeType de tâche inconnu : vérifiez le champ type de votre requête.
429rate_limitedTrop de requêtes : ralentissez la cadence, puis réessayez.

Consulter la documentation complète du KIT →