இருமம் முதல் ஹெக்ஸ் மாற்றி

உங்கள் உலாவியிலேயே இருமம்-ஐ ஹெக்ஸ் ஆக உடனடியாக மாற்றுங்கள்.

0 எழுத்துகள்

0 எழுத்துகள்

அனைத்தும் உங்கள் உலாவியில் மாற்றப்படுகிறது. நீங்கள் ஒட்டுவது பதிவேற்றப்படவோ சேமிக்கப்படவோ இல்லை.

செயல்முறை எடுத்துக்காட்டு

ஒவ்வொரு வரியும் இருமம் ஆக எழுதப்பட்ட ஒரு சிறு மாதிரியையும், அதே மதிப்பு ஹெக்ஸ் ஆக மாற்றப்பட்டதையும் காட்டுகிறது.

இருமம் உள்ளீடு ஹெக்ஸ் வெளியீடு
01001000 01101001 48 69
01010011 01000111 53 47
01110100 01101111 01101111 01101100 74 6F 6F 6C

விரிவான வழிகாட்டி

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

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

கடைசியாகச் சரிபார்க்கப்பட்டது: ஆதாரங்கள்: MDN Number.prototype.toString இந்த வழிகாட்டியின் எளிய உரை

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

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

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

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

  1. படி 1: வலமிருந்து நான்கு நான்காக எண்ணுங்கள்

    111110100 என்பது 1 | 1111 | 0100 எனப் பிரியும்.

  2. படி 2: இடது கோடிக் குழுவைப் பூஜ்யங்களால் நிரப்புங்கள்

    1 என்பது 0001 ஆகி, 0001 1111 0100 கிடைக்கும்.

  3. படி 3: ஒவ்வொரு குழுவையும் அதன் ஹெக்ஸ் இலக்கத்தால் மாற்றுங்கள்

    0001 என்பது 1, 1111 என்பது F, 0100 என்பது 4; எனவே முடிவு 1F4.

  4. படி 4: முழு byte-களுக்குக் கருவியைப் பயன்படுத்துங்கள்

    கருவி byte byte ஆக வேலை செய்யும்; 10100111 போன்ற 8 பிட் மதிப்புக்கு A7 தரும்.

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

இருமம் தொடர்கள் விரைவில் நீளமாகிவிடும். 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 ஒரே மதிப்பு; கருவி பெரிய எழுத்தில் காட்டும்.

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

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

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

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

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

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

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

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

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

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

ஆதாரங்கள்

  1. MDN: Number.prototype.toString() — toString(16) gives lower-case hexadecimal digits with no padding.
  2. MDN: parseInt() — parseInt(string, 2) reads binary digits.

இந்த வழிகாட்டி வெளியிடப்பட்ட விதிகளை எளிய மொழியில் விளக்குகிறது. இது நிதி, சட்ட அல்லது அதிகாரப்பூர்வ ஆலோசனை அல்ல — விதிகள் மாறக்கூடும், எனவே முடிவெடுக்கும் முன் மேலே இணைக்கப்பட்ட அமைப்பிடம் உறுதிப்படுத்துங்கள்.

தொடர்புடைய மாற்றிகள்