JavaScript Program to Convert a String to Binary

In this article, we will learn how to convert a string to binary in JavaScript. Binary representation holds special importance, especially in the realms of cryptography, low-level tasks, and other diverse programming situations.

Below are the following approaches to convert a string to binary in JavaScript:

Using String's Character Codes and Bitwise Operators

• Character Code Extraction: To start, we'll iterate through each character in the input string. For each character, we'll extract its character code using the charCodeAt() method.
• Binary Conversion with Bitwise Operators: After obtaining the character code, we'll convert it to its binary representation. We'll achieve this by performing bitwise operations, using shifts and masks to extract individual bits and create the binary value.
• Grouping and Formatting: To ensure a consistent format, we'll pad the binary representation with leading zeros to make it a complete byte (8 bits). We'll then aggregate the padded binary values and separate them with spaces.

Example: This example shows the use of the above-explained approach.

function convertToBinaryUsingCharacterCodes(input) {
    let binaryResult = '';
    
    for (let i = 0; i < input.length; i++) {
        const charCode = input.charCodeAt(i);
        let binaryValue = '';
        
        for (let j = 7; j >= 0; j--) {
            binaryValue += (charCode >> j) & 1;
        }
        
        binaryResult += binaryValue + ' ';
    }
    
    return binaryResult.trim();
}

const inputString = "GFG";
const binaryRepresentation = 
    convertToBinaryUsingCharacterCodes(inputString);
console.log(binaryRepresentation);

01000111 01000110 01000111

Leveraging Unicode Code Points and Conversion Methods

• Obtaining Code Points: We'll traverse through each character within the input string and employ the codePointAt(0) method to fetch its corresponding Unicode code point.
• Binary Conversion: Similar to the preceding method, we'll translate the Unicode code point into binary form using the toString(2) method.
• Padding and Grouping: As previously discussed, we'll ensure the binary values are 8 bits long by adding padding, and then consolidate them with spaces.

Example: This example shows the use of the above-explained approach.

function convertToBinaryApproach2(input) {
    let binaryResult = '';

    for (const char of input) {
        const codePoint = char.codePointAt(0);
        const binaryValue = codePoint.toString(2);
        binaryResult += 
            binaryValue.padStart(8, '0') + ' ';
    }

    return binaryResult.trim();
}

const inputString = "GFG";
const binaryRepresentation = 
      convertToBinaryApproach2(inputString);
console.log(binaryRepresentation);

01000111 01000110 01000111

Approach 3: Employing TextEncoder and Byte Conversion

This strategy leverages the TextEncoder API, which encodes strings into bytes and then transforms these bytes into binary representation.

• Text Encoding: Employing the TextEncoder API, we'll encode the input string into a sequence of bytes. This process effectively converts characters into their respective byte values.
• Byte-to-Binary Conversion: Subsequently, each byte is transformed into binary using the toString(2) method. This step ensures that each byte's binary representation spans 8 bits consistently.
• Aggregation: The resulting binary values are combined, with spaces as separators, to compose the comprehensive binary representation of the input string.

Example: This example shows the use of the above-explained approach.

async function convertToBinaryApproach3(input) {
    const encoder = new TextEncoder();
    const encodedData = encoder.encode(input);
    const binaryResult = 
        [...encodedData].map(byte => byte.toString(2)
            .padStart(8, '0')).join(' ');
    return binaryResult;
}

const inputString = "GFG";
convertToBinaryApproach3(inputString)
    .then(binaryRepresentation => {
        console.log(binaryRepresentation);
    })
    .catch(error => {
        console.error(error);
    });

01000111 01000110 01000111

Using Array.from() and charCodeAt()

In this approach, we utilize the Array.from() method to create an array of characters from the input string. Then, we apply the charCodeAt() method to each character to obtain its Unicode code point. Finally, we convert each Unicode code point to its binary representation using the toString(2) method.

function stringToBinaryWithArrayFrom(str) {
    return Array.from(str, char => char.charCodeAt(0).toString(2).padStart(8, '0')).join(' ');
}

console.log(stringToBinaryWithArrayFrom("GFG"));

01000111 01000110 01000111

Using TextDecoder and Uint8Array

The TextEncoder encodes a string into a Uint8Array of bytes. Each byte is then converted to its binary representation using `toString(2)`, and padded to 8 bits. The binary values are joined with spaces, resulting in the binary representation of the input string.

Example:

function stringToBinaryUint8Array(str) {
    const encoder = new TextEncoder();
    const encoded = encoder.encode(str);
    const binaryArray = Array.from(encoded).map(byte => {
        return byte.toString(2).padStart(8, '0');
    });
    return binaryArray.join(' ');
}

console.log(stringToBinaryUint8Array("Hello"));

01001000 01100101 01101100 01101100 01101111

Using Base64 Encoding and Conversion

In this approach, we will convert the string to a binary representation by first encoding the string to Base64 format. Then, we will convert each Base64 character to its binary form, ensuring that the final binary representation is accurate.

Steps:

• Base64 Encoding: Use JavaScript's btoa() method to encode the string in Base64 format.
• Character to Binary Conversion: Convert each character in the Base64 encoded string to its binary representation using the charCodeAt() and toString(2) methods.
• Padding and Formatting: Ensure each binary representation is 8 bits long by padding with leading zeros. Combine the binary values with spaces as separators.

Example: This example shows how to convert a string to binary using Base64 encoding and conversion.

function stringToBinaryUsingBase64(input) {
    // Encode the input string to Base64
    let base64String = btoa(input);
    
    // Convert each character of the Base64 string to its binary representation
    let binaryString = Array.from(base64String).map(char => {
        let binaryChar = char.charCodeAt(0).toString(2);
        return binaryChar.padStart(8, '0'); // Pad with leading zeros to ensure 8 bits
    }).join(' ');

    return binaryString;
}

// Example usage:
let inputString = "Hello";
let binaryRepresentation = stringToBinaryUsingBase64(inputString);
console.log(binaryRepresentation);

01010011 01000111 01010110 01110011 01100010 01000111 00111000 00111101

nikunj_sonigara

Follow

Improve

Article Tags :

• JavaScript
• Web Technologies
• javascript-string
• JavaScript-DSA
• JavaScript-Program

+1 More