Codificatore Base32768
Comprima testo in Base32768, dove ogni carattere Unicode porta quindici bit per i canali UTF-16: Hello diventa solo tre caratteri, 䩲腻㐿. In decodifica vengono controllati ogni simbolo e il riempimento, quindi una copia danneggiata fallisce. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- Hello
- Modalità di calcolo
- Encode
- Risultato
- 䩲腻㐿
- Lunghezza
- 3
- Byte di input
- 5
- Bit per carattere
- 15
Invece di impacchettare cinque o sei bit in un simbolo ASCII come Base32 e Base64, Base32768 sceglie ogni carattere da un repertorio di 32768 punti di codice sicuri del Piano multilinguistico di base e trasporta quindici bit di carico per carattere. Ciò produce circa il 93.75 percento di efficienza quando il risultato è memorizzato o trasmesso come UTF-16, molto più denso di Base64 sullo stesso filo. Questa capacità implementa da capo a fine il profilo qntm Base32768: la modalità encode legge la Sua stringa in chiaro come byte UTF-8 ed emette un risultato Base32768; la modalità decode convalida ogni simbolo rispetto all'alfabeto primario a quindici bit e a quello secondario di riempimento a sette bit, poi recupera il testo UTF-8 originale.
Come Base32768 impacchetta quindici bit in caratteri BMP sicuri
Base32768 tratta l'ingresso come un flusso continuo di bit di byte grezzi. Per il testo, questa capacità converte prima la Sua stringa con UTF-8 così i caratteri multi-byte restano portabili tra lingue e piattaforme. I bit si prendono dal più significativo al meno.
Ogni quindici bit accumulati selezionano un indice in un repertorio primario da 32768 voci costruito su intervalli chiusi di punti di codice Unicode assegnati, non di controllo e senza spazi bianchi nel Piano multilinguistico di base. Quando il resto finale non è un blocco completo di quindici bit, il codificatore riempie con uni e termina con un simbolo primario oppure con un simbolo secondario di riempimento a sette bit tratto da un alfabeto separato da 128 voci.
La decodifica inverte la mappa: ogni carattere apporta quindici o sette bit, i byte completi sono emessi non appena si accumulano otto bit e i bit residuali di riempimento devono restare tutti uni. Un carattere secondario di riempimento prima della posizione finale è pure rifiutato, perché quel motivo non compare mai in una codifica legale. Rispetto a Base64, Lei scambia un alfabeto solo ASCII per una densità molto migliore sotto UTF-16; rispetto a Base65536 resta nel BMP e ogni carattere è una sola unità di codice UTF-16.
Dove Base32768 compare nel lavoro reale
I sistemi che memorizzano blob binari in colonne di testo UTF-16 spesso necessitano di un impacchettamento più denso di quanto Base64 offra senza uscire dal BMP. I team già standardizzati sulla suite qntm di codifiche dense usano Base32768 quando il canale è nativo UTF-16 e Base2048 o Base65536 quando valgono altri vincoli. I desk di supporto incollano stringhe opache dai ticket e necessitano di convalida stretta dell'alfabeto senza accettare simboli spazzatura che produrrebbero un carico sbagliato.
Gli autori di corsi che insegnano densità di codifica sotto diverse forme Unicode vogliono una pagina dedicata a Base32768 piuttosto che seppellirla sotto un landing generico Base64, perché l'intento di ricerca, le regole dell'alfabeto e i numeri di efficienza differiscono. Se le serve Base32 RFC 4648 per segreti TOTP, Base64 sicuro per URL o densità basE91 sotto UTF-8, li tratti come intenti di ricerca e landing separati anziché sovraccaricare questa pagina di codificatore Base32768.
Casi d'uso
Token opachi densi in UTF-16
Codifichi carichi brevi sicuri in binario in Base32768 per archiviazione in colonne NVARCHAR, stringhe JavaScript o appunti quando la densità UTF-16 conta più della sicurezza ASCII.
Domande frequenti
Quale profilo Base32768 usa questa capacità?
Il profilo qntm Base32768: 32768 punti di codice BMP primari da quindici bit ciascuno, più un alfabeto secondario da 128 voci per il simbolo finale di riempimento a sette bit quando serve.
Posso codificare e decodificare?
Sì. Imposti mode su encode (predefinito) per trasformare testo UTF-8 in chiaro in Base32768, o mode su decode per recuperare testo da una stringa Base32768.
Cosa succede se la stringa Base32768 ha un carattere non valido?
Nulla viene addebitato per i fallimenti di convalida.
Perché Base32768 è più denso di Base64 sotto UTF-16?
Ogni carattere Base32768 è una sola unità di codice BMP (16 bit di UTF-16) con quindici bit di carico, circa il 93.75 percento di efficienza. Base64 richiede due unità UTF-16 per dodici bit di carico ASCII, quindi la densità su fili UTF-16 è molto inferiore.
Quanto costa?
Lo strumento del browser è gratuito e gira in locale.
Strumenti correlati
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
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/enc/base32768 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base32768", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base32768",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base32768", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base32768", 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
{
"text": "Hello"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base32768",
"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
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. |
Note tecniche
Base32768 è una codifica da binario a testo pensata per canali che parlano già UTF-16: stringhe JavaScript, String di Java, API wide di Windows e molti database con NVARCHAR. Simboli illegali, caratteri di riempimento fuori posto e disallineamenti dei bit di riempimento falliscono subito con invalid_input così un incolla corrotto non sembra mai riuscito.
Come Base32768 impacchetta quindici bit in caratteri BMP sicuri
Quegli intervalli evitano di proposito caratteri che spezzano la normalizzazione Unicode, confondono la direzione del testo o sembrano formattazione, così la stringa codificata è sicura da incollare nella maggior parte delle API pulite Unicode. Qualsiasi carattere fuori da entrambi i repertori solleva invalid_input. L'intero percorso è lavoro intero deterministico senza rete, senza semi casuali e senza orologio di parete, quindi ingressi identici producono sempre lo stesso JSON.
Cosa invia e cosa riceve indietro
Invii un campo stringa obbligatorio chiamato text e un campo opzionale mode impostato su encode o decode. La modalità encode tratta text come contenuto UTF-8 in chiaro e restituisce una stringa result negli alfabeti Base32768. La modalità decode tratta text come Base32768, convalida ogni simbolo e restituisce la stringa UTF-8 recuperata in result. I fallimenti di convalida non consumano il saldo prepagato. Quando mode è omesso, encode è il predefinito e un solo payload resta utile. Entrambe le direzioni riportano mode, il text originale, result, un campo length della stringa di uscita principale, bits_per_char a quindici, etichette alphabet e plane e un breve riferimento allo standard così i client possono affermare il profilo. Encode riporta anche input_bytes; decode riporta output_bytes. Text mancante, oggetti non stringa, valori di mode non supportati, stringhe più lunghe del massimo documentato, caratteri Base32768 non riconosciuti, un carattere secondario di riempimento prima della fine, disallineamenti dei bit di riempimento o byte decodificati non UTF-8 validi falliscono con invalid_input e un messaggio chiaro in inglese. Controlli classici includono la codifica di Hello in un breve blocco Base32768 di tre caratteri, la codifica della frase hello world nella stringa di riferimento nota del formato e la decodifica di quella stringa al payload originale di undici byte. Il prezzo delle chiamate API riuscite è la base pubblicata di $0.002 per elemento.
Dove Base32768 compare nel lavoro reale
Blob di salvataggio di gioco incorporati in JSON, impronte compatte di configurazione mosse tramite API degli appunti e token offline brevi che devono sopravvivere ad andate e ritorni di stringhe JavaScript traggono tutti vantaggio da quindici bit per carattere. Poiché questa capacità è un motore parse puro, il prezzo API è la base pubblicata di $0.002 per elemento riuscito e la convalida fallita non consuma saldo.
Casi di integrazione
Fixture golden multi-runtime
Generi vettori encode e decode allineati al riferimento qntm Base32768 così la CI multilingue condivide un'unica verità sull'impacchettamento a quindici bit.
Convalida rigorosa all'incolla
Decodifichi stringhe Base32768 incollate dall'utente con errori invalid_input chiari quando un simbolo esce dall'alfabeto primario o secondario.