# இருமம் முதல் ஹெக்ஸ்: வலமிருந்து நான்கு நான்காகக் குழுவாக்குங்கள்

> பிட் தொடரை ஹெக்ஸாடெசிமலாகக் கையால் சுருக்குவது எப்படி, மாற்றியால் சரிபார்த்த எடுத்துக்காட்டுகள், 1010 0101 என்பது A5 அல்லாமல் 0A 05 ஆக வருவதற்கான byte-வாரி செயல்பாடு.

- Tool: [இருமம் முதல் ஹெக்ஸ் மாற்றி](https://toolsg.com/ta/binary-to-hex)
- Language: ta (available: en, zh, ms, ta)
- Last verified against official sources: 2026-10-18
- Source site: ToolSG — a planning guide, not official or financial advice. Cite the agencies listed under Sources.

## முக்கிய எண்கள் ஒரே பார்வையில்

| விவரம் | மதிப்பு | ஆதாரம் |
| --- | --- | --- |
| குழுவாக்கும் விதி | 4 பிட் = 1 ஹெக்ஸ் இலக்கம், வலமிருந்து எண்ணுதல் — இடது கோடிக் குழு குறுகியிருந்தால் பூஜ்யங்களால் நிரப்புங்கள். |  |
| கருவி எதை ஒரு byte ஆகக் கருதுகிறது | இடைவெளியால் பிரிக்கப்பட்ட, அதிகபட்சம் 8 இருமம் இலக்கக் குழு — குறுகிய குழு இடப்பக்கம் நிரப்பப்படும்; எனவே 1010 என்பது 0A. |  |
| வெளியீட்டு வடிவம் | ஒவ்வொரு byte-க்கும் இரண்டு பெரிய எழுத்து ஹெக்ஸ் இலக்கங்கள், இடைவெளியால் பிரிக்கப்பட்டு — முன்பூஜ்யங்கள் தக்கவைக்கப்படும்: 00001010 என்பது 0A. |  |
| JavaScript-இல் அதே மாற்றம் | `parseInt("10100111", 2).toString(16)` திருப்புவது "a7" — உள்ளமைந்த முறை சிறிய எழுத்தையும் முன்பூஜ்யம் இல்லாமலும் தரும். | [MDN Number.prototype.toString](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString) |

## இருமத்திலிருந்து ஹெக்ஸுக்குக் கையால்

111110100 (பதின்மத்தில் 500) என்ற, முழு byte-களை நிரப்பாத நீளத்துக்குக் காட்டப்பட்டுள்ளது.

1. **வலமிருந்து நான்கு நான்காக எண்ணுங்கள்** — 111110100 என்பது 1 | 1111 | 0100 எனப் பிரியும்.
2. **இடது கோடிக் குழுவைப் பூஜ்யங்களால் நிரப்புங்கள்** — 1 என்பது 0001 ஆகி, 0001 1111 0100 கிடைக்கும்.
3. **ஒவ்வொரு குழுவையும் அதன் ஹெக்ஸ் இலக்கத்தால் மாற்றுங்கள்** — 0001 என்பது 1, 1111 என்பது F, 0100 என்பது 4; எனவே முடிவு 1F4.
4. **முழு byte-களுக்குக் கருவியைப் பயன்படுத்துங்கள்** — கருவி byte byte ஆக வேலை செய்யும்; 10100111 போன்ற 8 பிட் மதிப்புக்கு A7 தரும். கருவிகள்: [இருமம் முதல் ஹெக்ஸ் மாற்றி](https://toolsg.com/ta/binary-to-hex)

## ஒவ்வோர் ஹெக்ஸ் இலக்கத்துக்கும் ஏன் நான்கு பிட்கள்

இருமம் தொடர்கள் விரைவில் நீளமாகிவிடும். 16 என்பது 2-இன் 4-ஆம் அடுக்கு என்பதால், ஒவ்வொரு நான்கு பிட் தொகுதியும் சரியாக ஓர் ஹெக்ஸ் இலக்கத்துக்கு ஒத்திருக்கும்; எனவே எந்தக் கணக்கும் இன்றி பிட் தொடரைச் சுருக்கலாம். எங்கிருந்து எண்ணத் தொடங்குவது என்பதே கவனிக்க வேண்டியது: எப்போதும் **வலமிருந்து**, ஏனெனில் மிக வலது பிட் மிகக் குறைந்த முக்கியத்துவமுடையது. நீளம் நான்கின் மடங்கல்லாதபோது இடமிருந்து தொடங்கினால் விடை தவறாகும்.

## கணக்கீட்டு எடுத்துக்காட்டுகள்

| இருமம் | நான்கு நான்காகக் குழுவாக்கியது | ஹெக்ஸ் |
| --- | --- | --- |
| `10100111` | 1010 0111 | `A7` |
| `11010110` | 1101 0110 | `D6` |
| `01111111` | 0111 1111 | `7F` |
| `10101010` | 1010 1010 | `AA` |
| `01000001 01000010` | 0100 0001, 0100 0010 | `41 42` |
| `1111000010101010` | 1111 0000 1010 1010 | `F0 AA` |
| `11111111 10001000 00000000` | மூன்று byte-கள் | `FF 88 00` |

மேலுள்ள ஹெக்ஸ் மதிப்புகள் அனைத்தும் மாற்றியின் சொந்த வெளியீடு. கடைசி வரி நிறக் குறியீட்டின் வடிவில் உள்ளது: முன்னால் `#` சேர்த்தால் CSS-இல் `FF8800` ஒரு பளிச்சென்ற ஆரஞ்சு.

## உங்கள் பிட்களை மாற்றி எப்படிப் படிக்கிறது

கருவி byte அடிப்படையிலானது. பிரிக்கப்பட்ட ஒவ்வொரு குழுவும் ஒரு byte; எனவே இலக்கங்களுக்கு இடையே இடைவெளியை எப்படி வைக்கிறீர்கள் என்பதைப் பொறுத்தே காட்சி அமையும்.

| நீங்கள் உள்ளிடுவது | முடிவு | காரணம் |
| --- | --- | --- |
| `10100111` | `A7` | ஒரு byte |
| `1010 0111` | `0A 07` | இரண்டு தனி byte-கள்; ஒவ்வொன்றும் எட்டு பிட்டாக நிரப்பப்படும் |
| `1010` | `0A` | குறுகிய குழு இடப்பக்கம் நிரப்பப்படும் |
| `1111000010101010` | `F0 AA` | இடைவெளியற்ற தொடர் ஒவ்வொரு 8 இலக்கத்திலும் வெட்டப்படும் |
| `111110100` | நீளப் பிழை | ஒரே தொடரில் ஒன்பது இலக்கங்களை byte-களாகப் பிரிக்க முடியாது |

எனவே ஒற்றைப்படை நீளங்களுக்குக் கையால் செய்யும் முறைக்கு இந்தக் கருவி மாற்றாகாது. மேலுள்ள ஒன்பது பிட் மதிப்புக்கு `1F4` போன்ற ஒற்றை ஹெக்ஸ் எண் வேண்டுமானால், படிகளில் உள்ளபடி குழுவாக்குவதைக் கையால் செய்து, ஒவ்வொரு byte-ஐயும் கருவியால் உறுதிசெய்யுங்கள்.

> **குறிப்பு:** நான்கு நான்காக (nibble) இடைவெளி விடப்பட்ட இருமம் dump-ஐ ஒட்டும்போது, முதலில் இடைவெளிகளை நீக்குங்கள்; இல்லையெனில் கருவி ஒவ்வொரு nibble-ஐயும் நிரப்பப்பட்ட தனி byte ஆக்கிவிடும்.

## பொதுவான தவறுகள்

- **nibble-களுக்கு இடைவெளி விட்டு ஒரே எண் எதிர்பார்த்தல்.** `1010 0101` என்பது `A5` அல்ல, `0A 05` தரும். அதற்குப் பதிலாக `10100101` என எழுதுங்கள்.
- **இடமிருந்து குழுவாக்குதல்.** `1101101` வலமிருந்து குழுவாக்கினால் `6D` (0110 1101), `DA` அல்ல.
- **வெளியீட்டில் முன்பூஜ்யத்தை மறத்தல்.** `00001010` என்பது `A` அல்ல, `0A`; மாற்றி ஒவ்வொரு byte-க்கும் எப்போதும் இரண்டு இலக்கங்களைக் காட்டும்.
- **சிறிய, பெரிய எழுத்துகளை வெவ்வேறு மதிப்புகளாகக் கருதுதல்.** `a7`, `A7` ஒரே மதிப்பு; கருவி பெரிய எழுத்தில் காட்டும்.

## தொடர்புடைய கருவிகள்

- [ஹெக்ஸ் முதல் இருமம்](https://toolsg.com/ta/hex-to-binary) எதிர்த் திசை மாற்றம்.
- [இருமம் முதல் பதின்மம்](https://toolsg.com/ta/binary-to-decimal) அதே byte-இன் 0 முதல் 255 மதிப்பைத் தரும்.
- [இருமம் முதல் எண்மம்](https://toolsg.com/ta/binary-to-octal) நான்குக்குப் பதிலாக மூன்று மூன்றாகக் குழுவாக்கும்.
- [இருமம் முதல் உரை](https://toolsg.com/ta/binary-to-text) byte-களை எழுத்துகளாகப் படிக்கும்.

## அடிக்கடி கேட்கப்படும் கேள்விகள்

**என் தரவு எங்காவது அனுப்பப்படுகிறதா?**

இல்லை. மாற்றம் முழுவதும் உங்கள் உலாவியில் JavaScript மூலம் நடக்கிறது. நீங்கள் ஒட்டுவது உங்கள் சாதனத்தை விட்டு வெளியேறாது, பதிவு செய்யப்படாது, சேமிக்கப்படாது.

**மதிப்புகளை எப்படிப் பிரிக்க வேண்டும்?**

இடைவெளி வேலை செய்யும், காற்புள்ளி, முக்காற்புள்ளி, அரைப்புள்ளியும் வேலை செய்யும். இருமம், ஹெக்ஸ், எண்மத்திற்கு பிரிப்பின்றி ஒரே தொடர் இலக்கங்களையும் ஒட்டலாம் — அது தானாக byte-களாகப் பிரிக்கப்படும்.

**Emoji மற்றும் ஆங்கிலம் அல்லாத உரையைக் கையாளுமா?**

ஆம். உரை UTF-8 ஆகக் கருதப்படுகிறது, எனவே சீனம், தமிழ் மற்றும் emoji அனைத்தும் சரியாக மாற்றப்படும். அவை ஒவ்வொன்றும் ஒன்றுக்கு மேற்பட்ட byte-களை எடுத்துக்கொள்ளும்.

**ஏன் பிழை வந்தது?**

உள்ளீட்டில் மூல வடிவத்திற்குச் செல்லாத எழுத்து, 255-ஐ விட அதிக மதிப்பு, அல்லது byte-களாகச் சமமாகப் பிரியாத இலக்கத் தொடர் இருந்தது. எந்தப் பகுதி என்பதைப் பிழைச் செய்தி குறிப்பிடும்.


## ஆதாரங்கள்

- [MDN: Number.prototype.toString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString) — toString(16) gives lower-case hexadecimal digits with no padding.
- [MDN: parseInt()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt) — parseInt(string, 2) reads binary digits.
