# ஹெக்ஸ் முதல் இருமம்: ஓர் இலக்கம், நான்கு பிட்கள்

> ஒவ்வொரு ஹெக்ஸாடெசிமல் இலக்கமும் ஏன் சரியாக நான்கு இருமம் இலக்கங்களாக விரிகிறது, முழு இலக்க அட்டவணை, மாற்றியால் சரிபார்த்த நிறக் குறியீடு, byte எடுத்துக்காட்டுகள், முன்னொட்டுகள், எழுத்து வடிவம், ஒற்றைப்படை நீள உள்ளீட்டை கருவி எப்படிக் கையாள்கிறது.

- Tool: [ஹெக்ஸ் முதல் இருமம் மாற்றி](https://toolsg.com/ta/hex-to-binary)
- 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 (ஓர் இலக்கம் 0 முதல் 15 வரை) — எனவே இரண்டு ஹெக்ஸ் இலக்கங்கள் ஒரு byte; அதனால்தான் byte-களை எழுத ஹெக்ஸ் வழக்கமான வழி. |  |
| கருவி நீக்கும் முன்னொட்டுகள் | 0x, \x, # — பெரிய அல்லது சிறிய எழுத்து இலக்கங்கள் இரண்டும் ஏற்கப்படும்; தளத்தின் மற்ற இடங்களில் ஹெக்ஸ் வெளியீடு பெரிய எழுத்தில் காட்டப்படும். |  |
| இடைவெளியற்ற உள்ளீடு | இரண்டிரண்டு இலக்கங்களாக வெட்டப்படும் — FFFF இரண்டு byte-கள் ஆகும். ஒரே தொடரில் 1F4 போல ஒற்றைப்படை எண்ணிக்கை இலக்கங்கள் இருந்தால் நிராகரிக்கப்படும். |  |
| நிறக் குறியீடுகள் | #RRGGBB என்பது மூன்று இணைகள், ஒவ்வொன்றும் 00 முதல் FF வரை | [MDN CSS hex-color](https://developer.mozilla.org/en-US/docs/Web/CSS/hex-color) |

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

1. **ஹெக்ஸ் எண்ணைத் தனித்தனி இலக்கங்களாகப் பிரியுங்கள்** — 3F என்பது 3, F என்று பிரியும்.
2. **ஒவ்வோர் இலக்கத்தையும் அதன் நான்கு பிட் வடிவத்தால் மாற்றுங்கள்** — 3 என்பது 0011, F என்பது 1111.
3. **குழுக்களை இணையுங்கள்** — 0011 1111; ஒரு byte ஆக இது 00111111. கருவிகள்: [ஹெக்ஸ் முதல் இருமம் மாற்றி](https://toolsg.com/ta/hex-to-binary)

## ஹெக்ஸ் ஏன் இருமத்துடன் இவ்வளவு நேர்த்தியாகப் பொருந்துகிறது

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

| ஹெக்ஸ் | இருமம் | ஹெக்ஸ் | இருமம் |
| --- | --- | --- | --- |
| 0 | 0000 | 8 | 1000 |
| 1 | 0001 | 9 | 1001 |
| 2 | 0010 | A | 1010 |
| 3 | 0011 | B | 1011 |
| 4 | 0100 | C | 1100 |
| 5 | 0101 | D | 1101 |
| 6 | 0110 | E | 1110 |
| 7 | 0111 | F | 1111 |

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

| ஹெக்ஸ் உள்ளீடு | இருமம் வெளியீடு |
| --- | --- |
| `3F` | `00111111` |
| `A5` | `10100101` |
| `80` | `10000000` |
| `0x1F` | `00011111` |
| `F` | `00001111` |
| `1F 4` | `00011111 00000100` |
| `#4F46E5` | `01001111 01000110 11100101` |

கடைசி வரி CSS பாணி நிறம்: 4F, 46, E5 ஆகிய இணைகள் சிவப்பு, பச்சை, நீலம் byte-கள்; எனவே மாற்றி ஒவ்வொன்றையும் தனி எட்டு பிட் குழுவாகக் காட்டுகிறது. மேலே உள்ள வெளியீடுகள் அனைத்தும் மாற்றியால் உருவாக்கப்பட்டவை.

## மாற்றி என்ன செய்கிறது

- `0x`, `\x`, `#` எங்கு வந்தாலும் நீக்கப்படும்; எனவே `0xFF 0x0A`, `#FF8800` இரண்டும் வேலை செய்யும்.
- எழுத்துகள் பெரிய அல்லது சிறிய வடிவில் இருக்கலாம்: `ff` = `FF`.
- ஒற்றை இலக்கம் முழு byte ஆகக் கருதப்படும்; `F` என்பது `00001111` தரும். நிரப்புதல் எப்போதும் இடப்பக்கமே, வலப்பக்கம் அல்ல.
- ஒரே தொடரில் இரண்டு அல்லது அதற்கு மேற்பட்ட இலக்கங்கள் இருந்தால் இணைகளாக வெட்டப்படும்: `FFFF` என்பது `11111111 11111111` தரும். `1F4` போல நீளம் இரட்டைப்படை இல்லையென்றால், ஊகிக்காமல் நீளப் பிழையைக் காட்டும்.
- நீங்களே குழுக்களைப் பிரித்தால், ஒவ்வொரு குழுவும் ஒரு byte ஆகப் படிக்கப்படும்; அது 00 முதல் FF வரை இருக்க வேண்டும். `100 1` தோல்வியடையும், ஏனெனில் `100` என்பது 256.

> **குறிப்பு:** `1F4`-ஐ ஒரே எண்ணாகப் படிக்க, மேலுள்ள அட்டவணையால் ஒவ்வோர் இலக்கத்தையும் விரியுங்கள்: `1`, `F`, `4` என்பது `0001 1111 0100`; முன்பூஜ்யங்களை நீக்கினால் `111110100` (பதின்மத்தில் 500). மாற்றி அதற்குப் பதிலாக `1`, `F`, `4` ஆகியவற்றை நிரப்பப்பட்ட மூன்று தனி byte-களாகக் காட்டும்.

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

- **ஒற்றைப்படை எண்ணிக்கை இலக்கங்கள்.** இணைகளாக்க முன்னால் ஒரு பூஜ்யம் சேருங்கள் (`01F4`), அல்லது குழுக்களைப் பிரியுங்கள்.
- **பூஜ்யத்துக்குப் பதிலாக O எழுத்தைத் தட்டச்சு செய்தல்.** A முதல் F வரை அல்லாத O, G போன்ற எழுத்துகள் தவறான பகுதியைக் குறிப்பிட்டு நிராகரிக்கப்படும்.
- **நீண்ட தொடரிலிருந்து ஒரே எண் எதிர்பார்த்தல்.** கருவி ஒரு பெரிய முழு எண்ணை அல்ல, byte-களைத் தருகிறது.
- **`#` மதிப்பின் பகுதி என்று நினைத்தல்.** அது CSS குறியீடு மட்டுமே; பிட்கள் எதையும் கொண்டிருக்காது.

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

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

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

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

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

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

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

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

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

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

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


## ஆதாரங்கள்

- [MDN: CSS hex-color](https://developer.mozilla.org/en-US/docs/Web/CSS/hex-color) — Six-digit colours are three hexadecimal pairs between 00 and ff.
- [MDN: parseInt()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt) — Parsing a hexadecimal string, including the optional 0x prefix.
- [MDN: Number.prototype.toString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString)
