जावास्क्रिप्ट में स्ट्रिंग के लिए बाइट सरणी परिवर्तित

Question 1

मैं एक बाइट सरणी को स्ट्रिंग में कैसे बदलूं?

मैंने इन कार्यों को उल्टा पाया है:

function string2Bin(s) {
    var b = new Array();
    var last = s.length;

    for (var i = 0; i < last; i++) {
        var d = s.charCodeAt(i);
        if (d < 128)
            b[i] = dec2Bin(d);
        else {
            var c = s.charAt(i);
            alert(c + ' is NOT an ASCII character');
            b[i] = -1;
        }
    }
    return b;
}

function dec2Bin(d) {
    var b = '';

    for (var i = 0; i < 8; i++) {
        b = (d%2) + b;
        d = Math.floor(d/2);
    }

    return b;
}

लेकिन मैं दूसरे तरीके से काम करने वाले कार्यों को कैसे प्राप्त करूं?

धन्यवाद।

शाओ

Question 2

आपको प्रत्येक ओकटेट को वापस संख्या में पार्स करने की आवश्यकता है, और एक चरित्र पाने के लिए उस मूल्य का उपयोग करें, कुछ इस तरह से:

function bin2String(array) {
  var result = "";
  for (var i = 0; i < array.length; i++) {
    result += String.fromCharCode(parseInt(array[i], 2));
  }
  return result;
}

bin2String(["01100110", "01101111", "01101111"]); // "foo"

// Using your string2Bin function to test:
bin2String(string2Bin("hello world")) === "hello world";

संपादित करें: हाँ, आपका करंट string2Binशीघ्र ही और अधिक लिखा जा सकता है:

function string2Bin(str) {
  var result = [];
  for (var i = 0; i < str.length; i++) {
    result.push(str.charCodeAt(i).toString(2));
  }
  return result;
}

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

function string2Bin(str) {
  var result = [];
  for (var i = 0; i < str.length; i++) {
    result.push(str.charCodeAt(i));
  }
  return result;
}

function bin2String(array) {
  return String.fromCharCode.apply(String, array);
}

string2Bin('foo'); // [102, 111, 111]
bin2String(string2Bin('foo')) === 'foo'; // true

Question 3

बस applyअपने बाइट सरणी करने के लिए String.fromCharCode। उदाहरण के लिए

String.fromCharCode.apply(null, [102, 111, 111]) 'फू' के बराबर है।

कैविएट: 65535 से कम सरणियों के लिए काम करता है। एमडीएन डॉक्स यहां ।

Question 4

नया पाठ एन्कोडिंग API आज़माएँ:

// create an array view of some valid bytes
let bytesView = new Uint8Array([104, 101, 108, 108, 111]);

console.log(bytesView);

// convert bytes to string
// encoding can be specfied, defaults to utf-8 which is ascii.
let str = new TextDecoder().decode(bytesView); 

console.log(str);

// convert string to bytes
// encoding can be specfied, defaults to utf-8 which is ascii.
let bytes2 = new TextEncoder().encode(str);

// look, they're the same!
console.log(bytes2);
console.log(bytesView);

स्निपेट का विस्तार करें

Question 5

यह काम करना चाहिए:

String.fromCharCode(...array);

या

String.fromCodePoint(...array)

Question 6

उस string2Bin को और भी सलीके से लिखा जा सकता है , और बिना किसी लूप के, बूट करने के लिए!

function string2Bin ( str ) {
    return str.split("").map( function( val ) { 
        return val.charCodeAt( 0 ); 
    } );
}

Question 7

मुझे लगता है कि यह अधिक कुशल होगा:

function toBinString (arr) {
    var uarr = new Uint8Array(arr.map(function(x){return parseInt(x,2)}));
    var strings = [], chunksize = 0xffff;
    // There is a maximum stack size. We cannot call String.fromCharCode with as many arguments as we want
    for (var i=0; i*chunksize < uarr.length; i++){
        strings.push(String.fromCharCode.apply(null, uarr.subarray(i*chunksize, (i+1)*chunksize)));
    }
    return strings.join('');
}

Question 8

यहां तक कि अगर मुझे थोड़ा देर हो गई है, तो मैंने सोचा कि भविष्य के उपयोगकर्ताओं के लिए कुछ एकल-लाइनर कार्यान्वयन को साझा करना दिलचस्प होगा जो मैंने ईएस 6 का उपयोग करके किया था।

एक बात जो मैं आपके पर्यावरण या / और आप डेटा के साथ क्या करूंगा, इस पर निर्भर करता है कि आप पूर्ण बाइट मान का संरक्षण करें। उदाहरण के लिए, (5).toString(2)आपको दे देंगे 101, लेकिन पूर्ण द्विआधारी रूपांतरण वास्तविकता में है 00000101, और इसीलिए आपको leftPadअग्रणी शून्य के साथ स्ट्रिंग बाइट को भरने के लिए एक कार्यान्वयन बनाने की आवश्यकता हो सकती है । लेकिन आपको इसकी आवश्यकता बिल्कुल नहीं होगी, जैसे कि अन्य उत्तर प्रदर्शित किए गए हैं।

यदि आप नीचे दिए गए कोड स्निपेट को चलाते हैं, तो आप पहले आउटपुट को abcस्ट्रिंग के रूपांतरण को बाइट सरणी में देखते हैं और उसके ठीक बाद उसी सरणी को फिर से स्ट्रिंग के लिए कहा गया।

// For each byte in our array, retrieve the char code value of the binary value
const binArrayToString = array => array.map(byte => String.fromCharCode(parseInt(byte, 2))).join('')

// Basic left pad implementation to ensure string is on 8 bits
const leftPad = str => str.length < 8 ? (Array(8).join('0') + str).slice(-8) : str

// For each char of the string, get the int code and convert it to binary. Ensure 8 bits.
const stringToBinArray = str => str.split('').map(c => leftPad(c.charCodeAt().toString(2)))

const array = stringToBinArray('abc')

console.log(array)
console.log(binArrayToString(array))

स्निपेट का विस्तार करें

Question 9

स्ट्रिंग बाइट सरणी: "FooBar".split('').map(c => c.charCodeAt(0));

बाइट सरणी से स्ट्रिंग: [102, 111, 111, 98, 97, 114].map(c => String.fromCharCode(c)).join('');

Question 10

उत्तर देने में बहुत देर हो गई लेकिन यदि आपका इनपुट ASCII बाइट्स के रूप में है, तो आप इस समाधान की कोशिश कर सकते हैं:

function convertArrToString(rArr){
 //Step 1: Convert each element to character
 let tmpArr = new Array();
 rArr.forEach(function(element,index){
    tmpArr.push(String.fromCharCode(element));
});
//Step 2: Return the string by joining the elements
return(tmpArr.join(""));
}

function convertArrToHexNumber(rArr){
  return(parseInt(convertArrToString(rArr),16));
}

Question 11

यदि आप नोड का उपयोग कर रहे हैं। तो क्या आप ऐसा कर सकते हैं:

yourByteArray.toString('base64');

Question 12

यूटीएफ -8 वर्णों के साथ काम करने वाला कोई भी समाधान नहीं मिला। String.fromCharCodeअच्छा है जब तक आप 2 बाइट चरित्र से मिलते हैं।

उदाहरण के लिए हुसेर आएगा[0x44,0x61,0x6e,0x69,0x65,0x6c,0x61,0x20,0x48,0xc3,0xbc,0x73,0x65,0x72]

लेकिन अगर आप यह माध्यम से जाने के साथ String.fromCharCodeआप होगा HÃ¼ser के रूप में प्रत्येक बाइट एक चार के लिए अलग से परिवर्तित किया जाएगा।

उपाय

वर्तमान में मैं निम्नलिखित समाधान का उपयोग कर रहा हूं:

function pad(n) { return (n.length < 2 ? '0' + n : n); }
function decodeUtf8(data) {
  return decodeURIComponent(
    data.map(byte => ('%' + pad(byte.toString(16)))).join('')
  );
}

Question 13

मेरे पास कुछ डिक्रिप्टेड बाइट ऐरे हैं जिनमें पैडिंग कैरेक्टर और अन्य सामान जिनकी मुझे जरूरत नहीं थी, इसलिए मैंने ऐसा किया (शायद यह सही नहीं है, लेकिन यह मेरे सीमित उपयोग के लिए काम करता है)

var junk = String.fromCharCode.apply(null, res).split('').map(char => char.charCodeAt(0) <= 127 && char.charCodeAt(0) >= 32 ? char : '').join('');

Question 14

यदि आपकी सरणी UTF-8 में एन्कोडेड है और आप IE पर समर्थित नहीं है, क्योंकि आप TextDecoder API का उपयोग नहीं कर सकते हैं :

आप मोज़िला डेवलपर नेटवर्क वेबसाइट द्वारा अनुशंसित FastestSmallestTextEncoderDecoder polyfill का उपयोग कर सकते हैं ;
आप MDN वेबसाइट पर दिए गए इस फ़ंक्शन का उपयोग कर सकते हैं :

function utf8ArrayToString(aBytes) {
    var sView = "";
    
    for (var nPart, nLen = aBytes.length, nIdx = 0; nIdx < nLen; nIdx++) {
        nPart = aBytes[nIdx];
        
        sView += String.fromCharCode(
            nPart > 251 && nPart < 254 && nIdx + 5 < nLen ? /* six bytes */
                /* (nPart - 252 << 30) may be not so safe in ECMAScript! So...: */
                (nPart - 252) * 1073741824 + (aBytes[++nIdx] - 128 << 24) + (aBytes[++nIdx] - 128 << 18) + (aBytes[++nIdx] - 128 << 12) + (aBytes[++nIdx] - 128 << 6) + aBytes[++nIdx] - 128
            : nPart > 247 && nPart < 252 && nIdx + 4 < nLen ? /* five bytes */
                (nPart - 248 << 24) + (aBytes[++nIdx] - 128 << 18) + (aBytes[++nIdx] - 128 << 12) + (aBytes[++nIdx] - 128 << 6) + aBytes[++nIdx] - 128
            : nPart > 239 && nPart < 248 && nIdx + 3 < nLen ? /* four bytes */
                (nPart - 240 << 18) + (aBytes[++nIdx] - 128 << 12) + (aBytes[++nIdx] - 128 << 6) + aBytes[++nIdx] - 128
            : nPart > 223 && nPart < 240 && nIdx + 2 < nLen ? /* three bytes */
                (nPart - 224 << 12) + (aBytes[++nIdx] - 128 << 6) + aBytes[++nIdx] - 128
            : nPart > 191 && nPart < 224 && nIdx + 1 < nLen ? /* two bytes */
                (nPart - 192 << 6) + aBytes[++nIdx] - 128
            : /* nPart < 127 ? */ /* one byte */
                nPart
        );
    }
    
    return sView;
}

let str = utf8ArrayToString([50,72,226,130,130,32,43,32,79,226,130,130,32,226,135,140,32,50,72,226,130,130,79]);

// Must show 2H₂ + O₂ ⇌ 2H₂O
console.log(str);

स्निपेट का विस्तार करें

Question 15

सबसे आसान समाधान जो मैंने पाया है:

var text = atob(byteArray);