ബേസുകൾക്കിടയിൽ നമ്പർ കൺവേർട്ട് ചെയ്യുക _

ബേസ് കൺവേർഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഓരോ പൊസിഷണൽ നമ്പർ സിസ്റ്റവും ഒരു മൂല്യത്തെ ബേസിന്റെ ശക്തികൾ കൊണ്ട് ഗുണിക്കപ്പെട്ട അക്കങ്ങളുടെ ആകെ തുകയായി പ്രതിനിധീകരിക്കുന്നു. ബേസ് മാറ്റുക എന്നത് ഒരേ മൂല്യം വ്യത്യസ്ത ഘാത ശ്രേണിക്കെതിരെ പുനഃരചിക്കുക എന്നതാണ്.

1. ഇൻപുട്ട് ആൽഫബറ്റ് മൂല്യനിർണ്ണയം. ഓരോ ബേസും ഒരു പ്രത്യേക അക്ക സെറ്റ് സ്വീകരിക്കുന്നു. ബൈനറി 0, 1 സ്വീകരിക്കുന്നു; ഓക്ടൽ 0-7; ഡെസിമൽ 0-9; hex 0-9 ഉം A-F ഉം. തിരഞ്ഞെടുത്ത ആൽഫബറ്റിന് പുറത്തുള്ള ഒരു ക്യാരക്ടർ, ഏതെങ്കിലും കൺവേർഷൻ പ്രവർത്തിക്കുന്നതിന് മുൻപ് ഇൻലൈൻ പിശക് കാണിക്കുന്നു.
2. മൂല്യം പാഴ്‌സ് ചെയ്യുക. JavaScript Number-ൽ ഉൾക്കൊള്ളുന്ന മൂല്യങ്ങൾക്ക് (2^53-1 വരെ) ടൂൾ parseInt(text, base) ഉപയോഗിക്കുന്നു. അതിന് മുകളിൽ, ഏകദേശ വലിയ ഇന്റിജറുകൾക്കും കൺവേർഷൻ കൃത്യമായി നിലനിർത്താൻ BigInt ലേക്ക് മാറുന്നു.
3. ഓരോ ടാർഗറ്റ് ബേസിലും വീണ്ടും റെൻഡർ ചെയ്യുക. പാഴ്‌സ് ചെയ്ത മൂല്യം Number.prototype.toString(base) അല്ലെങ്കിൽ BigInt.prototype.toString(base) വഴി ഓരോ ഔട്ട്‌പുട്ട് ബേസിലേക്കും കൺവേർട്ട് ആകുന്നു. നാല് സ്റ്റാൻഡേർഡ് പെയ്‌നുകൾ (ബൈനറി, ഓക്ടൽ, ഡെസിമൽ, hex) ഒരേ സമയം അപ്‌ഡേറ്റ് ആകുന്നു.
4. ഫോർമാറ്റിംഗ് പ്രയോഗിക്കുക. ഒരു പ്രിഫിക്സ് ടോഗിൾ ബൈനറി, ഓക്ടൽ, hex ഔട്ട്‌പുട്ടിൽ 0b, 0o, 0x ചേർക്കുന്നു. ഡിജിറ്റ് ഗ്രൂപ്പിംഗ് ഓരോ നാല് ബൈനറി അക്കത്തിലും ഓരോ രണ്ട് hex അക്കത്തിലും അണ്ടർസ്‌കോർ ഇൻസേർട്ട് ചെയ്യുന്നു. Hex കേസ് ടോഗിൾ A-F-നായി അപ്പർകേസ് അല്ലെങ്കിൽ ലോവർകേസ് തിരഞ്ഞെടുക്കുന്നു.
5. ലൈവ് ക്രോസ്-പെയ്ൻ സിൻക്. ഏത് പെയ്ൻ എഡിറ്റ് ചെയ്താലും 100 ms ഡിബൗൺസ്ഡ് റീ-കൺവേർഷൻ ട്രിഗർ ആകുന്നു, മറ്റ് പെയ്‌നുകൾ അപ്‌ഡേറ്റ് ആകുന്നു. ഓരോ കീസ്‌ട്രോക്കിലും നിങ്ങൾ ടൈപ്പ് ചെയ്യുന്ന പെയ്ൻ ട്രൂത്തിന്റെ ഉറവിടമായി കണക്കാക്കപ്പെടുന്നു.

ഒരു ബേസ് കൺവേർട്ടർ ഉപയോഗിക്കേണ്ടത് എന്തുകൊണ്ട്

• മെമ്മറി ഡംപ്‌സ് വായിക്കുക. ഡീബഗ്ഗർ, ഡിസ്അസ്സംബ്ലർ, കോർ-ഡംപ് വ്യൂവറുകൾ അഡ്രസ്സ്, റജിസ്‌റ്റർ മൂല്യങ്ങൾ hex-ൽ കാണിക്കുന്നു. അവ ഡെസിമലിലേക്ക് മൊഴിമാറ്റം ചെയ്യുക, ഒരേ ട്രേസിൽ മറ്റിടങ്ങളിൽ റിപ്പോർട്ട് ചെയ്ത കൌണ്ടുകൾ, സൈസ്, ഓഫ്‌സെറ്റ്സ് എന്നിവയുമായി തുലനം ചെയ്യാൻ.
• കളർ കോഡുകളുമായി പ്രവർത്തിക്കുക. CSS, ഡിസൈൻ ടൂളുകൾ, ഇമേജ് ഫോർമാറ്റുകൾ #d2511a പോലെ hex ട്രിപ്ലെറ്റ്‌സ് ആയി കളർ ഉപയോഗിക്കുന്നു. ഓരോ ജോടിയും ഡെസിമലിലേക്ക് കൺവേർട്ട് ചെയ്ത്, നിങ്ങളുടെ കളർ പിക്കർ അല്ലെങ്കിൽ ആക്‌സസിബിലിറ്റി ചെക്കർ പ്രതീക്ഷിക്കുന്ന rgb(210, 81, 26) ഫോർമിലേക്ക് മാറ്റൂ.
• ഫയൽ പെർമിഷൻ ഡീകോഡ് ചെയ്യുക. Unix chmod മൂല്യങ്ങൾ ഓക്ടലിൽ എഴുതപ്പെടുന്നു: 755 എന്നത് ഓരോ ഓക്ടൽ അക്കവും അതിന്റെ മൂന്ന് ബൈനറി ബിറ്റുകളിലേക്ക് ട്രാൻസ്‌ലേറ്റ് ചെയ്‌താൽ rwxr-xr-x ആണ്. ഒരു man പേജ് നോക്കാതെ ഒരു ഘട്ടത്തിൽ ആ മാപ്പിംഗ് കൺവേർട്ടർ കാണിക്കുന്നു.
• ബിറ്റ് ഫ്ലാഗ്‌സ് ഡീബഗ്ഗ് ചെയ്യുക. നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോൾ, കേർണൽ syscalls, ഹാർഡ്‌വെയർ രജിസ്‌റ്ററുകൾ ഒരൊറ്റ ഇന്റിജറിൽ ഒരുപാട് ബൂളിയൻ ഫ്ലാഗ്‌സ് ഒതുക്കുന്നു. ഇന്റിജർ ബൈനറിയിൽ വായിക്കുക — ഏത് ബിറ്റ് സെറ്റ് ആണെന്ന് ഒറ്റനോട്ടത്തിൽ കാണാം, ഒരു ഫ്ലാഗ് പ്രവർത്തിക്കാത്തതിന്റെ കാരണം കണ്ടെത്തുന്നതിന് ഇതാണ് ആവശ്യം.

പൊതു ആപ്ലിക്കേഷനുകൾ

ഒരു നമ്പർ കേവലം ഒരു കൌണ്ടല്ലാതെ കൂടുതലാകുമ്പോഴെല്ലാം ദൈനംദിന ഡെവലപ്പർ, സെക്യൂരിറ്റി, ഹാർഡ്‌വെയർ പ്രവർത്തനങ്ങളിൽ ബേസ് കൺവേർഷൻ പ്രത്യക്ഷപ്പെടുന്നു.

• എംബഡഡ് ഫേംവെയർ: JTAG പ്രോബിൽ നിന്ന് ഒരു hex ഡംപ് വായിക്കുക, ഒരു ഫംഗ്‌ഷന്റെ അഡ്രസ്സ് കണ്ടെത്തുക, ഡീബഗ്ഗർ സ്‌ക്രിപ്റ്റ് സ്വീകരിക്കുന്ന ഡെസിമൽ ഓഫ്‌സെറ്റ് ഉപയോഗിച്ച് ഒരു ബ്രേക്ക്‌പോയ്‌ന്റ് കമാൻഡ് എഴുതുക.
• നെറ്റ്‌വർക്ക് സെക്യൂരിറ്റി: ഡോട്ടഡ്-ഡെസിമലിൽ പ്രിന്റ് ചെയ്ത 32-ബിറ്റ് നെറ്റ്‌മാസ്‌ക് ബൈനറിയിലേക്ക് പാഴ്‌സ് ചെയ്ത് പ്രിഫിക്സ് ദൈർഘ്യം കണ്ടെത്തുക, ACL നിയമത്തിനായി CIDR ഫോം എഴുതുക.
• CTF പ്രഹേളികകളും ക്രിപ്‌റ്റോ ചാലഞ്ചുകളും: XOR കീഴിൽ ഒരു ലീക്ക്ഡ് കീ ഫ്രാഗ്‌മെന്റ് ഒരു കാൻഡിഡേറ്റ് പ്ലെയിൻടെക്‌സ്‌റ്റിന് നേരെ ഹെക്‌സ്, ഡെസിമൽ, ബൈനറിക്കിടയിൽ ഫ്ലിപ്പ് ചെയ്യുക.

ഒരു ഉദാഹരണം

ഡെസിമൽ പെയ്‌നിൽ 255 ടൈപ്പ് ചെയ്യൂ. hex പെയ്ൻ FF (അല്ലെങ്കിൽ പ്രിഫിക്സ് ടോഗിൾ ഓണിൽ 0xFF) ആകുന്നു, ബൈനറി പെയ്ൻ 11111111 (ഗ്രൂപ്പ് ചെയ്‌ത 1111_1111), ഓക്ടൽ പെയ്ൻ 377. കസ്റ്റം-പെയ്ൻ റാഡിക്സ് 36 ആക്കൂ, ഒരേ മൂല്യം 73 ആയി ദൃശ്യമാകുന്നു. 123456789012345678901234567890 ഡെസിമൽ പെയ്‌നിൽ ടൈപ്പ് ചെയ്യൂ; hex പെയ്ൻ BigInt പാത്ത് ഉപയോഗിക്കുകയും 18EE90FF6C373E0EE4E3F0AD2 ആയി ദൃശ്യമാകുകയും ചെയ്യും.

FAQ

ഒരു നമ്പർ ബേസ് എന്താണ്?

ഒരു നമ്പർ ബേസ്, അല്ലെങ്കിൽ റാഡിക്സ്, അടുത്ത സ്ഥാനത്തേക്ക് കാരി ആകുന്നതിന് മുൻപ് ഒരു പൊസിഷണൽ സിസ്റ്റം ഉപയോഗിക്കുന്ന വ്യത്യസ്ത അക്കങ്ങളുടെ എണ്ണമാണ്. ഡെസിമൽ (ബേസ് 10) 0-9 ഉപയോഗിക്കുന്നു; ബൈനറി (ബേസ് 2) 0, 1 മാത്രം; ഹെക്സാഡെസിമൽ (ബേസ് 16) 0-9 ഉം A-F ഉം. ബേസ് മാറ്റുമ്പോൾ നമ്പറിന്റെ മൂല്യം മാറുന്നില്ല — അതിന്റെ അക്കങ്ങൾ എഴുതി ഗ്രൂപ്പ് ചെയ്യുന്ന രീതി മാത്രം.

പ്രോഗ്രാമിംഗിൽ ഹെക്സാഡെസിമൽ ഉപയോഗിക്കേണ്ടത് എന്തുകൊണ്ട്?

ഒരു hex അക്കം കൃത്യം നാല് ബൈനറി ബിറ്റുകളുമായി മാപ്പ് ആകുന്നു, അതിനാൽ രണ്ട് hex അക്കങ്ങൾ ഒരു ബൈറ്റ് ഉൾക്കൊള്ളുന്നു, എട്ട് hex അക്കങ്ങൾ 32-ബിറ്റ് വേഡ് ഉൾക്കൊള്ളുന്നു. മെമ്മറി അഡ്രസ്സ്, രജിസ്‌റ്റർ ഉള്ളടക്കങ്ങൾ, കളർ ട്രിപ്ലെറ്റ്‌സ്, ക്രിപ്‌റ്റോഗ്രാഫിക് കീകൾ — ഇവയ്ക്ക് hex ഏറ്റവും കോംപാക്ടായ മനുഷ്യ-വായനാ ഫോർമാണ്. 0xFF വായിക്കുന്നത് 11111111 വായിക്കുന്നതിനേക്കാൾ വേഗമാണ്, ആവശ്യമെങ്കിൽ ബിറ്റ് പാറ്റേൺ അവിടെ തന്നെ ഉണ്ട്.

ബേസ് 36-ന് മേൽ കൺവേർട്ട് ചെയ്യാൻ കഴിയുമോ?

ഈ ടൂൾ ബേസ് 36-ൽ നിർത്തുന്നു, കാരണം JavaScript-ന്റെ നേറ്റീവ് parseInt, toString APIs-ന്റെ ഉയർന്ന പരിധി അതാണ്, ഡിജിറ്റ് ആൽഫബറ്റ് ആയി 0-9, A-Z ഉൾക്കൊള്ളുന്നു. ബേസ് 37-62 കസ്റ്റം ആൽഫബറ്റ് ഉപയോഗിച്ച് സാദ്ധ്യമാണ് (Bitcoin അഡ്രസ്സുകളിൽ ഉപയോഗിക്കുന്ന Base58 ഒരു ഉദാഹരണം) പക്ഷേ ഓരോ ഉയർന്ന ബേസ്-ഉം അതിന്റേതായ കാനോനിക്കൽ ഡിജിറ്റ് ഓർഡർ ആവശ്യമായതിനാൽ അവ ഒരു പ്രത്യേക ടൂളായി ട്രാക്ക് ചെയ്യപ്പെടുന്നു.

ഇത് നെഗറ്റീവ് നമ്പറുകളും ഫ്ലോട്ടുകളും കൈകാര്യം ചെയ്യുമോ?

നെഗറ്റീവ് ഇന്റിജറുകൾ ഓരോ ബേസിലും ഒരു ലീഡിംഗ് മൈനസ് ചിഹ്നത്തോടെ ദൃശ്യമാകുന്നു, ഇത് Number.prototype.toString ഡിഫോൾട്ടായി ചെയ്യുന്ന അതേ ബിഹേവിയർ ആണ്. ഒരു നിശ്ചിത ബിറ്റ് വിഡ്ത്ത് (8, 16, 32, 64) ഉടനീളം Two's-complement പ്രതിനിധീകരണം ഒരു പ്രത്യേക ദൃശ്യം ആണ്, ഞങ്ങൾ ഇത് ചേർക്കാൻ ആലോചിക്കുന്നു. ഫ്ലോട്ടിംഗ്-പോയ്‌ന്റ് ബേസ് കൺവേർഷൻ ഈ പതിപ്പിന്റെ സ്‌കോപ്പ് അല്ല; ടൂൾ ഇന്റിജർ മൂല്യങ്ങൾ മാത്രം കൈകാര്യം ചെയ്യുന്നു.

ഫേംവെയർ, സെക്യൂരിറ്റി, ഗ്രാഫിക്‌സ് പ്രവർത്തനങ്ങളിൽ ആവർത്തിച്ചു വരുന്ന ഒരു ചെറിയ ജോലിയാണ് ബേസ് കൺവേർഷൻ. ഒരു ബ്രൗസർ ടാബിൽ ഇത് ചെയ്യുക, Node V8 ഉപയോഗിക്കുന്ന അതേ ഗണിത primitives ഉപയോഗിച്ച്, ജോലി വേഗത്തിലും ഡാറ്റ നിങ്ങളുടെ മെഷ്യനിലും നിലനിർത്തുന്നു.