ForHosting KIT · Strumenti per sviluppatori

Abbellitore JavaScript

L’abbellitore JavaScript trasforma codice compresso o spaziato in modo irregolare in un formato più facile da esaminare, spiegare e revisionare.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Incolli uno script minificato, un frammento impacchettato, un gestore incorporato o codice generato e otterrà una disposizione deterministica con rientri di due spazi e interruzioni dopo le istruzioni. Lo scanner protegge stringhe, template literal, commenti ed espressioni regolari mentre formatta la punteggiatura strutturale. Rifiuta inoltre parentesi tonde, quadre e graffe non corrispondenti o incomplete.

Renda nuovamente leggibile il JavaScript compresso

Il JavaScript inviato ai browser viene spesso minificato per ridurre i tempi di trasferimento, ma tale rappresentazione compatta è difficile da seguire. Corpi di funzioni, dichiarazioni di variabili, chiamate, condizioni e ritorni possono occupare un’unica riga continua. Questo abbellitore ripristina una gerarchia visiva stabile senza eseguire il programma fornito. Le graffe di apertura avviano blocchi rientrati, quelle di chiusura tornano al livello precedente e i punti e virgola che terminano un’istruzione creano interruzioni quando si trovano fuori da espressioni tra parentesi. Ogni livello usa due spazi, quindi esecuzioni ripetute producono un risultato prevedibile, adatto a note, ticket, revisioni o editor. Lo strumento è particolarmente utile quando l’unica fonte disponibile proviene dal browser, da una cartella di build, da uno script incorporato o da una risposta diagnostica. Non rinomina variabili, non espande moduli impacchettati, non ricostruisce mappe sorgente e non promette di recuperare lo stile dell’autore. Il suo scopo è preciso: mostrare chiaramente la struttura visibile del programma conservandone i caratteri significativi.

Protegga stringhe, commenti, template ed espressioni regolari

La punteggiatura assume significati diversi nei vari contesti JavaScript, quindi un formattatore affidabile non può dividere il testo a ogni graffa o punto e virgola. Un punto e virgola in un messaggio tra virgolette è un dato. Le parentesi quadre in un’espressione regolare descrivono una classe di caratteri. Una graffa in un template literal può essere contenuto, mentre la punteggiatura in un commento non deve modificare la struttura. Lo scanner riconosce stringhe con virgolette singole e doppie, sequenze di escape, template literal, commenti di riga e di blocco ed espressioni regolari. La formattazione strutturale avviene solo fuori da queste aree protette. Vengono tracciate anche le parentesi, così i punti e virgola dell’intestazione for tradizionale restano sulla stessa riga. Questa scansione deterministica non usa rete, orologio, casualità, modelli o valutazione in esecuzione. Un input identico produce sempre lo stesso output e il JavaScript inviato non viene mai eseguito. Il risultato facilita l’ispezione umana e gli strumenti successivi, ma questo abbellitore strutturale non sostituisce un parser completo dello standard né un formattatore configurato per il progetto.

Individui delimitatori incompleti prima di proseguire

La formattazione viene spesso richiesta dopo aver copiato codice da una posizione scomoda, operazione che può omettere un carattere alle estremità. L’abbellitore mantiene una pila annidata di delimitatori strutturali e confronta ogni chiusura con la relativa apertura. Una parentesi tonda, quadra o graffa di chiusura inattesa genera immediatamente un errore di input non valido. Se il testo termina con un delimitatore di apertura ancora pendente, l’operazione fallisce invece di restituire un risultato solo apparentemente ordinato. I delimitatori nelle stringhe, nei commenti, nei template literal e nelle espressioni regolari protetti vengono trattati come contenuto. Il controllo è volutamente mirato: delimitatori bilanciati non dimostrano che identificatori, operatori, dichiarazioni, moduli o flusso di controllo costituiscano JavaScript valido e lo strumento non esegue il codice. Forniscono però un avviso utile per troncamenti e incompatibilità comuni prima che un frammento entri in documentazione, revisione, confronto o analisi specializzata. La formattazione nel browser può avvenire localmente; le richieste API automatizzate usano il prezzo base pubblicato di $0.002 per elemento.

Casi d'uso

Esaminare una risorsa minificata del browser

Espanda uno script compresso in blocchi rientrati e righe di istruzioni prima di seguire una funzione, un gestore o una chiamata sospetta.

Preparare un frammento per la revisione

Applichi una disposizione deterministica al JavaScript generato o irregolare affinché la revisione si concentri su comportamento e struttura.

Controllare un frammento copiato

Rilevi parentesi tonde, quadre e graffe mancanti o incompatibili prima di inserire il codice nella documentazione o in un altro strumento.

Domande frequenti

Quale formattazione applica l’abbellitore?

Usa due spazi per livello di blocco e colloca su nuove righe le istruzioni terminate da punto e virgola fuori dalle espressioni tra parentesi.

Lo strumento esegue il JavaScript inviato?

No. Effettua una scansione deterministica del testo e non valuta né esegue mai il codice fornito.

Stringhe, commenti, template ed espressioni regolari vengono conservati?

Sì. Il loro contenuto resta protetto dalle interruzioni strutturali mentre lo scanner elabora il codice circostante.

Una punteggiatura bilanciata garantisce JavaScript valido?

No. Lo strumento controlla delimitatori e confini di formattazione, ma non convalida l’intera sintassi ECMAScript.

Quanto costa una richiesta API?

Ogni richiesta API applica il prezzo base pubblicato di $0.002. La versione per browser può funzionare localmente senza richiesta API.

Per sviluppatori — accesso via API

Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.

Endpoint

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

Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.

Chiamala dal tuo 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)

Esempio di richiesta

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

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev2.beautify_js",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.

Prezzi

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

Errori

HTTP	Codice	Significato
`401`	`unauthorized`	Chiave API mancante o non valida: controlla l'header Authorization.
`402`	`insufficient_balance`	Credito esaurito: ricarica per continuare a eseguire attività.
`404`	`unknown_type`	Tipo di attività sconosciuto: controlla il campo type della richiesta.
`429`	`rate_limited`	Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo.

Leggi la documentazione completa del KIT →