मेरे पास एक संदर्भ है जहां मुझे बाइनरी को हेक्साडेसिमल और दशमलव और वाइसवर्स को शेल स्क्रिप्ट में बदलने की आवश्यकता है। क्या कोई मुझे इसके लिए एक उपकरण सुझा सकता है?
मेरे पास एक संदर्भ है जहां मुझे बाइनरी को हेक्साडेसिमल और दशमलव और वाइसवर्स को शेल स्क्रिप्ट में बदलने की आवश्यकता है। क्या कोई मुझे इसके लिए एक उपकरण सुझा सकता है?
जवाबों:
शुद्ध बैश ( और बिलिंस हैं) में बाइनरी से रूपांतरण करना काफी सरल है :echo
printf
$ echo "$((2#101010101))"
341
$ printf '%x\n' "$((2#101010101))"
155
अकेले बश का उपयोग करके बाइनरी में वापस जाना कुछ अधिक जटिल है, इसलिए मैं आपको सुझाव देता हूं कि आप उस के समाधान के लिए अन्य उत्तर देखें।
printf '%x\n' 10
, उदाहरण के लिए।
printf %d
बिन 2 डीईसी के लिए उपयोग करने का क्या मतलब है? $(( ... ))
पहले से ही एक दशमलव परिणाम देता है, echo
पर्याप्त है।
printf '%s\n' foo
करने के बजाय echo
कई कारणों से (ज्यादातर पोर्टेबिलिटी) के लिए, एक ही कारण के लिए, मैं इसे यहाँ का उपयोग नहीं करते।
echo
बिलिन है) के बारे में था। मेरी गलती!
यह मानते हुए कि द्विआधारी द्वारा, आप का अर्थ है बाइनरी डेटा जिसमें 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*",$_)'
आप इसके लिए 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
echo 'ibase=2;obase=F;1111
कि दशमलव 15 के बराबर होना चाहिए , अर्थात। हेक्स में एफ। यह 10 के रूप में निकलता है, जो कि आधार 15 (अंक 0-ई) में है। यह आसान है यदि आप पहले ओबेस को बताएं , जैसे echo 'obase=16;ibase=2;1111'|bc
:। कोई भ्रम नहीं।
ibase
, आपको उस आधार में इनपुट प्रदान करना होगा , यहां तक कि के लिए obase
। तो आपके उदाहरण में होगा echo 'ibase=2;obase=10000;11110001011010'|bc
। सुनहरी की सलाह को बेहतर तरीके से सुनें और आदेश को उलट दें - पहले सेट करें obase
, फिर ibase
।
आप आधार 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
बाइनरी में बदलने के लिए।
हेक्साडेसिमल उपयोग के लिए द्विआधारी के लिए: लिनक्स में xxd उपकरण और दशमलव के लिए द्विआधारी के लिए आप qalculate उपकरण का उपयोग कर सकते हैं।
Xxd प्रकार xxd --help
या man xxd
लिनक्स में मदद के लिए ।
आप 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
जैसा कि पिछले उत्तर में बताया गया है कि आप ईको और प्रिंटफ का उपयोग करते हुए बश में निम्नानुसार बाइनरी को डेसीमल और हेक्सा डेसीमल कर सकते हैं। मैं सिर्फ यहाँ जोड़ रहा हूँ कि शुद्ध बैश का उपयोग करके दशमलव और हेक्स से बाइनरी में कैसे परिवर्तित किया जाए।
गूंज का उपयोग करके दशमलव से द्विआधारी
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!