शेल स्क्रिप्ट में हेक्साडेसिमल और दशमलव के लिए द्विआधारी


20

मेरे पास एक संदर्भ है जहां मुझे बाइनरी को हेक्साडेसिमल और दशमलव और वाइसवर्स को शेल स्क्रिप्ट में बदलने की आवश्यकता है। क्या कोई मुझे इसके लिए एक उपकरण सुझा सकता है?


7
हाल के उत्तरों को देखकर, शायद आपको यह निर्दिष्ट करना चाहिए कि "बाइनरी" का अर्थ है बाइनरी नंबर या बाइनरी फ़ाइल
मैनटवर्क

1
संभव क्रॉस साइट डुप्लिकेट की डुप्लिकेट: stackoverflow.com/questions/13280131/… और stackoverflow.com/questions/378829/…
Ciro Santilli 新疆:: 法轮功 '

जवाबों:


39

शुद्ध बैश ( और बिलिंस हैं) में बाइनरी से रूपांतरण करना काफी सरल है :echoprintf

दशमलव के लिए द्विआधारी

$ echo "$((2#101010101))"
341

हेक्साडेसिमल के लिए द्विआधारी

$ printf '%x\n' "$((2#101010101))"
155

अकेले बश का उपयोग करके बाइनरी में वापस जाना कुछ अधिक जटिल है, इसलिए मैं आपको सुझाव देता हूं कि आप उस के समाधान के लिए अन्य उत्तर देखें।


कैसे हेक्साडेसिमल के लिए दशमलव के बारे में।
बैंगि

2
@ बंगी बस करो printf '%x\n' 10, उदाहरण के लिए।
क्रिस डाउन

1
printf %dबिन 2 डीईसी के लिए उपयोग करने का क्या मतलब है? $(( ... ))पहले से ही एक दशमलव परिणाम देता है, echoपर्याप्त है।
एंड्रिया कोरबेलिनी

@AndreaCorbellini - व्यक्तिगत प्राथमिकता। सामान्य तौर पर, मैं का उपयोग printf '%s\n' fooकरने के बजाय echoकई कारणों से (ज्यादातर पोर्टेबिलिटी) के लिए, एक ही कारण के लिए, मैं इसे यहाँ का उपयोग नहीं करते।
क्रिस डाउन

@ क्रिसडाउन: हालांकि यह प्रश्न स्पष्ट रूप से बैश (जिसमें अच्छी तरह से कार्यान्वित echoबिलिन है) के बारे में था। मेरी गलती!
एंड्रिया कोरबेलिनी

16

यह मानते हुए कि द्विआधारी द्वारा, आप का अर्थ है बाइनरी डेटा जिसमें 0 सहित किसी भी संभावित बाइट मान के साथ डेटा है, न कि आधार -2 नंबर:

कन्वर्ट करने के लिए से द्विआधारी, od(मानक), xxd(के साथ आता है vim) या perlके unpackदिमाग में आते हैं।

od -An -vtu1 # for decimal
od -An -vtx1 # for hexadecimal

xxd -p # for hexa

perl -pe 'BEGIN{$\="\n";$/=\30};$_=unpack("H*",$_)' # like xxd -p

# for decimal:
perl -ne 'BEGIN{$\="\n";$/=\30;$,=" "}; print unpack("C*",$_)'

अब, वापस कन्वर्ट करने के लिए द्विआधारी, awk(मानक), xxd -rया perlकी pack:

दशमलव आउटपुट से ऊपर od -tu1या perlनीचे से:

LC_ALL=C awk '{for (i = 1; i <= NF; i++) printf "%c", $i}'
perl -ape '$_=pack("C*",@F)'

हेक्सा perlया xxd -pइसके बाद के संस्करण से:

xxd -r -p
perl -pe 'chomp;$_=pack("H*",$_)'

13

आप इसके लिए ibaseऔर obaseमापदंडों में हेरफेर करके bc का उपयोग कर सकते हैं :

चाल यह है कि आपको आधारों के बारे में स्पष्ट होना चाहिए। इसलिए यदि आपका आईबस 2 है, तो यदि आप अपना ओबेस 10 पर सेट करते हैं, तो यह कुछ भी नहीं करेगा, क्योंकि बाइनरी में 2 है। इसलिए आपको हेक्साडेसिमल नोटेशन का उपयोग करने की आवश्यकता है।

तो दशमलव के लिए द्विआधारी होगा (यह देखें कि ओबेस ए है)

बाइनरी टू दशमलव:

$> echo 'ibase=2;obase=A;11110001011010'|bc
15450

बाइनरी से हेक्स:

$> echo 'ibase=2;obase=10000;11110001011010'|bc
3C5A

यदि 'आउटपुट बेस' obaseको पहले बदल दिया जाए, तो यह आसान होना चाहिए:

$> echo 'obase=10;ibase=2;11110001011010'|bc
15450
$> echo 'obase=16;ibase=2;11110001011010'|bc
3C5A

6
यह दूसरा उदाहरण गलत है - 'एफ' आधार 15 होगा, 16 नहीं (हेक्स में दशमलव 16 10 है, एफ नहीं)। कोशिश करें echo 'ibase=2;obase=F;1111कि दशमलव 15 के बराबर होना चाहिए , अर्थात। हेक्स में एफ। यह 10 के रूप में निकलता है, जो कि आधार 15 (अंक 0-ई) में है। यह आसान है यदि आप पहले ओबेस को बताएं , जैसे echo 'obase=16;ibase=2;1111'|bc:। कोई भ्रम नहीं।
गोल्डीलॉक्स

2
अब यह सबसे खराब है। एक बार सेट करने के बाद ibase, आपको उस आधार में इनपुट प्रदान करना होगा , यहां तक ​​कि के लिए obase। तो आपके उदाहरण में होगा echo 'ibase=2;obase=10000;11110001011010'|bc। सुनहरी की सलाह को बेहतर तरीके से सुनें और आदेश को उलट दें - पहले सेट करें obase, फिर ibase
18

3

आप आधार 2 से 10 या 16 और पीछे से संख्या परिवर्तित मतलब हैं, तो bcऐसा करने के लिए के रूप में पहले से ही ने उल्लेख मानक उपकरण है psarossy

decimal=123
binary=$(echo "obase=2;$decimal" | bc)
hex=$(echo "obase=16;ibase=2;$binary" | bc)

कुछ गोले जैसे zshआधार अंकन के लिए उनके अंकगणितीय विस्तार संचालकों के भाग के रूप में निर्मित होते हैं:

decimal=123
binary=$(([##2]decimal))
hex=$(([##16]decimal))
hex=$(([##16]2#$binary))
decimal=$((2#$binary))

और इसी तरह।

दोनों ksh93और zshभी समर्थन:

typeset -i2 binary=123
typeset -i16 dec2hex=123 bin2hex='2#1111'

लेकिन ध्यान दें, जब विस्तार किया जाता है, $binaryतो एक 2#या 16#उपसर्ग होगा (जिसे आप पट्टी कर सकते हैं ${binary#*#}

ksh93 भी समर्थन करता है:

printf "%..2d\n" 123

बाइनरी में बदलने के लिए।


1

हेक्साडेसिमल उपयोग के लिए द्विआधारी के लिए: लिनक्स में xxd उपकरण और दशमलव के लिए द्विआधारी के लिए आप qalculate उपकरण का उपयोग कर सकते हैं।

Xxd प्रकार xxd --helpया man xxdलिनक्स में मदद के लिए ।


1

आप PHP का उपयोग कर सकते हैं:

$ php -r 'printf("%b", 11);'
1011

या पर्ल:

$ perl -e 'print unpack("B*", pack("c", 11))'
00001011

$ perl -e 'print unpack("B*", pack("C", 11))'
00001011

$ perl -e 'print unpack("B*", pack("W", 11))'
00001011

$ perl -e 'print unpack("B*", pack("n", 11))'
0000000000001011

$ perl -e 'print unpack("B*", pack("N", 11))'
00000000000000000000000000001011

या पोसिक्स अक्क svnpenn / stdlib :

$ awklib 'BEGIN {print mt_basecon(1011, 2, 16)}'
B

$ awklib 'BEGIN {print mt_basecon(1011, 2, 10)}'
11

$ awklib 'BEGIN {print mt_basecon("B", 16, 2)}'
1011

$ awklib 'BEGIN {print mt_basecon(11, 10, 2)}'
1011

0

जैसा कि पिछले उत्तर में बताया गया है कि आप ईको और प्रिंटफ का उपयोग करते हुए बश में निम्नानुसार बाइनरी को डेसीमल और हेक्सा डेसीमल कर सकते हैं। मैं सिर्फ यहाँ जोड़ रहा हूँ कि शुद्ध बैश का उपयोग करके दशमलव और हेक्स से बाइनरी में कैसे परिवर्तित किया जाए।

गूंज का उपयोग करके दशमलव से द्विआधारी

echo "$((2#101010101))"
341

Printf का उपयोग करके हेक्सा-डेसीमल के लिए बाइनरी

printf '%x\n' "$((2#101010101))"
155

केवल बश का उपयोग करके बाइनरी रूपांतरण के लिए पूर्णांक दशमलव

केवल बैश का उपयोग करना, यदि आप दशमलव को बाइनरी में बदलना चाहते हैं, तो आप इसे निम्न की तरह कर सकते हैं:

touch dec2bin && chmod +x "$_" && vim "$_"

और फिर निम्नलिखित को कॉपी और पेस्ट करें:

#!/bin/bash
## converting decimal integer to binary, pass int as a parameter
num=$1;
dec2bin()
{   [ "$num" == "" ] && { printf "Error: Pass an integer\n"; exit 1; };
    op=2; ## Since we're converting to binary
    quo=$(( $num / $op)); rem=$(( $num % $op)); ## quotient and remainder
    remarray=(); ## array for putting remainder inside array
    remarray+=("$rem"); ## array expansion
        until [[ $quo -eq 0 ]]; do
            num=$quo; quo=$(( $num / $op)); ## looping to get all remainder untill 0
            rem=$(( $num % $op)); remarray+="$rem"; ## array expansion
        done
    binary=$(echo "${remarray[@]}" | rev); ## reversing array
    printf "$binary\n"; ## printing reversed array
}
main()
{   [[ -n ${num//[0-9]/} ]] &&
        { printf "Error: $num is not an integer bruv!\n"; return 1;
        } || { dec2bin $num; }
}
main;

और फिर इसे वहां से आज़माएँ जहाँ से आपने बचाया था:

./dec2bin 420
110100100

इंटेगर को जोड़ना होगा !!

./dec2bin 420.py
420.py is not an integer bruv!

हेक्साडेसिमल केवल बश का उपयोग करके द्विआधारी रूपांतरण में

इसी प्रकार, बाइनरी के लिए हेक्साडेसिमल, केवल बैश का उपयोग करते हुए:

#!/usr/local/bin/bash
## converting hexadecimal to binary, pass hex as a parameter
hex=$1;
hex2bin()
{   [ "$hex" == "" ] && { printf "Error: Pass a hex\n"; exit 1; };
    op=2; num=$((16#$hex)); ## converting hex to integer
    quo=$(( $num/ $op)); rem=$(( $num% $op)); ## quotient and remainder
    remarray=(); remarray+=("$rem"); ## array expansion
        until [[ $quo -eq 0 ]]; do
            num=$quo; quo=$(( $num / $op)); ## looping to get all remainder untill 0
            rem=$(( $num % $op)); remarray+="$rem"; ## array expansion
        done
    binary=$(echo "${remarray[@]}" | rev); ## reversing array
    printf "$binary\n"; ## printing reversed array
}
main()
{
[[ -n ${hex//[0-9,A-F,a-f]/} ]] &&
    { printf "Error: $hex is not a hex bruv!\n"; return 1;
    } || { hex2bin $hex; }
}
main;

उदाहरण के लिए:

./hex2bin 1aF
110101111

हेक्स को पारित किया जाना चाहिए:

./hex2bin.bash XyZ
XyZ is not a hexa decimal number bruv!
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.