Wie konvertiere ich Text in binären Code in JavaScript?

Dies könnte das einfachste sein, das Sie bekommen können:

function text2Binary(string) {
    return string.split('').map(function (char) {
        return char.charCodeAt(0).toString(2);
    }).join(' ');
}

1. den String durchqueren
2. wandeln Sie jedes Zeichen in den Zeichencode um 
3. wandeln Sie den Zeichencode in binär um
4. Schieben Sie es in ein Array und fügen Sie die linken Nullen hinzu 
5. gib eine durch Leerzeichen getrennte Zeichenfolge zurück 

Code:

function textToBin(text) {
  var length = text.length,
      output = [];
  for (var i = 0;i < length; i++) {
    var bin = text[i].charCodeAt().toString(2);
    output.Push(Array(8-bin.length+1).join("0") + bin);
  } 
  return output.join(" ");
}
textToBin("!a") => "00100001 01100001"

Ein anderer Weg 

function textToBin(text) {
  return (
    Array
      .from(text)
      .reduce((acc, char) => acc.concat(char.charCodeAt().toString(2)), [])
      .map(bin => '0'.repeat(8 - bin.length) + bin )
      .join(' ')
  );
}

var PADDING = "00000000"

var string = "TEST"
var resultArray = []

for (var i = 0; i < string.length; i++) {
  var compact = string.charCodeAt(i).toString(2)
  var padded  = compact.substring(0, PADDING.length - compact.length) + compact

  resultArray.Push(padded)
}

console.log(resultArray.join(" "))

Hier ist eine ziemlich generische, native Implementierung, die ich vor einiger Zeit schrieb , 

// ABC - a generic, native JS (A)scii(B)inary(C)onverter.
// (c) 2013 Stephan Schmitz <[email protected]>
// License: MIT, http://eyecatchup.mit-license.org
// URL: https://Gist.github.com/eyecatchup/6742657
var ABC = {
  toAscii: function(bin) {
    return bin.replace(/\s*[01]{8}\s*/g, function(bin) {
      return String.fromCharCode(parseInt(bin, 2))
    })
  },
  toBinary: function(str, spaceSeparatedOctets) {
    return str.replace(/[\s\S]/g, function(str) {
      str = ABC.zeroPad(str.charCodeAt().toString(2));
      return !1 == spaceSeparatedOctets ? str : str + " "
    })
  },
  zeroPad: function(num) {
    return "00000000".slice(String(num).length) + num
  }
};

und wie folgt zu verwenden:

var binary1      = "01100110011001010110010101101100011010010110111001100111001000000110110001110101011000110110101101111001",
    binary2      = "01100110 01100101 01100101 01101100 01101001 01101110 01100111 00100000 01101100 01110101 01100011 01101011 01111001",
    binary1Ascii = ABC.toAscii(binary1),
    binary2Ascii = ABC.toAscii(binary2);

console.log("Binary 1:                   " + binary1);
console.log("Binary 1 to ASCII:          " + binary1Ascii);
console.log("Binary 2:                   " + binary2);
console.log("Binary 2 to ASCII:          " + binary2Ascii);
console.log("Ascii to Binary:            " + ABC.toBinary(binary1Ascii));     // default: space-separated octets
console.log("Ascii to Binary /wo spaces: " + ABC.toBinary(binary1Ascii, 0));  // 2nd parameter false to not space-separate octets

Quelle ist auf Github (Gist): https://Gist.github.com/eyecatchup/6742657

Ich hoffe es hilft. Fühlen Sie sich frei für alles, was Sie wollen (zumindest für das, was MIT erlaubt).

8-Bit-Zeichen mit führender 0

'sometext'
        .split('')
        .map((char) => '00'.concat(char.charCodeAt(0).toString(2)).slice(-8))
        .join(' ');

Wenn Sie 6 oder 7 Bit benötigen, ändern Sie einfach .slice(-8)

Nur ein Hinweis in die richtige Richtung

var foo = "TEST",
    res = [ ];

foo.split('').forEach(function( letter ) {
    var bin     = letter.charCodeAt( 0 ).toString( 2 ),
        padding = 8 - bin.length;

    res.Push( new Array( padding+1 ).join( '0' ) + bin );
});

console.log( res );

Die anderen Antworten funktionieren in den meisten Fällen. Es ist jedoch erwähnenswert, dass charCodeAt() und verwandte Objekte nicht mit UTF-8-Zeichenfolgen funktionieren (dh sie werfen Fehler, wenn Zeichen außerhalb des Standardbereichs ASCII sind). Hier ist ein Workaround.

// UTF-8 to binary
var utf8ToBin = function( s ){
    s = unescape( encodeURIComponent( s ) );
    var chr, i = 0, l = s.length, out = '';
    for( ; i < l; i ++ ){
        chr = s.charCodeAt( i ).toString( 2 );
        while( chr.length % 8 != 0 ){ chr = '0' + chr; }
        out += chr;
    }
    return out;
};

// Binary to UTF-8
var binToUtf8 = function( s ){
    var i = 0, l = s.length, chr, out = '';
    for( ; i < l; i += 8 ){
        chr = parseInt( s.substr( i, 8 ), 2 ).toString( 16 );
        out += '%' + ( ( chr.length % 2 == 0 ) ? chr : '0' + chr );
    }
    return decodeURIComponent( out );
};

Die Funktionen von escape/unescape() sind veraltet. Wenn Sie Polyfills für sie benötigen, können Sie sich das umfassendere UTF-8-Codierungsbeispiel ansehen, das Sie hier finden: http://jsfiddle.net/47zwb41o

dies scheint die vereinfachte Version zu sein 

Array.from('abc').map((each)=>each.charCodeAt(0).toString(2)).join(" ")

Vielen Dank Majid Laissi für Ihre Antwort

Ich habe 2 Funktionen aus Ihrem Code gemacht:

ziel war es, die Konvertierung von String in VARBINARY, BINARY und zurück zu implementieren

const stringToBinary = function(string, maxBytes) {
  //for BINARY maxBytes = 255
  //for VARBINARY maxBytes = 65535
  let binaryOutput = '';
  if (string.length > maxBytes) {
    string = string.substring(0, maxBytes);
  }

  for (var i = 0; i < string.length; i++) {
    binaryOutput += string[i].charCodeAt(0).toString(2) + ' ';
  }

  return binaryOutput;
};

und Rückwandlung:

const binaryToString = function(binary) {
  const arrayOfBytes = binary.split(' ');

  let stringOutput = '';

  for (let i = 0; i < arrayOfBytes.length; i++) {
    stringOutput += String.fromCharCode(parseInt(arrayOfBytes[i], 2));
  }

  return stringOutput;
};

und hier ist ein Arbeitsbeispiel: https://jsbin.com/futalidenu/edit?js,console