உரையை பேஸ்64 க்கு குறியாக்க அல்லது பேஸ்64 சரங்களை மீண்டும் உரையாக குறியாக்க ஒரு இலவச ஆன்லைன் கருவி. தரவுகளை குறியாக்குவதற்கான தரநிலைக்கு உட்பட்ட மற்றும் URL-பாதுகாப்பான பேஸ்64 குறியாக்கத்தை உடனடியாக மாற்றுகிறது.
Base64 என்பது பைனரி-க்கு-உரை குறியாக்க திட்டம் ஆகும், இது பைனரி தரவுகளை ASCII உரை வடிவத்தில் பிரதிநிதித்துவம் செய்கிறது. இது பைனரி வடிவங்களில் சேமிக்கப்பட்ட தரவுகளை உரை உள்ளடக்கம் மட்டும் நம்பகமாக ஆதரிக்கும் சேனல்களில் கொண்டு செல்ல வடிவமைக்கப்பட்டுள்ளது. Base64 குறியாக்கம் பைனரி தரவுகளை 64 எழுத்துக்களின் தொகுப்பாக மாற்றுகிறது (இதனால் பெயர்) இது உரை அடிப்படையிலான நெட்வொர்க்களில் தரவுகளை பாதுகாப்பாக அனுப்புவதற்கு இடையூறு இல்லாமல்.
Base64 எழுத்துக்களின் தொகுப்பு:
இந்த கருவி உங்களுக்கு உரையை Base64 வடிவத்திற்கு எளிதாக குறியாக்கம் செய்யவோ அல்லது Base64 வரிகளை மீண்டும் அவர்களின் முதன்மை உரையாகக் குறியாக்கம் செய்யவோ உதவுகிறது. இது குறிப்பாக மேம்படுத்துனர்கள், IT தொழில்முனைவோர் மற்றும் உரை அடிப்படையிலான சேனல்களில் பாதுகாப்பாக அனுப்பப்பட வேண்டிய தரவுகளுடன் வேலை செய்யும் அனைவருக்கும் பயனுள்ளதாக இருக்கும். நமது நேரடி மாற்றம் அம்சத்துடன், நீங்கள் தட்டச்சு செய்யும் போது உடனுக்குடன் முடிவுகளை காணலாம், இது உங்கள் குறியாக்கம் மற்றும் குறியாக்கம் வேலைப்பாட்டை மேலும் திறமையாக மாற்றுகிறது.
Base64 குறியாக்கம் பைனரி தரவின் ஒவ்வொரு மூன்று பைட்டுகளை (24 பிட்டுகள்) நான்கு Base64 எழுத்துக்களாக மாற்றுவதன் மூலம் செயல்படுகிறது. இந்த செயல்முறை இந்த படிகளை பின்பற்றுகிறது:
உள்ளீட்டு நீளம் 3-க்கு பகுத்தால், "=" எழுத்துக்களைப் பயன்படுத்தி பூர்த்தி செய்யப்படுகிறது.
ஒரு பைட்டுகளின் வரிசை க்கான தொடர்புடைய Base64 எழுத்துக்கள் க்கான கணக்கீடுகள்:
இங்கு என்பது Base64 அகராதியில் -வது எழுத்தை பிரதிநிதித்துவம் செய்கிறது.
Base64 குறியாக்கம் குறியாக்க செயல்முறையை மறு செயல்படுத்துகிறது:
குறியாக்கப்பட வேண்டிய பைட்டுகளின் எண்ணிக்கை 3-க்கு பகுக்க முடியாத போது, பூர்த்தி செய்யப்படுகிறது:
"Hello" என்ற உரையை Base64 க்கு குறியாக்குவோம்:
உள்ளீட்டு நீளம் (5 பைட்டுகள்) 3-க்கு பகுக்க முடியாததால், கடைசி "=" பூட்டுதலை கவனிக்கவும்.
Base64 குறியாக்கப்பட்ட உரையின் நீளத்தை கணக்கிடுவதற்கான பொதுவான சூத்திரம்:
இங்கு என்பது மேலே உள்ள முழு எண்ணாக (அடுத்த முழு எண்ணுக்கு மேல்) வட்டமாக்கும் செயல்பாட்டைக் குறிக்கிறது.
எங்கள் Base64 கருவி உரையை Base64 க்கு குறியாக்கம் செய்யவோ அல்லது Base64 ஐ மீண்டும் உரையாகக் குறியாக்கம் செய்யவோ எளிமையான மற்றும் திறமையான வழியை வழங்குகிறது. இதைப் பயன்படுத்துவது எப்படி:
எங்கள் கருவி தற்போது நீங்கள் தட்டச்சு செய்யும் போது உடனுக்குடன் வெளியீட்டை புதுப்பிக்கும் நேரடி மாற்றம் விருப்பத்தை உள்ளடக்கியது:
நேரடி மாற்றம் அம்சம் குறிப்பாக பயனுள்ளதாக இருக்கிறது:
மிகவும் பெரிய உள்ளீடுகளுக்கு, கருவி செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது, இது நீங்கள் தட்டச்சு செய்யும் போது உடனடியாக மாற்றம் நிகழும், ஒவ்வொரு விசை அழுத்தத்திற்கும் அல்ல.
Base64 குறியாக்கம் பல பயன்பாடுகளில் பரவலாகப் பயன்படுத்தப்படுகிறது:
மின்னஞ்சல் இணைப்புகள்: MIME (பல்துறை இன்டர்நெட் மின்னஞ்சல் விரிவாக்கங்கள்) மின்னஞ்சலில் பைனரி இணைப்புகளை Base64 க்கு குறியாக்கம் செய்ய பயன்படுத்துகிறது.
தரவை URL களில்: HTML, CSS அல்லது JavaScript இல் நேரடியாக சிறிய படங்கள், எழுத்துருக்கள் அல்லது பிற வளங்களை உள்ளடக்குவது data: URL திட்டத்தைப் பயன்படுத்துகிறது.
API தொடர்புகள்: JSON payloads அல்லது பிற உரை அடிப்படையிலான API வடிவங்களில் பைனரி தரவுகளை பாதுகாப்பாக அனுப்புகிறது.
உரை வடிவங்களில் பைனரி தரவுகளை சேமிப்பது: XML, JSON அல்லது பிற உரை அடிப்படையிலான வடிவங்களில் பைனரி தரவுகளை சேமிக்க வேண்டும் என்றால்.
அங்கீகார அமைப்புகள்: HTTP இல் அடிப்படையான அங்கீகாரம் Base64 குறியாக்கத்தைப் பயன்படுத்துகிறது (ஆனால் இது பாதுகாப்பிற்காக அல்ல, குறியாக்கத்திற்காகவே).
கிரிப்டோகிராபி: பல கிரிப்டோகிராபி ஒப்பந்தங்கள் மற்றும் அமைப்புகளின் ஒரு பகுதியாக, பொதுவாக விசைகள் அல்லது சான்றிதழ்களை குறியாக்குவதற்காக.
குக்கி மதிப்புகள்: குக்கிகளில் சேமிக்கப்பட வேண்டிய சிக்கலான தரவுக் கட்டமைப்புகளை குறியாக்கம் செய்வது.
Base64 பரவலாகப் பயன்படுத்தப்படும் போதிலும், சில சூழ்நிலைகளில் அதிகரிக்கக்கூடிய மாற்றங்கள் இருக்கலாம்:
URL-பாதுகாப்பான Base64: "+" மற்றும் "/" ஐ "-" மற்றும் "_" உடன் மாற்றும் ஒரு மாறுபாடு, URL குறியாக்கப் பிரச்சினைகளைத் தவிர்க்க. URL களில் உள்ள தரவுக்கு பயனுள்ளதாக இருக்கிறது.
Base32: 32 எழுத்துக்களின் தொகுப்பைப் பயன்படுத்துகிறது, இது நீளமான வெளியீட்டை உருவாக்குகிறது ஆனால் மனித வாசிப்பில் சிறந்தது மற்றும் வழக்கமாகக் குறியீட்டில் இல்லாமல் உள்ளது.
Hex Encoding: எளிதான hexadecimal க்கு மாற்றம், இது குறைவான செயல்திறனை (அளவை இரட்டிப்பாக்குகிறது) ஆனால் மிகவும் எளிமையானது மற்றும் பரவலாக ஆதரிக்கப்படுகிறது.
பைனரி பரிமாற்றம்: பெரிய கோப்புகள் அல்லது செயல்திறனை மிக முக்கியமாகக் கொண்டால், நேரடி பைனரி பரிமாற்ற நெறிமுறைகள் HTTP உடன் சரியான உள்ளடக்கம் வகை தலைப்புகளைப் பயன்படுத்துவது மேலானது.
சுருக்கம் + Base64: பெரிய உரை தரவுகளுக்கு, குறியாக்கத்திற்கு முன் சுருக்கம் செய்வது அளவைக் குறைக்கலாம்.
JSON/XML Serialization: அமைப்பான தரவுக்கு, Base64 குறியாக்கத்தை விட உள்ளூர் JSON அல்லது XML சீரியல் செய்யுதல் அதிகரிக்கக்கூடியதாக இருக்கலாம்.
Base64 குறியாக்கம் கணினி மற்றும் தொலைதொடர்பு அமைப்புகளில் அதன்根ங்கள் கொண்டது, அங்கு பைனரி தரவுகளை உரை வடிவங்களில் அனுப்ப வேண்டும்.
Base64 இன் அதிகாரப்பூர்வ விவரக்குறிப்பு முதலில் 1987 இல் RFC 989 இல் வெளியிடப்பட்டது, இது தனியுரிமை மேம்படுத்திய மின்னஞ்சலை (PEM) வரையறுக்கிறது. இது பின்னர் RFC 1421 (1993) மற்றும் RFC 2045 (1996, MIME இன் ஒரு பகுதியாக) இல் புதுப்பிக்கப்பட்டது.
"Base64" என்ற சொல், குறியாக்கம் 64 வெவ்வேறு ASCII எழுத்துக்களைப் பயன்படுத்துவதிலிருந்து வருகிறது, இது பைனரி தரவுகளை பிரதிநிதித்துவம் செய்கிறது. 64 எழுத்துக்களைத் தேர்ந்தெடுத்தது திட்டமிடப்பட்டது, ஏனெனில் 64 என்பது 2 இன் சக்தி (2^6), இது பைனரி மற்றும் Base64 இடையே மாற்றத்தை திறமையாகக் செய்யும்.
காலப்போக்கில், Base64 இன் பல மாறுபாடுகள் உருவாகின:
மூன்று தசாப்தங்களுக்கு மேலாக இருந்தாலும், Base64 இன்று நவீன கணினியில் அடிப்படையான கருவியாகவே உள்ளது, குறிப்பாக JSON போன்ற உரை அடிப்படையிலான தரவுப் வடிவங்களைப் பயன்படுத்தும் இணைய பயன்பாடுகள் மற்றும் API களின் வளர்ச்சியுடன்.
இங்கே பல நிரலாக்க மொழிகளில் 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}
251# 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)
291// 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}
351<?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?>
271// 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}
431# 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
271// 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}
331// 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}
311' 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==")
441# 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})
351% 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
331// 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}
741// 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 இல் நேரடி மாற்ற அம்சத்தை செயல்படுத்த எப்படி செயல்படுத்தலாம்:
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});
42Base64 குறியாக்கம் மற்றும் குறியாக்கம் செய்யும்போது, இந்த முக்கியமான கருத்துக்களை கவனிக்கவும்:
யூனிகோட் மற்றும் அசரி எழுத்துக்கள்: அசரி எழுத்துக்களை உள்ளடக்கிய உரைகளை குறியாக்கும் போது, Base64 குறியாக்கத்திற்கு முன் சரியான எழுத்து குறியாக்கத்தை (பொதுவாக UTF-8) உறுதி செய்யவும்.
பூர்த்தி: தரநிலையான Base64 "=" எழுத்துக்களுடன் பூர்த்தி செய்யும் போது, வெளியீட்டு நீளம் 4 இன் பலமாக இருக்க வேண்டும். சில செயல்பாடுகள் பூர்த்தியை தவிர்க்க அனுமதிக்கலாம், இது இணக்கத்தன்மை பிரச்சினைகளை உருவாக்கலாம்.
வரி உடைப்பு: பாரம்பரிய Base64 செயல்பாடுகள் வாசிப்புக்கு வரி உடைப்புகளை (பொதுவாக 76 எழுத்துக்கள்) சேர்க்கின்றன, ஆனால் நவீன பயன்பாடுகள் இதை தவிர்க்கலாம்.
URL-பாதுகாப்பான Base64: தரநிலையான Base64 "+" மற்றும் "/" எழுத்துக்களைப் பயன்படுத்துகிறது, இது URL இல் சிறப்பு அர்த்தங்கள் கொண்டது. URL சூழ்நிலைகளுக்கு, URL-பாதுகாப்பான Base64 ஐப் பயன்படுத்தவும், இது இவற்றை "-" மற்றும் "_" உடன் மாற்றுகிறது.
வெள்ளை இடம்: குறியாக்கத்தின் போது, சில செயல்பாடுகள் மென்மையானவை மற்றும் வெள்ளை இடங்களைப் புறக்கணிக்கின்றன, மற்றவை சரியான உள்ளீட்டைத் தேவைப்படுத்துகின்றன.
அளவீட்டு அதிகரிப்பு: Base64 குறியாக்கம் தரவின் அளவைக் சுமார் 33% அதிகரிக்கிறது (3 உள்ளீட்டு பைட்டுகளுக்கு 4 வெளியீட்டு பைட்டுகள்).
செயல்திறன்: Base64 குறியாக்கம்/குறியாக்கம் மிகவும் பெரிய தரவுகளுக்காக கணினி திறனுக்கு மையமாக இருக்கலாம். எங்கள் கருவி செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது.
நேரடி மாற்றம் கருத்துக்கள்: நேரடி மாற்றம் அம்சத்துடன் மிகப் பெரிய உள்ளீடுகளை உள்ளீடு செய்யும் போது, கருவி செயல்பாட்டில் சிறிய தாமதத்தை நீங்கள் கவனிக்கலாம். இது சாதாரணமாகவே உள்ளது மற்றும் உலாவியில் செயல்திறனைப் பராமரிக்க உதவுகிறது.
நேரடி மாற்றம் அம்சம் நீங்கள் தட்டச்சு செய்யும் போது வெளியீட்டை தானாகவே புதுப்பிக்கிறது, மாற்றம் பொத்தானைப் கிளிக் செய்ய தேவையில்லை. இது உடனடி கருத்துகளை வழங்குகிறது மற்றும் கருவியை மேலும் தொடர்புடைய மற்றும் திறமையானதாக மாற்றுகிறது.
எங்கள் செயல்பாடு செயல்திறனைப் பராமரிக்க தாமதத்தைப் பயன்படுத்துகிறது. மாற்றம் நீங்கள் தட்டச்சு செய்யும் போது நிகழும், ஒவ்வொரு விசை அழுத்தத்திற்கும் அல்ல, இது விரைவான தட்டச்சு செய்யும் போது அதிக செயல்பாட்டைத் தவிர்க்கிறது.
நேரடி மாற்றம் உடனடி கருத்துகளை தேவைப்படும் இடங்களில் பரவலாகப் பயன்படுத்தப்படுகிறது. மிகப் பெரிய தரவுத்தொகுப்புகள் அல்லது நீங்கள் மாற்றத்திற்கு முன் உங்கள் உள்ளீட்டை பரிசீலிக்க விரும்பும் போது, நீங்கள் கையேடு மாற்றத்தைப் பயன்படுத்த விரும்பலாம்.
ஆம், நேரடி மாற்றம் இரு திசைகளிலும் செயல்படுகிறது - உரையிலிருந்து Base64 க்கு மற்றும் Base64 இல் இருந்து உரைக்கு.
நீங்கள் குறியாக்கம் செய்யும் போது தவறான Base64 எழுத்துக்களை உள்ளீடு செய்தால், கருவி உடனடியாக ஒரு பிழை செய்தியை காட்டும், இது நீங்கள் உடனடியாக பிரச்சினையை அடையாளம் காண உதவுகிறது.
எங்கள் Base64 Encoder/Decoder கருவியை இன்று முயற்சிக்கவும், உரை மற்றும் Base64 வடிவங்களை விரைவாக மாற்றவும், நேரடி மாற்றத்தின் வசதியுடன். நீங்கள் API களுடன் வேலை செய்யும் மேம்படுத்துனர், மின்னஞ்சல் இணைப்புகளை கையாள்வது, அல்லது உரை வடிவங்களில் பைனரி தரவுகளை உள்ளடக்குவது எதுவாக இருந்தாலும், எங்கள் கருவி செயல்முறையை எளிதாக்குகிறது.
உங்கள் பணிப்பாக்கிலுக்கு பயனுள்ள மேலும் பயனுள்ள கருவிகளைக் கண்டறியவும்