ASCII बाइनरी और बाइनरी से ASCII रूपांतरण उपकरण?

Question

ASCII को बाइनरी में और ASCII को बाइनरी में बदलने के लिए कौन सा अच्छा टूल है?

मैं कुछ इस तरह की उम्मीद कर रहा था:

$ echo --binary "This is a binary message"
01010100 01101000 01101001 01110011 00100000 01101001 01110011 00100000 01100001 00100000 01100010 01101001 01101110 01100001 01110010 01111001 00100000 01101101 01100101 01110011 01110011 01100001 01100111 01100101

या, अधिक यथार्थवादी:

$ echo "This is a binary message" | ascii2bin
01010100 01101000 01101001 01110011 00100000 01101001 01110011 00100000 01100001 00100000 01100010 01101001 01101110 01100001 01110010 01111001 00100000 01101101 01100101 01110011 01110011 01100001 01100111 01100101

और रिवर्स भी:

$ echo "01010100 01101000 01101001 01110011 00100000 01101001 01110011 00100000 01100001 00100000 01100010 01101001 01101110 01100001 01110010 01111001 00100000 01101101 01100101 01110011 01110011 01100001 01100111 01100101" | bin2ascii
This is a binary message

PS: मैं बैश का उपयोग कर रहा हूं

PS2: मुझे आशा है कि मुझे गलत बाइनरी नहीं मिली

Comments

क्या आप पोस्ट कर सकते हैं कि आप अंततः इसके साथ क्या करना चाहते हैं? बस b / c जो भी समाधान हम प्रदान करते हैं वह संभवतः केवल एक संकीर्ण उपयोग के मामले में काम करेगा, और मुझे लगता है कि आप उस चीज़ के लिए पूछ रहे हैं जिसे आप अधिक जटिल तरीके से उपयोग करना चाहते हैं, और प्रदान किया गया कोई भी समाधान संभवतः विफल हो जाएगा। उस परिदृश्य में।

— SLM

@ एसएलएम किया, मैंने प्रश्न संपादित किया

— RSFalcon7

मुझे लगता है कि आप LF के चरित्र आउटपुट को अनदेखा करना चाहते हैं echo।

— स्टीफन चेज़लस 15

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

— ctrl-alt-delor-

Answer 1

$ echo AB | perl -lpe '$_=unpack"B*"'
0100000101000010
$ echo 0100000101000010 | perl -lpe '$_=pack"B*",$_'
AB

• -e expressionperlकोड के रूप में दी गई अभिव्यक्ति का मूल्यांकन करें
• -p: sedमोड। अभिव्यक्ति इनपुट की प्रत्येक पंक्ति में मूल्यांकन किया जाता है, लाइन में संग्रहीत की सामग्री के साथ $_चर और के मूल्यांकन के बाद मुद्रित अभिव्यक्ति ।
• -l: और भी अधिक की तरह sed: पूर्ण लाइन के बजाय, केवल लाइन की सामग्री (यानी, लाइन सीमांकक के बिना) में है $_(और आउटपुट पर एक नई पंक्ति वापस जोड़ दी जाती है)। इसलिए perl -lpe codeकाम करता है sed codeसिवाय इसके कि यह perlकोड के विपरीत sedकोड है।
• unpack "B*"$_डिफ़ॉल्ट रूप से चर पर काम करता है और अपनी सामग्री को पहले बाइट के उच्चतम बिट से अंतिम बाइट के सबसे कम बिट तक चलने के रूप में निकालता है।
• packका उलटा करता है unpack। perldoc -f packविवरण के लिए देखें।

रिक्त स्थान के साथ:

$ echo AB | perl -lpe '$_=join " ", unpack"(B8)*"'
01000001 01000010
$ echo 01000001 01000010 | perl -lape '$_=pack"(B8)*",@F'
AB

(यह मानता है कि इनपुट 8 बिट्स (0-पेड) के ब्लॉक में है)।

इसके साथ unpack "(B8)*", हम एक बार में 8 बिट्स निकालते हैं, और हम परिणामस्वरूप रिक्त स्थान के साथ जुड़ते हैं join " "।

Comments

बहुत धन्यवाद। मैं पर्ल से कुछ हद तक परिचित हूं, लेकिन विस्तारित विवरण उन लोगों के लिए बहुत मददगार होंगे जो पूरी तरह से नए हैं।

— योके

Answer 2

आप xxdASCII और बाइनरी से कन्वर्ट करने के लिए उपयोग कर सकते हैं ।

$ echo -n "A" | xxd -b
0000000: 01000001                                               A

$ echo -n "A" | xxd -b | awk '{print $2}'
01000001

आधारों को परिवर्तित करना

यदि आप हेक्स, ऑक्टल और दिसंबर के बीच बस बेस रूपांतरण करने के लिए देख रहे हैं, तो मैं आमतौर पर bcऐसी चीजों को करने के लिए मूल कैलकुलेटर कमांड लाइन टूल ( ) का उपयोग करता हूं। ध्यान दें कि bcहमेशा आधारों के सही क्रम के बारे में बहुत ही उपयुक्त है: आपको परिणामी आधार ( obase) को पहले निर्दिष्ट करना होगा , फिर अपनी पसंद को जोड़ना होगा ibase।

$ echo "obase=2; ibase=16; A" | bc
1010

$ echo "obase=16; ibase=2; 1010" | bc
A

Comments

xxdअच्छा होगा, सिवाय इसके कि लाइन के अंत में पहले कष्टप्रद स्तंभ और आधार इनपुट से पता चलता है।

— RSFalcon7

@ RSFalcon7 - मुझे पता है, आप awkइससे छुटकारा पाने के लिए इसे पाइप कर सकते हैं लेकिन इस डिस्प्ले को निष्क्रिय करने के लिए इसमें स्विच नहीं हैं। | awk '{print $2}'। अन्य उपकरण भी हैं। odऔर hexdump। मैं उन का उपयोग कर एक और विधि के लिए देख रहा हूँ।

— slm

@ RSFalcon7 -p'शुद्ध' आउटपुट प्राप्त करने के लिए विकल्प का उपयोग करें

— प्यूरफेरेट

मैं xxd -bस्वयं दृष्टिकोण का उपयोग करता हूं, हालांकि, कोई भी xxdअकेले बाइनरी को एएससीआईआई में परिवर्तित करने के लिए उपयोग नहीं कर सकता है । टोडो इसलिए, मुझे लगता है कि आपको कुछ ऐसा उपयोग करना होगा printf 'obase=16;ibase=2;%s\n' "$n" | bc | xxd -p -r, जिसमें $ n को संख्या में बदलने के लिए, या तो अंकों की एक लंबी स्ट्रिंग के रूप में, या अंकों के एक तार को अर्ध-कॉलनों के साथ अलग किया जाए। यदि आप गारंटी दे सकते हैं कि $ n आपके गोले के अंकगणित प्रकार में फिट बैठता है, तो आप दूर हो सकते हैंprintf '%x\n' $((2#$n)) | xxd -p -r

— फ्रेंकी

जब तक आप perl / python

— Franki

Answer 3

Bc और bash का उपयोग करना:

#!/bin/bash

chrbin() {
        echo $(printf \\$(echo "ibase=2; obase=8; $1" | bc))
}

ordbin() {
  a=$(printf '%d' "'$1")
  echo "obase=2; $a" | bc
}

ascii2bin() {
    echo -n $* | while IFS= read -r -n1 char
    do
        ordbin $char | tr -d '\n'
        echo -n " "
    done
}

bin2ascii() {
    for bin in $*
    do
        chrbin $bin | tr -d '\n'
    done
}
ascii2bin "This is a binary message"
bin2ascii 01010100 01101000 01101001 01110011 00100000 01101001 01110011 00100000 01100001 00100000 01100010 01101001 01101110 01100001 01110010 01111001 00100000 01101101 01100101 01110011 01110011 01100001 01100111 01100101

Answer 4

बाइनरी को एससीआई में बदलने के लिए शेल समाधान:

bin2ascii() { { tr -cd 01 | fold -w8; echo; } | sed '1i obase=8; ibase=2' | bc | sed 's/^/\\/' | tr -d '\n' | xargs -0 echo -e; }

Comments

यह एक शुद्ध खोल समाधान नहीं है। sed, trऔर bcबाहरी प्रोग्राम हैं जिन्हें शेल स्क्रिप्ट में कहा जाता है।

— योके

Answer 5

पायथन में

[ -~]अजगर 2 पर सीमा में ASCII वर्णों के लिए :

>>> import binascii
>>> bin(int(binascii.hexlify('hello'), 16))
'0b110100001100101011011000110110001101111'

उलटे हुए:

>>> n = int('0b110100001100101011011000110110001101111', 2)
>>> binascii.unhexlify('%x' % n)
'hello'

---

पायथन 3.2+ में:

>>> bin(int.from_bytes('hello'.encode(), 'big'))
'0b110100001100101011011000110110001101111'

उलटे हुए:

>>> n = int('0b110100001100101011011000110110001101111', 2)
>>> n.to_bytes((n.bit_length() + 7) // 8, 'big').decode()
'hello'

Answer 6

पायथन 3 का उपयोग करना:

#!/usr/bin/env python3

import sys


if __name__ == "__main__":
    if len(sys.argv) != 1 and len(sys.argv) <= 3:
        if sys.argv[1] in ('-b', '--binary'):
            n = int(sys.argv[2].replace(' ', ''), 2)
            print(n.to_bytes((n.bit_length() + 7) // 8, 'big').decode())
        if sys.argv[1] in ('-a', '--ascii'):
            print((bin(int.from_bytes(sys.argv[2].encode(), 'big')))[2:])
    else:
        print("Example: decode -b '10000001'")

उदाहरण के लिए "बिन 2साइसी" के रूप में सहेजा गया:

$ bin2ascii -a "Hello, world!"
1001000011001010110110001101100011011110010110000100000011101110110111101110010011011000110010000100001

$ bin2ascii -b 1001000011001010110110001101100011011110010110000100000011101110110111101110010011011000110010000100001  
Hello, world!

Answer 7

आधार 64 द्वारा बाइनरी एन्कोडिंग

$ echo "This is a binary message" | base64
VGhpcyBpcyBhIGJpbmFyeSBtZXNzYWdlCg==

डिकोडिंग base64

$ echo "VGhpcyBpcyBhIGJpbmFyeSBtZXNzYWdlCg==" | base64 -d
This is a binary message