ForHosting KIT · Strumenti per sviluppatori

Minifichi gli spazi JavaScript e misuri la riduzione

Questo minificatore degli spazi JavaScript elimina commenti di riga, commenti a blocchi e spazi di formattazione non necessari all’esecuzione.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Conserva stringhe, template literal, espressioni regolari, operatori e confini degli identificatori, oltre agli a capo che possono influire sull’inserimento automatico del punto e virgola. Il risultato comprende il codice compatto, i conteggi dei byte UTF-8 originali e finali e la percentuale risparmiata. È indicato quando Lei desidera una compattazione prevedibile senza rinominare identificatori, riscrivere codice, installare dipendenze, usare la rete o adottare un’intera pipeline di bundling.

Compatti il codice senza riscrivere il programma

Questa capacità svolge un compito preciso: rimuovere i commenti e ridurre gli spazi non significativi. Non rinomina variabili, semplifica costanti, riordina espressioni, modifica proprietà o converte la sintassi moderna. L’ambito ristretto facilita l’ispezione e il confronto con l’originale. Invii JavaScript nel campo javascript, oppure utilizzi gli alias code o text, e riceverà codice compatto con misure UTF-8 esatte. Lo scanner riconosce stringhe tra virgolette, template literal ed espressioni regolari prima di interpretare i marcatori dei commenti; pertanto, un URL in una stringa o una barra in un’espressione regolare rimane un dato del programma. Gli spazi vengono reinseriti soltanto quando due token adiacenti potrebbero fondersi in un token diverso. Gli identificatori restano separati, mentre scompare la formattazione attorno a virgole, parentesi graffe e gran parte degli operatori. È compattazione, non offuscamento: nomi e struttura restano riconoscibili, senza servizi di rete nascosti o modelli non deterministici.

Conservi token e interruzioni di riga significative

Gli spazi in JavaScript sono spesso facoltativi, ma non sempre privi di significato. Unire caratteri di identificatori può creare un altro nome; accostare due segni più può formare un incremento; eliminare un a capo dopo return, throw, break, continue o yield può modificare l’inserimento automatico del punto e virgola. Il minificatore suddivide quindi l’input in token e decide ogni confine, invece di applicare un’espressione regolare globale. Mantiene gli a capo rilevanti per questi casi e separa gli operatori ambigui. I commenti vengono riconosciuti solo fuori da stringhe, template literal ed espressioni regolari. Nello stesso passaggio verifica i delimitatori: ogni parentesi tonda, quadra o graffa di chiusura deve corrispondere all’apertura più recente. Un delimitatore spaiato o annidato male genera un errore di input non valido, non un risultato dubbio. Anche commenti, stringhe, template ed espressioni regolari non terminati falliscono chiaramente. La validazione è strutturale e non sostituisce un parser JavaScript completo.

Misuri il risparmio e integri un risultato deterministico

La risposta indica original_bytes e minified_bytes in UTF-8, la misura pertinente per file trasferiti via HTTP o archiviati come risorse web. Riporta inoltre reduction_percent arrotondato a due decimali, semplificando controlli, dashboard e note di rilascio. Poiché l’algoritmo è deterministico, lo stesso input restituisce sempre identico codice e identici conteggi. Una pipeline può inviare codice generato, scrivere il campo javascript restituito nella cartella degli artefatti e imporre una riduzione minima senza installare pacchetti. Un sistema documentale può compattare esempi inline e una distribuzione leggera può ridurre utility scritte a mano senza bundling o modifica dei nomi. La capacità costa $0.002 per richiesta API, mentre l’esecuzione nel browser può usare la stessa implementazione pura. Prima della produzione, esegua i test del programma risultante come dopo qualsiasi trattamento del sorgente. Lo strumento tutela i confini lessicali e l’equilibrio dei delimitatori, ma i test restano la conferma migliore per contesti grammaticali insoliti.

Casi d'uso

Compattare una risorsa browser generata

Rimuova commenti e formattazione prima della pubblicazione, conservando identificatori leggibili per la diagnostica.

Ridurre script di utilità autonomi

Diminuisca il trasferimento di un piccolo script senza adottare bundler, modifica dei nomi o una fase pesante di dipendenze.

Registrare il risparmio sul sorgente

Inserisca byte originali, byte minificati e percentuale di riduzione in un rapporto di rilascio o controllo qualità.

Domande frequenti

Che cosa rimuove questa capacità?

Elimina commenti di riga e a blocchi, oltre agli spazi non necessari a separare token e determinati confini di inserimento automatico.

Rinomina le variabili o modifica le espressioni?

No. Esegue solo una compattazione lessicale prudente, senza rinominare, semplificare, riordinare o transpilare.

Come viene calcolata la riduzione delle dimensioni?

Entrambe le dimensioni sono misurate in byte UTF-8. La percentuale è la differenza divisa per la dimensione originale, arrotondata a due decimali.

Che cosa accade con delimitatori sbilanciati?

La richiesta fallisce con un errore di input non valido se parentesi tonde, quadre o graffe sono spaiate o annidate male.

I caratteri di commento nelle stringhe vengono rimossi?

No. Stringhe, template literal ed espressioni regolari sono analizzati come letterali, quindi le barre interne restano intatte.

Quanto costa una richiesta API?

Ogni richiesta API costa $0.002. Gli input che non superano la validazione producono errori, non codice minificato.

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/minify-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/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"}'

const res = await fetch("https://api.kit.forhosting.com/dev2/minify-js", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "javascript": "function add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev2/minify-js",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "javascript": "function add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/minify-js", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"javascript":"function add(a, b) {\\n  // Return the sum\\n  return a + b;\\n}\\n"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"javascript":"function add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/minify-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 add(a, b) {\n  // Return the sum\n  return a + b;\n}\n"
}

Esempio di risposta

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