ટેક્સ્ટ hex convert _

Hex encoding કેવી?

પેજ પરનો દરેક અક્ષર એક અથવા વધુ બાઇટ્સ તરીકે સંગ્રહિત થાય છે. Hex એન્કોડિંગ એ બાઇટ્સને બેઝ 16 માં ફરી લખે છે, બાઇટ દીઠ બે અક્ષર, જેથી બાઇટ સ્ટ્રીમ કોઈ ખાસ સાધન વગર વાંચી શકાય.

1. લખાણને બાઇટ્સમાં એન્કોડ કરો. UTF-8 મોડ ઇનપુટને new TextEncoder().encode(text) દ્વારા ચલાવે છે, જે બાઇટ મૂલ્યોની Uint8Array પરત આપે છે. Latin-1 મોડ charCodeAt(0) & 0xFF દ્વારા દરેક કોડ યુનિટના નીચલા આઠ બિટ્સ લે છે, જે જૂના ISO-8859-1 કોડેક્સ કરે છે તે રૂપાંતરણ છે.
2. દરેક બાઇટને બે hex અંકો તરીકે રેન્ડર કરો. દરેક બાઇટ byte.toString(16).padStart(2, "0") દ્વારા બે hex અંકોમાં મેપ થાય છે. કેસ ટૉગલ આઉટપુટ અક્ષરો પર અપરકેસ (A-F) અથવા લોઅરકેસ (a-f) પસંદ કરે છે.
3. જૂથબંધી અને પ્રીફિક્સ લાગુ કરો. ગ્રૂપિંગ બાઇટ્સ વચ્ચે એક વિભાજક દાખલ કરે છે: એક જ ખાલી જગ્યા, એક ડૅશ, અથવા દર ચાર બાઇટે એક ખાલી જગ્યા. 0x પ્રીફિક્સ આખી સ્ટ્રિંગ પર એક વાર (None ગ્રૂપિંગ) અથવા બાઇટ દીઠ (Space ગ્રૂપિંગ) આગળ ઉમેરી શકાય છે, જે C arrays અને binary diff સાધનો અપેક્ષા રાખે છે તે પ્રથાઓ સાથે મેળ ખાય છે.
4. Reverse decode. Hex → Text મોડ ઇનપુટમાંથી દરેક ખાલી જગ્યા, ડૅશ, અને 0x પ્રીફિક્સ કાઢી નાખે છે, બાકીના અક્ષરોને /^[0-9a-fA-F]+$/ સામે માન્ય કરે છે, વિષમ-લંબાઈની સ્ટ્રિંગ નકારે છે, અને ક્રમિક બાઇટ જોડીઓમાંથી Uint8Array ફરી બનાવે છે. UTF-8 મોડ એ array ને new TextDecoder("utf-8", { fatal: true }) વડે ડિકોડ કરે છે; Latin-1 મોડ દરેક બાઇટને String.fromCharCode(b) પર મેપ કરે છે.
5. ઝડપી પુનરાવર્તન માટે લાઇવ મોડ. લાઇવ મોડ ડિફૉલ્ટ રૂપે ચાલુ છે. દરેક કીસ્ટ્રોક 150 ms debounced ફરી-કન્વર્ટ શેડ્યૂલ કરે છે જેથી તમે Convert બટન ક્લિક કર્યા વગર પેસ્ટ કરી, સંપાદન કરી, અને બીજા પેનને અપડેટ થતું જોઈ શકો.

Hex converter કેમ?

• બાઇનરી પ્રોટોકોલ ડીબગ કરવા. Modbus, DNP3, અને CoAP જેવા wire formats તેમના હેડરોને ચોક્કસ બાઇટ ઑફસેટ્સમાં પૅક કરે છે. કૅપ્ચર કરેલ ફ્રેમને hex તરીકે વાંચવાથી દરેક ક્ષેત્ર એક નજરમાં દેખાય છે, અને એ જ બાઇટ્સને પાછા ASCII માં ફેરવવાથી binary framing ની સાથે રહેલો કોઈપણ plaintext payload સામે આવે છે.
• Embedded firmware સાથે કામ કરવું. JTAG અને SWD probes મેમરી સામગ્રીને hex તરીકે રિપોર્ટ કરે છે. મેમરીના કોઈ ભાગને ASCII માં અનુવાદ કરવાથી embedded strings (ફાઇલ પાથ, ભૂલ સંદેશા, vendor signatures) મળે છે જે ઘણીવાર બતાવે છે કે તમે firmware માં ક્યાં જોઈ રહ્યા છો.
• Packet captures read. Wireshark અને tcpdump બંને એક બાઇટ પેન આપે છે જે દરેક પૅકેટને ડાબી બાજુ hex તરીકે અને જમણી બાજુ ASCII તરીકે છાપે છે. અહીં એક snippet કન્વર્ટ કરવાથી તમે કોઈ bug report અથવા chat log માંથી hex blob કૉપિ કરી શકો છો અને બાઇટ્સ ખરેખર શું કહે છે તે વાંચી શકો છો, એમને કોઈ capture સાધનમાં ફરી import કર્યા વગર.
• Byte-level diffs. બે binary files ની સરખામણી ઘણીવાર ક્યા બાઇટ્સ બદલાયા તે શોધવા સુધી આવી જાય છે. બંને બાજુને એકસમાન ગ્રૂપિંગ સાથે hex માં કન્વર્ટ કરવાથી diff કોઈ ટેક્સ્ટ એડિટરમાં લાઇનઅપ થાય છે, જ્યાં બિલ્ટ-ઇન diff સાધન બદલાયેલા બાઇટ્સ હાઇલાઇટ કરી શકે છે.

સામાન્ય ઉપયોગ

Hex ↔ ASCII કન્વર્ઝન reverse engineering, security, અને embedded કામ દરમ્યાન ત્યારે સામે આવે છે જ્યારે પણ બાઇટ સ્ટ્રીમ માત્ર એક text payload કરતાં વધુ હોય.

• Reverse engineering: strings-resistant binary માંથી hex dump લો, એવા runs પસંદ કરો જે printable ASCII તરીકે ડિકોડ થાય છે, અને disassembly માં તમે ક્યાં છો તે નક્કી કરવા માટે એ strings નો ઉપયોગ કરો.
• Network forensics: Wireshark માંથી એક જ પૅકેટ payload ને hex તરીકે કૉપિ કરો, અહીં પેસ્ટ કરો, અને આખા capture ને export કર્યા વગર application-layer text વાંચો.
• Crypto material handling: key, IV, અથવા HMAC tag ઘણીવાર hex સ્ટ્રિંગ તરીકે આવે છે. પાછા બાઇટ્સમાં ડિકોડ કરવાથી તમે કૉન્ફિગમાં જોડો તે પહેલાં લંબાઈ algorithm સાથે મેળ ખાય છે તેની પુષ્ટિ થાય છે (AES-128 માટે 16 બાઇટ્સ, AES-256 માટે 32).

ઉદાહરણ

Text → Hex, UTF-8, lowercase, Space-every-byte ગ્રૂપિંગ, prefix બંધ પસંદ કરો. Hi ટાઇપ કરો: આઉટપુટ 48 69 વાંચે છે. prefix ચાલુ કરો અને ગ્રૂપિંગ None કરો તો એ જ ઇનપુટ 0x4869 તરીકે રેન્ડર થાય છે. emoji 😀 ને ઇનપુટ તરીકે પેસ્ટ કરો અને UTF-8 મોડ f0 9f 98 80 રેન્ડર કરે છે — એક code point માટે ચાર બાઇટ્સ, જે કારણથી emoji ઘણીવાર transmission કદ વધારે છે. Hex → Text પર સ્વિચ કરો અને 0x48-65-6C 6C 6F પેસ્ટ કરો: પાર્સર પ્રીફિક્સ, ડૅશ, અને ખાલી જગ્યાઓ કાઢી નાખે છે અને Hello ફરી બનાવે છે.

FAQ

Hex encoding શું?

Hex એન્કોડિંગ (અથવા hexadecimal encoding) બાઇટ સ્ટ્રીમને બેઝ 16 માં લખે છે, બાઇટ દીઠ બે ASCII અક્ષરો. દરેક hex અંક ચાર બિટ્સ આવરી લે છે, તેથી બે અંકો એક આઠ-બિટ બાઇટ આવરી લે છે. વર્ણમાળા 0-9 પછી A-F (અથવા a-f) ચાલે છે; કેસ સંપૂર્ણપણે રજૂઆતની પસંદગી છે અને decoders બંને સ્વીકારે છે. Hex એ protocol specs, debugger output, અને crypto keys માં raw bytes લખવાની પ્રમાણભૂત રીત છે કારણ કે તે binary કરતાં બમણું compact છે અને text માં raw bytes ની unprintable-character સમસ્યાઓ ટાળે છે.

મારો emoji hex માં ચાર બાઇટ કેમ બને છે?

UTF-8 એ variable-length encoding છે. ASCII અક્ષરો (U+0000 થી U+007F) એક બાઇટ લે છે, Latin-1 supplements બે લે છે, મોટાભાગના અન્ય BMP code points ત્રણ લે છે, અને U+FFFF થી ઉપરના અક્ષરો — જેમાં મોટાભાગના emoji સામેલ છે — ચાર લે છે. smiling face 😀 એ U+1F600 છે અને F0 9F 98 80 માં encode થાય છે. જો તમને fixed-width બાઇટ વ્યૂ જોઈતો હોય, તો Latin-1 પર સ્વિચ કરો — પણ Latin-1 માત્ર પ્રથમ 256 code points આવરી લે છે, તેથી એ range ની બહારનો કોઈપણ અક્ષર round-trip કરી શકતો નથી.

શું આ Latin-1 / ISO-8859-1 ને સપોર્ટ કરે છે?

હા. Text encoding વિકલ્પને Latin-1 (ISO-8859-1) પર સ્વિચ કરો. Encoding દરેક JavaScript code unit ના નીચલા આઠ બિટ્સ લે છે (charCodeAt(0) & 0xFF), જે જૂના single-byte mapping સાથે મેળ ખાય છે. Decoding દરેક બાઇટ માટે String.fromCharCode(byte) વાપરે છે. Latin-1 ત્યારે વાપરો જ્યારે તમે જૂના Windows-1252 અથવા pre-Unicode સિસ્ટમના આઉટપુટ સાથે કામ કરી રહ્યા હો જ્યાં દરેક બાઇટ બરાબર એક અક્ષરનું પ્રતિનિધિત્વ કરે છે.

શું રૂપાંતર મારા બ્રાઉઝરમાં થાય છે?

હા. કન્વર્ટર TextEncoder, TextDecoder, અને એક નાનું પાર્સર એક જ static page તરીકે ચલાવે છે. કોઈ upload નથી, કોઈ API call નથી, અને તમે જે પેસ્ટ કરો છો તેના પર કોઈ analytics નથી — માત્ર સાઇટભરમાં shared પ્રમાણભૂત page-load metrics. તમે અહીં જે hex bytes જુઓ છો તે જ છે જે Node script અથવા Lambda function એ જ ઇનપુટ સામે ઉત્પન્ન કરશે.

Hex ↔ ASCII binary protocols read, embedded firmware — day several times small job. Browser tab, Node V8 native encoders same — fast, byte stream machine.