બેઝ રૂપાંતર કેવી રીતે કામ કરે છે
દરેક સ્થાનીય અંક પ્રણાલી કોઈ મૂલ્યને બેઝની ઘાતો વડે ગુણાયેલા અંકોના સરવાળા તરીકે દર્શાવે છે. બેઝ બદલવાનો અર્થ એ જ મૂલ્યને એક અલગ ઘાત-શ્રેણી સામે ફરીથી લખવું.
- ઇનપુટ મૂળાક્ષરની ચકાસણી કરો. દરેક બેઝ એક ચોક્કસ અંક-સમૂહ સ્વીકારે છે. બાઇનરી 0 અને 1 સ્વીકારે છે; ઑક્ટલ 0-7; ડેસિમલ 0-9; હેક્સ 0-9 અને A-F. પસંદ કરેલી વર્ણમાળાની બહારનો કોઈ અક્ષર હોય તો કોઈ પણ કન્વર્ઝન ચાલે તે પહેલાં ઇનલાઇન ભૂલ દેખાય છે.
- Value parse. JavaScript Number (2^53-1 સુધી) માં સમાય તેવા મૂલ્યો માટે ટૂલ
parseInt(text, base)ને કૉલ કરે છે. તે સીમાથી ઉપર તેBigIntપર પાછું ફરે છે જેથી મનસ્વી રીતે મોટા પૂર્ણાંકો માટે કન્વર્ઝન ચોક્કસ રહે. - દરેક લક્ષ્ય બેઝમાં ફરી પ્રસ્તુત કરો. પાર્સ થયેલ મૂલ્ય
Number.prototype.toString(base)અથવાBigInt.prototype.toString(base)દ્વારા દરેક આઉટપુટ બેઝમાં બદલાય છે. ચાર પ્રમાણભૂત પૅન (બાઇનરી, ઑક્ટલ, ડેસિમલ, હેક્સ) અને કસ્ટમ-બેઝ પૅન સાથે મળીને અપડેટ થાય છે. - Formatting apply. પ્રીફિક્સ ટૉગલ બાઇનરી, ઑક્ટલ અને હેક્સ આઉટપુટની આગળ અનુક્રમે 0b, 0o, અથવા 0x ઉમેરે છે. અંક-સમૂહન બાઇનરીમાં દર ચાર અંકે અને હેક્સમાં દર બે અંકે અન્ડરસ્કોર દાખલ કરે છે. હેક્સ કેસ ટૉગલ A-F માટે અપરકેસ અથવા લોઅરકેસ અક્ષરો પસંદ કરે છે.
- Live cross-pane સમન્વય. કોઈ પણ પૅનને સંપાદિત કરવાથી 100 ms ડિબાઉન્સ્ડ રી-કન્વર્ઝન ટ્રિગર થાય છે જે અન્ય પૅન અપડેટ કરે છે. તમે જે પૅનમાં ટાઇપ કરી રહ્યા છો તેને દરેક કીસ્ટ્રોક પર સત્યનો સ્રોત ગણવામાં આવે છે.
Base converter?
- Memory dumps reading. ડિબગર, ડિસઅસેમ્બલર અને કોર-ડમ્પ વ્યૂઅર સરનામાં અને રજિસ્ટર મૂલ્યો હેક્સમાં દર્શાવે છે. તેમને ડેસિમલમાં બદલવાથી તેઓ એ જ ટ્રેસમાં બીજે ક્યાંક નોંધાયેલી ગણતરીઓ, કદ અને ઑફસેટ સાથે તુલનીય બને છે.
- Color codes. CSS, ડિઝાઇન ટૂલ અને છબી ફોર્મેટ રંગોને #d2511a જેવા હેક્સ ટ્રિપ્લેટમાં લખે છે. દરેક જોડીને ડેસિમલમાં બદલવાથી એ જ રંગ rgb(210, 81, 26) સ્વરૂપમાં મળે છે જેવો તમારો કલર પિકર અથવા એક્સેસિબિલિટી ચેકર અપેક્ષે છે.
- ફાઇલ પરવાનગીઓ ડિકોડ કરવી. Unix chmod values octal માં લખવામાં આવે: 755 નો અર્થ rwxr-xr-x — દરેક octal digit ને ત્રણ binary bits (bits) માં translate (translate) કરો. Converter permission set man page ખોલ્યા વિના check કરવા એક જ તબક્કામાં mapping દર્શાવે.
- Bit flags debug. નેટવર્ક પ્રોટોકૉલ, કર્નલ સિસ્કૉલ અને હાર્ડવેર રજિસ્ટર ઘણા બૂલિયન ફ્લૅગ એક જ પૂર્ણાંકમાં પૅક કરે છે. પૂર્ણાંકને બાઇનરીમાં વાંચવાથી એક નજરમાં દેખાય છે કે કયા બિટ સેટ છે, જે ત્યારે જરૂરી છે જ્યારે તમે શોધી રહ્યા હો કે કોઈ ફ્લૅગ અસર કેમ નથી કરી રહ્યો.
સામાન્ય applications
બેઝ કન્વર્ઝન રોજિંદા ડેવલપર, સિક્યોરિટી અને હાર્ડવેર કાર્યમાં ત્યારે દેખાય છે જ્યારે કોઈ સંખ્યા માત્ર ગણતરી કરતાં વધુ કંઈક હોય.
- એમ્બેડેડ ફર્મવેર: JTAG પ્રોબમાંથી નીકળેલ હેક્સ ડમ્પ વાંચો, કોઈ ફંક્શનનું સરનામું શોધો, અને તમારી ડિબગર સ્ક્રિપ્ટ સ્વીકારે તેવા ડેસિમલ ઑફસેટનો ઉપયોગ કરીને બ્રેકપૉઇન્ટ કમાન્ડ લખો.
- નેટવર્ક સિક્યોરિટી: ડૉટેડ-ડેસિમલમાં છપાયેલ 32-બિટ નેટમાસ્કને પ્રીફિક્સ લંબાઈ ગણવા માટે પાછું બાઇનરીમાં પાર્સ કરો, પછી ACL નિયમ માટે CIDR સ્વરૂપ લખો.
- CTF કોયડા અને ક્રિપ્ટો પડકારો: XOR હેઠળ કોઈ ઉમેદવાર પ્લેનટેક્સ્ટ સામે લીક થયેલ કી અંશની તુલના કરતી વખતે હેક્સ, ડેસિમલ અને બાઇનરી વચ્ચે સ્વિચ કરો.
Worked example
ડેસિમલ પૅનમાં 255 ટાઇપ કરો. હેક્સ પૅન FF (અથવા પ્રીફિક્સ ટૉગલ ચાલુ હોય તો 0xFF) પર અપડેટ થાય છે, બાઇનરી પૅન 11111111 (1111_1111 તરીકે સમૂહિત) પર, અને ઑક્ટલ પૅન 377 પર. કસ્ટમ-પૅન રેડિક્સ 36 પર સ્વિચ કરો અને એ જ મૂલ્ય 73 તરીકે રેન્ડર થાય છે. ડેસિમલ પૅનમાં 123456789012345678901234567890 જેવું ઘણું મોટું મૂલ્ય ટાઇપ કરો; હેક્સ પૅન BigInt માર્ગનો ઉપયોગ કરે છે અને 18EE90FF6C373E0EE4E3F0AD2 રેન્ડર કરે છે.
FAQ
Number base?
નંબર બેઝ, અથવા રેડિક્સ, એ છે કે કોઈ સ્થાનીય પ્રણાલી આગળની સ્થિતિમાં કૅરી કરતા પહેલાં કેટલા અલગ-અલગ અંકોનો ઉપયોગ કરે છે. ડેસિમલ (બેઝ 10) 0-9 નો ઉપયોગ કરે છે; બાઇનરી (બેઝ 2) માત્ર 0 અને 1 નો; હેક્સાડેસિમલ (બેઝ 16) 0-9 સાથે A-F નો. બેઝ બદલવાથી સંખ્યાનું મૂલ્ય બદલાતું નથી — માત્ર તેના અંકો લખવાની અને સમૂહિત કરવાની રીત બદલાય છે.
પ્રોગ્રામિંગમાં હેક્સાડેસિમલ શા માટે વાપરવામાં આવે છે?
એક હેક્સ અંક બરાબર ચાર બાઇનરી બિટ્સ સાથે મૅપ થાય છે, તેથી બે હેક્સ અંક એક બાઇટ આવરી લે છે અને આઠ હેક્સ અંક 32-બિટ વર્ડ આવરી લે છે. એ હેક્સને મેમરી સરનામાં, રજિસ્ટર સામગ્રી, કલર ટ્રિપ્લેટ અને ક્રિપ્ટોગ્રાફિક કી માટે સૌથી સઘન માનવ-વાંચનીય સ્વરૂપ બનાવે છે. 0xFF વાંચવું 11111111 કરતાં ઝડપી છે, અને બિટ પૅટર્ન જરૂર પડે ત્યારે ત્યાં જ હાજર છે.
શું હું બેઝ 36થી આગળ રૂપાંતર કરી શકું?
આ ટૂલ બેઝ 36 પર અટકે છે કારણ કે એ જ નેટિવ JavaScript parseInt અને toString API ની ઉપલી સીમા છે, જે અંક વર્ણમાળા તરીકે 0-9 પછી A-Z સ્વીકારે છે. બેઝ 37-62 કસ્ટમ વર્ણમાળા સાથે શક્ય છે (Bitcoin સરનામાંમાં વપરાતું Base58 એક ઉદાહરણ છે) પણ તેમને એક અલગ ટૂલ તરીકે ટ્રૅક કરવામાં આવે છે કારણ કે દરેક ઊંચા બેઝને પોતાનો પ્રામાણિક અંક-ક્રમ જોઈએ.
શું આ ઋણ સંખ્યાઓ અને ફ્લોટ સંભાળે છે?
ઋણ પૂર્ણાંકો દરેક બેઝમાં આગળ એક માઇનસ ચિહ્ન સાથે રેન્ડર થાય છે, એ જ વર્તન જે Number.prototype.toString સાથે આવે છે. પસંદ કરેલી બિટ-પહોળાઈ (8, 16, 32, 64) પર ટૂઝ-કૉમ્પ્લિમેન્ટ રજૂઆત એક અલગ વ્યૂ છે જે અમે ઉમેરવાની યોજના ધરાવીએ છીએ. ફ્લોટિંગ-પૉઇન્ટ બેઝ કન્વર્ઝન પણ આ સંસ્કરણના વ્યાપની બહાર છે; ટૂલ માત્ર પૂર્ણાંક મૂલ્યો સંભાળે છે.
Base conversion firmware, security, અને graphics work માં વારંવાર આવતો નાનો job છે. Browser tab માં, Node અને V8 already ship કરે છે તે same arithmetic primitives ઉપયોગ કરીને, આ operation fast રહે અને data machine પર.