Base64 Encoder and Decoder

Introduction

Base64 என்பது பைனரி-க்கு-உரை குறியாக்க திட்டம் ஆகும், இது பைனரி தரவுகளை ASCII உரை வடிவத்தில் பிரதிநிதித்துவம் செய்கிறது. இது பைனரி வடிவங்களில் சேமிக்கப்பட்ட தரவுகளை உரை உள்ளடக்கம் மட்டும் நம்பகமாக ஆதரிக்கும் சேனல்களில் கொண்டு செல்ல வடிவமைக்கப்பட்டுள்ளது. Base64 குறியாக்கம் பைனரி தரவுகளை 64 எழுத்துக்களின் தொகுப்பாக மாற்றுகிறது (இதனால் பெயர்) இது உரை அடிப்படையிலான நெட்வொர்க்களில் தரவுகளை பாதுகாப்பாக அனுப்புவதற்கு இடையூறு இல்லாமல்.

Base64 எழுத்துக்களின் தொகுப்பு:

• பெரிய எழுத்துக்கள் A-Z (26 எழுத்துக்கள்)
• சிறிய எழுத்துக்கள் a-z (26 எழுத்துக்கள்)
• எண்கள் 0-9 (10 எழுத்துக்கள்)
• இரண்டு கூடுதல் எழுத்துக்கள், பொதுவாக "+" மற்றும் "/" (2 எழுத்துக்கள்)

இந்த கருவி உங்களுக்கு உரையை Base64 வடிவத்திற்கு எளிதாக குறியாக்கம் செய்யவோ அல்லது Base64 வரிகளை மீண்டும் அவர்களின் முதன்மை உரையாகக் குறியாக்கம் செய்யவோ உதவுகிறது. இது குறிப்பாக மேம்படுத்துனர்கள், IT தொழில்முனைவோர் மற்றும் உரை அடிப்படையிலான சேனல்களில் பாதுகாப்பாக அனுப்பப்பட வேண்டிய தரவுகளுடன் வேலை செய்யும் அனைவருக்கும் பயனுள்ளதாக இருக்கும். நமது நேரடி மாற்றம் அம்சத்துடன், நீங்கள் தட்டச்சு செய்யும் போது உடனுக்குடன் முடிவுகளை காணலாம், இது உங்கள் குறியாக்கம் மற்றும் குறியாக்கம் வேலைப்பாட்டை மேலும் திறமையாக மாற்றுகிறது.

How Base64 Encoding Works

Encoding Process

Base64 குறியாக்கம் பைனரி தரவின் ஒவ்வொரு மூன்று பைட்டுகளை (24 பிட்டுகள்) நான்கு Base64 எழுத்துக்களாக மாற்றுவதன் மூலம் செயல்படுகிறது. இந்த செயல்முறை இந்த படிகளை பின்பற்றுகிறது:

1. உள்ளீட்டு உரையை அதன் பைனரி பிரதிநிதித்துவத்திற்கு மாற்றவும் (ASCII அல்லது UTF-8 குறியாக்கத்தைப் பயன்படுத்தி)
2. பைனரி தரவுகளை 24 பிட்டுகளின் தொகுதிகளாக (3 பைட்டுகள்) குழுவாகப் பகுக்கவும்
3. ஒவ்வொரு 24-பிட் தொகுதியையும் நான்கு 6-பிட் குழுக்களாகப் பிரிக்கவும்
4. ஒவ்வொரு 6-பிட் குழுவையும் அதற்கேற்ப Base64 எழுத்துக்களாக மாற்றவும்

உள்ளீட்டு நீளம் 3-க்கு பகுத்தால், "=" எழுத்துக்களைப் பயன்படுத்தி பூர்த்தி செய்யப்படுகிறது.

Mathematical Representation

ஒரு பைட்டுகளின் வரிசை $b_1, b_2, b_3$ க்கான தொடர்புடைய Base64 எழுத்துக்கள் $c_1, c_2, c_3, c_4$ க்கான கணக்கீடுகள்:

$c_1 = \text{Base64}[(b_1 >> 2)]$ $c_2 = \text{Base64}[((b_1 \& 3) << 4) | (b_2 >> 4)]$ $c_3 = \text{Base64}[((b_2 \& 15) << 2) | (b_3 >> 6)]$ $c_4 = \text{Base64}[(b_3 \& 63)]$

இங்கு $\text{Base64}[i]$ என்பது Base64 அகராதியில் $i$-வது எழுத்தை பிரதிநிதித்துவம் செய்கிறது.

Decoding Process

Base64 குறியாக்கம் குறியாக்க செயல்முறையை மறு செயல்படுத்துகிறது:

1. ஒவ்வொரு Base64 எழுத்துக்களையும் 6-பிட் மதிப்பாக மாற்றவும்
2. இந்த 6-பிட் மதிப்புகளை இணைக்கவும்
3. பிட்டுகளை 8-பிட் தொகுதிகளாக (பைட்டுகள்) குழுவாகப் பகுக்கவும்
4. ஒவ்வொரு பைட்டையும் அதற்கேற்ப எழுத்தாக மாற்றவும்

Padding

குறியாக்கப்பட வேண்டிய பைட்டுகளின் எண்ணிக்கை 3-க்கு பகுக்க முடியாத போது, பூர்த்தி செய்யப்படுகிறது:

• ஒரு பைட் மீதமிருந்தால், இது இரண்டு Base64 எழுத்துக்களாக மாற்றப்படுகிறது, பின்னர் "=="
• இரண்டு பைட்டுகள் மீதமிருந்தால், அவை மூன்று Base64 எழுத்துக்களாக மாற்றப்படுகின்றன, பின்னர் "="

Example

"Hello" என்ற உரையை Base64 க்கு குறியாக்குவோம்:

1. "Hello" இன் ASCII பிரதிநிதித்துவம்: 72 101 108 108 111
2. பைனரி பிரதிநிதித்துவம்: 01001000 01100101 01101100 01101100 01101111
3. 6-பிட் குழுக்களாகக் குழுவாகப் பகுக்குதல்: 010010 000110 010101 101100 011011 000110 1111
4. கடைசி குழு 4 பிட்டுகள் மட்டுமே உள்ளது, எனவே நாங்கள் பூட்டி பூட்டுகிறோம்: 010010 000110 010101 101100 011011 000110 111100
5. புள்ளிகளை அலகாக மாற்றுதல்: 18, 6, 21, 44, 27, 6, 60
6. Base64 அகராதியிலிருந்து தேடுதல்: S, G, V, s, b, G, 8
7. முடிவு "SGVsbG8=" ஆகும்

உள்ளீட்டு நீளம் (5 பைட்டுகள்) 3-க்கு பகுக்க முடியாததால், கடைசி "=" பூட்டுதலை கவனிக்கவும்.

Formula

Base64 குறியாக்கப்பட்ட உரையின் நீளத்தை கணக்கிடுவதற்கான பொதுவான சூத்திரம்:

$\text{encoded\_length} = 4 \times \lceil \frac{\text{input\_length}}{3} \rceil$

இங்கு $\lceil x \rceil$ என்பது மேலே உள்ள முழு எண்ணாக (அடுத்த முழு எண்ணுக்கு மேல்) வட்டமாக்கும் செயல்பாட்டைக் குறிக்கிறது.

Using the Base64 Encoder/Decoder Tool

எங்கள் Base64 கருவி உரையை Base64 க்கு குறியாக்கம் செய்யவோ அல்லது Base64 ஐ மீண்டும் உரையாகக் குறியாக்கம் செய்யவோ எளிமையான மற்றும் திறமையான வழியை வழங்குகிறது. இதைப் பயன்படுத்துவது எப்படி:

Basic Usage

1. செயல்பாட்டு முறை தேர்வு செய்யவும்: உரையை Base64 க்கு மாற்ற "Encode" ஐ தேர்ந்தெடுக்கவும், அல்லது Base64 ஐ மீண்டும் உரையாக மாற்ற "Decode" ஐ தேர்ந்தெடுக்கவும்.
2. உங்கள் உள்ளீட்டை உள்ளிடவும்: உள்ளீட்டு களத்தில் உங்கள் உரை அல்லது Base64 வரியை தட்டச்சு செய்யவும் அல்லது ஒட்டவும்.
3. மாற்றவும்: "Base64 க்கு குறியாக்கவும்" அல்லது "Base64 இல் இருந்து குறியாக்கவும்" பொத்தானை கிளிக் செய்து மாற்றத்தை செயல்படுத்தவும்.
4. முடிவை நகலெடுக்கவும்: முடிவை உங்கள் கிளிப்போர்டுக்கு நகலெடுக்க "Copy" பொத்தானைப் பயன்படுத்தவும்.

Live Conversion Feature

எங்கள் கருவி தற்போது நீங்கள் தட்டச்சு செய்யும் போது உடனுக்குடன் வெளியீட்டை புதுப்பிக்கும் நேரடி மாற்றம் விருப்பத்தை உள்ளடக்கியது:

1. நேரடி மாற்றத்தை இயக்கவும்: கருவியின் மேலே உள்ள "Live Conversion" செக்க்பாக்ஸை சோதிக்கவும்.
2. உடனடி முடிவுகளை காணவும்: உள்ளீட்டு களத்தில் நீங்கள் தட்டச்சு செய்யும் போது, வெளியீடு தானாகவே புதுப்பிக்கப்படும், மாற்றம் பொத்தானைப் கிளிக் செய்ய தேவையில்லை.
3. தேவைப்பட்டால் மாற்றவும்: உங்கள் விருப்பத்தின் அடிப்படையில், நீங்கள் எப்போது வேண்டுமானாலும் நேரடி மாற்றத்தை இயக்கலாம் அல்லது அணைக்கலாம்.

நேரடி மாற்றம் அம்சம் குறிப்பாக பயனுள்ளதாக இருக்கிறது:

• குறுகிய மற்றும் மத்தியில் உள்ள உரை அல்லது Base64 வரிகளுடன் வேலை செய்யும் போது
• படிப்படியாக மாற்றங்களைச் செய்வதற்காக உடனடி கருத்துகளை தேவைப்படும் போது
• வெவ்வேறு எழுத்துக்கள் எவ்வாறு குறியாக்கப்படுகின்றன/குறியாக்கப்படுகின்றன என்பதை ஆராயும் போது
• Base64 குறியாக்கத்தின் மாதிரிகளைப் பற்றி கற்றுக்கொள்ளும் போது

மிகவும் பெரிய உள்ளீடுகளுக்கு, கருவி செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது, இது நீங்கள் தட்டச்சு செய்யும் போது உடனடியாக மாற்றம் நிகழும், ஒவ்வொரு விசை அழுத்தத்திற்கும் அல்ல.

Use Cases

Base64 குறியாக்கம் பல பயன்பாடுகளில் பரவலாகப் பயன்படுத்தப்படுகிறது:

1. மின்னஞ்சல் இணைப்புகள்: MIME (பல்துறை இன்டர்நெட் மின்னஞ்சல் விரிவாக்கங்கள்) மின்னஞ்சலில் பைனரி இணைப்புகளை Base64 க்கு குறியாக்கம் செய்ய பயன்படுத்துகிறது.

2. தரவை URL களில்: HTML, CSS அல்லது JavaScript இல் நேரடியாக சிறிய படங்கள், எழுத்துருக்கள் அல்லது பிற வளங்களை உள்ளடக்குவது data: URL திட்டத்தைப் பயன்படுத்துகிறது.

3. API தொடர்புகள்: JSON payloads அல்லது பிற உரை அடிப்படையிலான API வடிவங்களில் பைனரி தரவுகளை பாதுகாப்பாக அனுப்புகிறது.

4. உரை வடிவங்களில் பைனரி தரவுகளை சேமிப்பது: XML, JSON அல்லது பிற உரை அடிப்படையிலான வடிவங்களில் பைனரி தரவுகளை சேமிக்க வேண்டும் என்றால்.

5. அங்கீகார அமைப்புகள்: HTTP இல் அடிப்படையான அங்கீகாரம் Base64 குறியாக்கத்தைப் பயன்படுத்துகிறது (ஆனால் இது பாதுகாப்பிற்காக அல்ல, குறியாக்கத்திற்காகவே).

6. கிரிப்டோகிராபி: பல கிரிப்டோகிராபி ஒப்பந்தங்கள் மற்றும் அமைப்புகளின் ஒரு பகுதியாக, பொதுவாக விசைகள் அல்லது சான்றிதழ்களை குறியாக்குவதற்காக.

7. குக்கி மதிப்புகள்: குக்கிகளில் சேமிக்கப்பட வேண்டிய சிக்கலான தரவுக் கட்டமைப்புகளை குறியாக்கம் செய்வது.

Alternatives

Base64 பரவலாகப் பயன்படுத்தப்படும் போதிலும், சில சூழ்நிலைகளில் அதிகரிக்கக்கூடிய மாற்றங்கள் இருக்கலாம்:

1. URL-பாதுகாப்பான Base64: "+" மற்றும் "/" ஐ "-" மற்றும் "_" உடன் மாற்றும் ஒரு மாறுபாடு, URL குறியாக்கப் பிரச்சினைகளைத் தவிர்க்க. URL களில் உள்ள தரவுக்கு பயனுள்ளதாக இருக்கிறது.

2. Base32: 32 எழுத்துக்களின் தொகுப்பைப் பயன்படுத்துகிறது, இது நீளமான வெளியீட்டை உருவாக்குகிறது ஆனால் மனித வாசிப்பில் சிறந்தது மற்றும் வழக்கமாகக் குறியீட்டில் இல்லாமல் உள்ளது.

3. Hex Encoding: எளிதான hexadecimal க்கு மாற்றம், இது குறைவான செயல்திறனை (அளவை இரட்டிப்பாக்குகிறது) ஆனால் மிகவும் எளிமையானது மற்றும் பரவலாக ஆதரிக்கப்படுகிறது.

4. பைனரி பரிமாற்றம்: பெரிய கோப்புகள் அல்லது செயல்திறனை மிக முக்கியமாகக் கொண்டால், நேரடி பைனரி பரிமாற்ற நெறிமுறைகள் HTTP உடன் சரியான உள்ளடக்கம் வகை தலைப்புகளைப் பயன்படுத்துவது மேலானது.

5. சுருக்கம் + Base64: பெரிய உரை தரவுகளுக்கு, குறியாக்கத்திற்கு முன் சுருக்கம் செய்வது அளவைக் குறைக்கலாம்.

6. JSON/XML Serialization: அமைப்பான தரவுக்கு, Base64 குறியாக்கத்தை விட உள்ளூர் JSON அல்லது XML சீரியல் செய்யுதல் அதிகரிக்கக்கூடியதாக இருக்கலாம்.

History

Base64 குறியாக்கம் கணினி மற்றும் தொலைதொடர்பு அமைப்புகளில் அதன்根ங்கள் கொண்டது, அங்கு பைனரி தரவுகளை உரை வடிவங்களில் அனுப்ப வேண்டும்.

Base64 இன் அதிகாரப்பூர்வ விவரக்குறிப்பு முதலில் 1987 இல் RFC 989 இல் வெளியிடப்பட்டது, இது தனியுரிமை மேம்படுத்திய மின்னஞ்சலை (PEM) வரையறுக்கிறது. இது பின்னர் RFC 1421 (1993) மற்றும் RFC 2045 (1996, MIME இன் ஒரு பகுதியாக) இல் புதுப்பிக்கப்பட்டது.

"Base64" என்ற சொல், குறியாக்கம் 64 வெவ்வேறு ASCII எழுத்துக்களைப் பயன்படுத்துவதிலிருந்து வருகிறது, இது பைனரி தரவுகளை பிரதிநிதித்துவம் செய்கிறது. 64 எழுத்துக்களைத் தேர்ந்தெடுத்தது திட்டமிடப்பட்டது, ஏனெனில் 64 என்பது 2 இன் சக்தி (2^6), இது பைனரி மற்றும் Base64 இடையே மாற்றத்தை திறமையாகக் செய்யும்.

காலப்போக்கில், Base64 இன் பல மாறுபாடுகள் உருவாகின:

• தரநிலை Base64: RFC 4648 இல் வரையறுக்கப்பட்ட, A-Z, a-z, 0-9, +, / மற்றும் = ஐ பூட்டுதலுக்காகப் பயன்படுத்துகிறது
• URL-பாதுகாப்பான Base64: "+" மற்றும் "/" ஐ URL குறியாக்கப் பிரச்சினைகளைத் தவிர்க்க "-" மற்றும் "_" உடன் மாற்றுகிறது
• கோப்பு பெயர்-பாதுகாப்பான Base64: URL-பாதுகாப்பானது போலவே, கோப்பு பெயர்களில் பயன்படுத்துவதற்காக வடிவமைக்கப்பட்டுள்ளது
• IMAP க்கான மாற்றப்பட்ட Base64: IMAP நெறிமுறையில் மாறுபட்ட சிறப்பு எழுத்துக்களின் தொகுப்பைப் பயன்படுத்துகிறது

மூன்று தசாப்தங்களுக்கு மேலாக இருந்தாலும், Base64 இன்று நவீன கணினியில் அடிப்படையான கருவியாகவே உள்ளது, குறிப்பாக JSON போன்ற உரை அடிப்படையிலான தரவுப் வடிவங்களைப் பயன்படுத்தும் இணைய பயன்பாடுகள் மற்றும் API களின் வளர்ச்சியுடன்.

Code Examples

இங்கே பல நிரலாக்க மொழிகளில் Base64 குறியாக்கம் மற்றும் குறியாக்கத்தின் எடுத்துக்காட்டுகள் உள்ளன:

1// JavaScript Base64 Encoding/Decoding
2function encodeToBase64(text) {
3  return btoa(text);
4}
5
6function decodeFromBase64(base64String) {
7  try {
8    return atob(base64String);
9  } catch (e) {
10    throw new Error("Invalid Base64 string");
11  }
12}
13
14// Example usage
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Encoded:", encoded);  // SGVsbG8sIFdvcmxkIQ==
18
19try {
20  const decoded = decodeFromBase64(encoded);
21  console.log("Decoded:", decoded);  // Hello, World!
22} catch (error) {
23  console.error(error.message);
24}
25

1# Python Base64 Encoding/Decoding
2import base64
3
4def encode_to_base64(text):
5    # Convert string to bytes and then encode
6    text_bytes = text.encode('utf-8')
7    base64_bytes = base64.b64encode(text_bytes)
8    return base64_bytes.decode('utf-8')
9
10def decode_from_base64(base64_string):
11    try:
12        # Convert base64 string to bytes and then decode
13        base64_bytes = base64_string.encode('utf-8')
14        text_bytes = base64.b64decode(base64_bytes)
15        return text_bytes.decode('utf-8')
16    except Exception as e:
17        raise ValueError(f"Invalid Base64 string: {e}")
18
19# Example usage
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Encoded: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Decoded: {decoded}")  # Hello, World!
27except ValueError as e:
28    print(e)
29

1// Java Base64 Encoding/Decoding
2import java.util.Base64;
3import java.nio.charset.StandardCharsets;
4
5public class Base64Example {
6    public static String encodeToBase64(String text) {
7        byte[] textBytes = text.getBytes(StandardCharsets.UTF_8);
8        byte[] encodedBytes = Base64.getEncoder().encode(textBytes);
9        return new String(encodedBytes, StandardCharsets.UTF_8);
10    }
11    
12    public static String decodeFromBase64(String base64String) {
13        try {
14            byte[] base64Bytes = base64String.getBytes(StandardCharsets.UTF_8);
15            byte[] decodedBytes = Base64.getDecoder().decode(base64Bytes);
16            return new String(decodedBytes, StandardCharsets.UTF_8);
17        } catch (IllegalArgumentException e) {
18            throw new IllegalArgumentException("Invalid Base64 string: " + e.getMessage());
19        }
20    }
21    
22    public static void main(String[] args) {
23        String originalText = "Hello, World!";
24        String encoded = encodeToBase64(originalText);
25        System.out.println("Encoded: " + encoded);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Decoded: " + decoded);  // Hello, World!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// PHP Base64 Encoding/Decoding
3function encodeToBase64($text) {
4    return base64_encode($text);
5}
6
7function decodeFromBase64($base64String) {
8    $decoded = base64_decode($base64String, true);
9    if ($decoded === false) {
10        throw new Exception("Invalid Base64 string");
11    }
12    return $decoded;
13}
14
15// Example usage
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Encoded: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Decoded: " . $decoded . "\n";  // Hello, World!
23} catch (Exception $e) {
24    echo "Error: " . $e->getMessage() . "\n";
25}
26?>
27

1// C# Base64 Encoding/Decoding
2using System;
3using System.Text;
4
5class Base64Example
6{
7    public static string EncodeToBase64(string text)
8    {
9        byte[] textBytes = Encoding.UTF8.GetBytes(text);
10        return Convert.ToBase64String(textBytes);
11    }
12    
13    public static string DecodeFromBase64(string base64String)
14    {
15        try
16        {
17            byte[] base64Bytes = Convert.FromBase64String(base64String);
18            return Encoding.UTF8.GetString(base64Bytes);
19        }
20        catch (FormatException)
21        {
22            throw new FormatException("Invalid Base64 string");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hello, World!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Encoded: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Decoded: {decoded}");  // Hello, World!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Error: {e.Message}");
40        }
41    }
42}
43

1# Ruby Base64 Encoding/Decoding
2require 'base64'
3
4def encode_to_base64(text)
5  Base64.strict_encode64(text)
6end
7
8def decode_from_base64(base64_string)
9  begin
10    Base64.strict_decode64(base64_string)
11  rescue ArgumentError => e
12    raise "Invalid Base64 string: #{e.message}"
13  end
14end
15
16# Example usage
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Encoded: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Decoded: #{decoded}"  # Hello, World!
24rescue StandardError => e
25  puts "Error: #{e.message}"
26end
27

1// Go Base64 Encoding/Decoding
2package main
3
4import (
5    "encoding/base64"
6    "fmt"
7)
8
9func encodeToBase64(text string) string {
10    return base64.StdEncoding.EncodeToString([]byte(text))
11}
12
13func decodeFromBase64(base64_string string) (string, error) {
14    bytes, err := base64.StdEncoding.DecodeString(base64_string)
15    if err != nil {
16        return "", fmt.Errorf("invalid Base64 string: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    original_text := "Hello, World!"
23    encoded := encodeToBase64(original_text)
24    fmt.Println("Encoded:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Error:", err)
29    } else {
30        fmt.Println("Decoded:", decoded)  // Hello, World!
31    }
32}
33

1// Swift Base64 Encoding/Decoding
2import Foundation
3
4func encodeToBase64(_ text: String) -> String? {
5    if let data = text.data(using: .utf8) {
6        return data.base64EncodedString()
7    }
8    return nil
9}
10
11func decodeFromBase64(_ base64String: String) -> String? {
12    if let data = Data(base64Encoded: base64String) {
13        return String(data: data, encoding: .utf8)
14    }
15    return nil
16}
17
18// Example usage
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21    print("Encoded: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Decoded: \(decoded)")  // Hello, World!
25    } else {
26        print("Error: Could not decode Base64 string")
27    }
28} else {
29    print("Error: Could not encode text")
30}
31

1' Excel VBA Base64 Encoding/Decoding
2' Note: This requires a reference to Microsoft XML, v6.0
3Function EncodeToBase64(text As String) As String
4    Dim xmlObj As Object
5    Set xmlObj = CreateObject("MSXML2.DOMDocument")
6    
7    Dim xmlNode As Object
8    Set xmlNode = xmlObj.createElement("b64")
9    
10    xmlNode.DataType = "bin.base64"
11    xmlNode.nodeTypedValue = StrConv(text, vbFromUnicode)
12    
13    EncodeToBase64 = xmlNode.text
14    
15    Set xmlNode = Nothing
16    Set xmlObj = Nothing
17End Function
18
19Function DecodeFromBase64(base64String As String) As String
20    On Error GoTo ErrorHandler
21    
22    Dim xmlObj As Object
23    Set xmlObj = CreateObject("MSXML2.DOMDocument")
24    
25    Dim xmlNode As Object
26    Set xmlNode = xmlObj.createElement("b64")
27    
28    xmlNode.DataType = "bin.base64"
29    xmlNode.text = base64String
30    
31    DecodeFromBase64 = StrConv(xmlNode.nodeTypedValue, vbUnicode)
32    
33    Set xmlNode = Nothing
34    Set xmlObj = Nothing
35    Exit Function
36    
37ErrorHandler:
38    DecodeFromBase64 = "Error: Invalid Base64 string"
39End Function
40
41' Usage in a worksheet:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# R Base64 Encoding/Decoding
2# Requires the 'base64enc' package
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Convert text to raw bytes, then encode
8  text_raw <- charToRaw(text)
9  base64_encoded <- base64encode(text_raw)
10  return(rawToChar(base64_encoded))
11}
12
13decode_from_base64 <- function(base64_string) {
14  tryCatch({
15    # Convert base64 string to raw, then decode
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("Invalid Base64 string:", e$message))
21  })
22}
23
24# Example usage
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Encoded:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Decoded:", decoded, "\n")  # Hello, World!
32}, error = function(e) {
33  cat("Error:", e$message, "\n")
34})
35

1% MATLAB Base64 Encoding/Decoding
2function demo_base64()
3    originalText = 'Hello, World!';
4    
5    % Encode
6    encoded = encode_to_base64(originalText);
7    fprintf('Encoded: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Decode
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Decoded: %s\n', decoded);  % Hello, World!
13    catch e
14        fprintf('Error: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Convert text to uint8 array and encode
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Decode base64 string to uint8 array
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('Invalid Base64 string');
31    end
32end
33

1// C Base64 Encoding/Decoding using OpenSSL
2#include <stdio.h>
3#include <string.h>
4#include <openssl/bio.h>
5#include <openssl/evp.h>
6#include <openssl/buffer.h>
7#include <stdint.h>
8
9char* encode_to_base64(const char* input) {
10    BIO *bio, *b64;
11    BUF_MEM *bufferPtr;
12    
13    b64 = BIO_new(BIO_f_base64());
14    bio = BIO_new(BIO_s_mem());
15    bio = BIO_push(b64, bio);
16    
17    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
18    BIO_write(bio, input, strlen(input));
19    BIO_flush(bio);
20    BIO_get_mem_ptr(bio, &bufferPtr);
21    
22    char* result = (char*)malloc(bufferPtr->length + 1);
23    memcpy(result, bufferPtr->data, bufferPtr->length);
24    result[bufferPtr->length] = '\0';
25    
26    BIO_free_all(bio);
27    
28    return result;
29}
30
31char* decode_from_base64(const char* input) {
32    BIO *bio, *b64;
33    size_t length = strlen(input);
34    char* buffer = (char*)malloc(length);
35    
36    b64 = BIO_new(BIO_f_base64());
37    bio = BIO_new_mem_buf(input, -1);
38    bio = BIO_push(b64, bio);
39    
40    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
41    int decoded_length = BIO_read(bio, buffer, length);
42    
43    if (decoded_length <= 0) {
44        free(buffer);
45        BIO_free_all(bio);
46        return NULL; // Invalid Base64 input
47    }
48    
49    buffer[decoded_length] = '\0';
50    
51    BIO_free_all(bio);
52    
53    return buffer;
54}
55
56int main() {
57    const char* original_text = "Hello, World!";
58    
59    char* encoded = encode_to_base64(original_text);
60    printf("Encoded: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Decoded: %s\n", decoded);  // Hello, World!
65        free(decoded);
66    } else {
67        printf("Error: Invalid Base64 string\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Rust Base64 Encoding/Decoding
2use base64::{encode, decode};
3use std::str;
4
5fn encode_to_base64(text: &str) -> String {
6    encode(text)
7}
8
9fn decode_from_base64(base64_string: &str) -> Result<String, String> {
10    match decode(base64_string) {
11        Ok(bytes) => {
12            match str::from_utf8(&bytes) {
13                Ok(text) => Ok(text.to_string()),
14                Err(e) => Err(format!("Invalid UTF-8 sequence: {}", e))
15            }
16        },
17        Err(e) => Err(format!("Invalid Base64 string: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hello, World!";
23    let encoded = encode_to_base64(original_text);
24    println!("Encoded: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Decoded: {}", decoded),  // Hello, World!
28        Err(e) => println!("Error: {}", e)
29    }
30}
31

JavaScript Implementation with Live Conversion

இங்கே நீங்கள் JavaScript இல் நேரடி மாற்ற அம்சத்தை செயல்படுத்த எப்படி செயல்படுத்தலாம்:

1// JavaScript implementation with live conversion
2const textInput = document.getElementById('text-input');
3const base64Output = document.getElementById('base64-output');
4const liveConversionCheckbox = document.getElementById('live-conversion');
5let debounceTimeout = null;
6
7// Function to encode with debouncing for performance
8function liveEncode() {
9  // Clear any existing timeout
10  if (debounceTimeout) {
11    clearTimeout(debounceTimeout);
12  }
13  
14  // Set a new timeout to prevent excessive processing during rapid typing
15  debounceTimeout = setTimeout(() => {
16    try {
17      const text = textInput.value;
18      if (text.trim()) {
19        base64Output.value = btoa(text);
20      } else {
21        base64Output.value = '';
22      }
23    } catch (e) {
24      console.error('Encoding error:', e);
25      // Handle error appropriately in the UI
26    }
27  }, 300); // 300ms debounce delay
28}
29
30// Event listeners
31liveConversionCheckbox.addEventListener('change', function() {
32  if (this.checked) {
33    // Enable live conversion
34    textInput.addEventListener('input', liveEncode);
35    // Initial encode
36    liveEncode();
37  } else {
38    // Disable live conversion
39    textInput.removeEventListener('input', liveEncode);
40  }
41});
42

Edge Cases and Considerations

Base64 குறியாக்கம் மற்றும் குறியாக்கம் செய்யும்போது, இந்த முக்கியமான கருத்துக்களை கவனிக்கவும்:

1. யூனிகோட் மற்றும் அசரி எழுத்துக்கள்: அசரி எழுத்துக்களை உள்ளடக்கிய உரைகளை குறியாக்கும் போது, Base64 குறியாக்கத்திற்கு முன் சரியான எழுத்து குறியாக்கத்தை (பொதுவாக UTF-8) உறுதி செய்யவும்.

2. பூர்த்தி: தரநிலையான Base64 "=" எழுத்துக்களுடன் பூர்த்தி செய்யும் போது, வெளியீட்டு நீளம் 4 இன் பலமாக இருக்க வேண்டும். சில செயல்பாடுகள் பூர்த்தியை தவிர்க்க அனுமதிக்கலாம், இது இணக்கத்தன்மை பிரச்சினைகளை உருவாக்கலாம்.

3. வரி உடைப்பு: பாரம்பரிய Base64 செயல்பாடுகள் வாசிப்புக்கு வரி உடைப்புகளை (பொதுவாக 76 எழுத்துக்கள்) சேர்க்கின்றன, ஆனால் நவீன பயன்பாடுகள் இதை தவிர்க்கலாம்.

4. URL-பாதுகாப்பான Base64: தரநிலையான Base64 "+" மற்றும் "/" எழுத்துக்களைப் பயன்படுத்துகிறது, இது URL இல் சிறப்பு அர்த்தங்கள் கொண்டது. URL சூழ்நிலைகளுக்கு, URL-பாதுகாப்பான Base64 ஐப் பயன்படுத்தவும், இது இவற்றை "-" மற்றும் "_" உடன் மாற்றுகிறது.

5. வெள்ளை இடம்: குறியாக்கத்தின் போது, சில செயல்பாடுகள் மென்மையானவை மற்றும் வெள்ளை இடங்களைப் புறக்கணிக்கின்றன, மற்றவை சரியான உள்ளீட்டைத் தேவைப்படுத்துகின்றன.

6. அளவீட்டு அதிகரிப்பு: Base64 குறியாக்கம் தரவின் அளவைக் சுமார் 33% அதிகரிக்கிறது (3 உள்ளீட்டு பைட்டுகளுக்கு 4 வெளியீட்டு பைட்டுகள்).

7. செயல்திறன்: Base64 குறியாக்கம்/குறியாக்கம் மிகவும் பெரிய தரவுகளுக்காக கணினி திறனுக்கு மையமாக இருக்கலாம். எங்கள் கருவி செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது.

8. நேரடி மாற்றம் கருத்துக்கள்: நேரடி மாற்றம் அம்சத்துடன் மிகப் பெரிய உள்ளீடுகளை உள்ளீடு செய்யும் போது, கருவி செயல்பாட்டில் சிறிய தாமதத்தை நீங்கள் கவனிக்கலாம். இது சாதாரணமாகவே உள்ளது மற்றும் உலாவியில் செயல்திறனைப் பராமரிக்க உதவுகிறது.

Frequently Asked Questions

What is the Live Conversion feature?

நேரடி மாற்றம் அம்சம் நீங்கள் தட்டச்சு செய்யும் போது வெளியீட்டை தானாகவே புதுப்பிக்கிறது, மாற்றம் பொத்தானைப் கிளிக் செய்ய தேவையில்லை. இது உடனடி கருத்துகளை வழங்குகிறது மற்றும் கருவியை மேலும் தொடர்புடைய மற்றும் திறமையானதாக மாற்றுகிறது.

Will Live Conversion slow down my browser with large inputs?

எங்கள் செயல்பாடு செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது. மாற்றம் நீங்கள் தட்டச்சு செய்யும் போது நிகழும், ஒவ்வொரு விசை அழுத்தத்திற்கும் அல்ல, இது விரைவான தட்டச்சு செய்யும் போது அதிக செயல்பாட்டைத் தவிர்க்கிறது.

When should I use Live Conversion vs. manual conversion?

நேரடி மாற்றம் உடனடி கருத்துகளை தேவைப்படும் இடங்களில் பரவலாகப் பயன்படுத்தப்படுகிறது. மிகப் பெரிய தரவுத்தொகுப்புகள் அல்லது நீங்கள் மாற்றத்திற்கு முன் உங்கள் உள்ளீட்டை பரிசீலிக்க விரும்பும் போது, நீங்கள் கையேடு மாற்றத்தைப் பயன்படுத்த விரும்பலாம்.

Does Live Conversion work for both encoding and decoding?

ஆம், நேரடி மாற்றம் இரு திசைகளிலும் செயல்படுகிறது - உரையிலிருந்து Base64 க்கு மற்றும் Base64 இல் இருந்து உரைக்கு.

What happens if I input invalid Base64 with Live Conversion enabled?

நீங்கள் குறியாக்கம் செய்யும் போது தவறான Base64 எழுத்துக்களை உள்ளீடு செய்தால், கருவி உடனடியாக ஒரு பிழை செய்தியை காட்டும், இது நீங்கள் உடனடியாக பிரச்சினையை அடையாளம் காண உதவுகிறது.

References

1. RFC 4648 - The Base16, Base32, and Base64 Data Encodings
2. RFC 2045 - MIME Part One: Format of Internet Message Bodies
3. MDN Web Docs: Base64 encoding and decoding
4. Base64 - Wikipedia
5. MIME - Wikipedia

எங்கள் Base64 Encoder/Decoder கருவியை இன்று முயற்சிக்கவும், உரை மற்றும் Base64 வடிவங்களை விரைவாக மாற்றவும், நேரடி மாற்றத்தின் வசதியுடன். நீங்கள் API களுடன் வேலை செய்யும் மேம்படுத்துனர், மின்னஞ்சல் இணைப்புகளை கையாள்வது, அல்லது உரை வடிவங்களில் பைனரி தரவுகளை உள்ளடக்குவது எதுவாக இருந்தாலும், எங்கள் கருவி செயல்முறையை எளிதாக்குகிறது.