# இருமம் முதல் பதின்மம்: இட மதிப்பு, இரட்டிப்பு முறை, இந்த மாற்றி ஏற்பவை

> இருமம் எண்ணைப் பதின்மமாகக் கையால் படிப்பது எப்படி, மாற்றியால் சரிபார்த்த எடுத்துக்காட்டுகள், கருவி ஏற்கும் 0 முதல் 255 வரையிலான குழுக்களுக்கான துல்லிய விதிகள்.

- Tool: [இருமம் முதல் பதின்மம் மாற்றி](https://toolsg.com/ta/binary-to-decimal)
- 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.

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

| விவரம் | மதிப்பு | ஆதாரம் |
| --- | --- | --- |
| ஒரு byte-இல் பிட் எடைகள் | 128 · 64 · 32 · 16 · 8 · 4 · 2 · 1 — ஒவ்வொரு இடமும் அதன் வலப்பக்க இடத்தைவிட இரு மடங்கு மதிப்புடையது. |  |
| கருவி ஏற்கும் மிகப் பெரிய குழு | 11111111 = 255 — இருமம் இலக்கங்களின் ஒவ்வொரு குழுவும் ஒரு byte ஆகக் கருதப்படும்; 255-ஐ மீறினால் நிராகரிக்கப்படும். |  |
| குழுக்கள் எப்படிப் பிரிக்கப்படுகின்றன | இடைவெளி, காற்புள்ளி, அரைப்புள்ளி, முக்காற்புள்ளி, அடிக்கோடு அல்லது இணைப்புக்குறியால் பிரிக்கலாம்; இடைவெளியின்றி ஒரே தொடர் இருந்தால் ஒவ்வொரு 8 இலக்கத்திலும் வெட்டப்படும் |  |
| JavaScript-இல் அதே மாற்றம் | `parseInt("11010110", 2)` திருப்புவது 214 | [MDN parseInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt) |

## இருமம் எண்ணைக் கையால் படித்தல்

சமமான இரண்டு முறைகள்; சரிபார்க்க எளிதானதைத் தேர்ந்தெடுங்கள்.

1. **இலக்கங்களின் கீழே எடைகளை எழுதுங்கள்** — வலது முனையில் 1-இல் தொடங்கி, இடப்பக்கம் ஒவ்வொரு படியும் இரட்டிப்பாக்குங்கள்: 1, 2, 4, 8, 16, 32, 64, 128.
2. **இலக்கம் 1 உள்ள இடங்களின் எடைகளைக் கூட்டுங்கள்** — 0 உள்ள இடங்களை விட்டுவிடுங்கள். மொத்தமே பதின்ம மதிப்பு.
3. **அல்லது இடமிருந்து வலமாகப் படிக்கும்போதே இரட்டிப்பாக்குங்கள்** — 0-இல் தொடங்குங்கள். ஒவ்வொரு இலக்கத்துக்கும் தற்போதைய மொத்தத்தை இரட்டிப்பாக்கி அந்த இலக்கத்தைக் கூட்டுங்கள். எடைகளை எழுத வேண்டியதில்லை.
4. **மாற்றியால் சரிபார்க்கவும்** — இலக்கங்களைக் கருவியில் ஒட்டுங்கள். முடிவு வேறுபட்டால், பெரும்பாலும் ஓர் எடை தவறான இடத்தில் வைக்கப்பட்டிருக்கும். கருவிகள்: [இருமம் முதல் பதின்மம் மாற்றி](https://toolsg.com/ta/binary-to-decimal)

## அடிப்படை 2-இல் இடமதிப்பு முறை

பதின்மத்தில் 214 என்பது 2 நூறு, 1 பத்து, 4 ஒன்று என்று பொருள்படும்: ஒவ்வொரு இடமும் வலப்பக்க இடத்தைவிடப் பத்து மடங்கு. இருமம் அதே எண்ணத்தை இரண்டு என்ற பெருக்கியுடன் பயன்படுத்துகிறது. இலக்கங்கள் 0, 1 மட்டுமே; இடங்களின் மதிப்பு 1, 2, 4, 8, 16, 32, 64, 128 எனத் தொடரும். இலக்கம் 1 அந்த எடையைச் சேர்க்கும், 0 சேர்க்காது.

`11010110`-க்குச் சேரும் எடைகள் 128, 64, 16, 4, 2; 128 + 64 + 16 + 4 + 2 = 214.

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

| இருமம் | சேரும் எடைகள் | பதின்மம் |
| --- | --- | --- |
| `1101` | 8 + 4 + 1 | 13 |
| `101010` | 32 + 8 + 2 | 42 |
| `1100100` | 64 + 32 + 4 | 100 |
| `11010110` | 128 + 64 + 16 + 4 + 2 | 214 |
| `00110011` | 32 + 16 + 2 + 1 | 51 |
| `11111111` | எட்டு எடைகளும் | 255 |

இந்த ஆறு மதிப்புகளும் மாற்றியின் சொந்தக் குறியீட்டை இயக்கிப் பெறப்பட்டவை. முன்னால் உள்ள பூஜ்யங்கள் மதிப்பை மாற்றாது; `00110011`, `110011` இரண்டும் 51.

## இந்த மாற்றி எதை ஏற்கிறது

- ஒவ்வொரு குழுவும் ஒரு **byte**; எனவே செல்லுபடியாகும் மிகப் பெரிய குழு `11111111` (255). `111111111 1` போல மற்ற குழுக்களுக்கு நடுவில் ஒன்பது அல்லது அதற்கு மேற்பட்ட இலக்கங்கள் இருந்தால் வரம்பை மீறியதாகக் காட்டப்படும்.
- பல குழுக்கள் பல எண்களைத் தரும்: `1111 0000 10101010` என்பது `15 0 170`.
- இடைவெளியின்றி ஒரே தொடர் இருந்தால் ஒவ்வொரு 8 இலக்கத்திலும் வெட்டப்படும்; `1111000010101010` என்பது `240 170`. தொடரின் நீளம் 8-இன் மடங்கல்லாவிட்டால் (எ.கா. தொடர்ச்சியாக ஒன்பது இலக்கங்கள்) நீளப் பிழைச் செய்தி வரும்.
- `0`, `1` மட்டுமே செல்லுபடியாகும் இலக்கங்கள். `13` போன்ற உள்ளீடு நிராகரிக்கப்படும்.
- பின்னங்களும் முன்னொட்டுகளும் இல்லை: `0b101` உள்ள `b` காரணமாக நிராகரிக்கப்படும். கழித்தல் குறி எதிர்மறைக் குறியாக அல்ல, பிரிப்பானாகக் கருதப்படும்.
- வெளியீடு சாதாரணப் பதின்மம்; ஒவ்வொரு உள்ளீட்டுக் குழுவுக்கும் ஒரு எண், ஒற்றை இடைவெளியால் பிரிக்கப்பட்டு.

> **குறிப்பு:** நீண்ட இருமம் எண்ணை மாற்ற, அதை அதிகபட்சம் 8 இலக்கக் குழுக்களாகப் பிரித்து ஒவ்வொன்றையும் மாற்றுங்கள்; பின்னர் 2-இன் அடுக்குகளால் கையால் இணையுங்கள் (ஒவ்வொரு குழுவும் அதன் வலப்பக்கத்தில் உள்ள ஒவ்வொரு குழுவுக்கும் 256 ஆல் பெருக்கப்படும்).

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

- **எடைகளை இடமிருந்து எண்ணுதல்.** மிக வலது இலக்கத்தின் மதிப்பு 1; மிக இடது இலக்கத்தின் மதிப்பு அல்ல.
- **முடிவை குறியுடையதாகக் கருதுதல்.** கருவி எப்போதும் குறியற்ற மதிப்பையே தரும்; எனவே `11111111` என்பது 255. இரண்டின் நிரப்பியில் 8-பிட் குறியுடைய எண்ணாகக் கொண்டால் அது -1; ஆனால் அது அதே பிட்களுக்கான வேறு விளக்கம்.
- **`0b` முன்னொட்டை ஒட்டுதல்.** முதலில் நீக்குங்கள்; மாற்றி இலக்கங்களை மட்டுமே ஏற்கும்.
- **இடைவெளி byte-களைப் பிரிக்கும் என்பதை மறத்தல்.** `1010 0101` என்பது இரண்டு எண்கள் (10, 5); ஒரே எண் 165 அல்ல.

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

- [பதின்மம் முதல் இருமம்](https://toolsg.com/ta/decimal-to-binary) எதிர்த் திசை மாற்றம்.
- [இருமம் முதல் ஹெக்ஸ்](https://toolsg.com/ta/binary-to-hex) ஒவ்வொரு இலக்கத்துக்கும் நான்கு பிட்களாகச் சேர்த்து நீண்ட பிட் தொடரைச் சுருக்கும்.
- [இருமம் முதல் எண்மம்](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: parseInt()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt) — Parsing a string in radix 2 to 36.
- [MDN: Number.prototype.toString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString) — The reverse direction, radix 2 to 36.
