1# Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Python
2import base64
3
4def encode_to_base64(text):
5    # Μετατροπή της συμβολοσειράς σε byte και στη συνέχεια κωδικοποίηση
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        # Μετατροπή της συμβολοσειράς base64 σε byte και στη συνέχεια αποκωδικοποίηση
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"Μη έγκυρη συμβολοσειρά Base64: {e}")
18
19# Παράδειγμα χρήσης
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Κωδικοποιημένο: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Αποκωδικοποιημένο: {decoded}")  # Hello, World!
27except ValueError as e:
28    print(e)
29

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Java
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("Μη έγκυρη συμβολοσειρά Base64: " + 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);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Αποκωδικοποιημένο: " + decoded);  // Hello, World!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε PHP
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("Μη έγκυρη συμβολοσειρά Base64");
11    }
12    return $decoded;
13}
14
15// Παράδειγμα χρήσης
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Κωδικοποιημένο: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Αποκωδικοποιημένο: " . $decoded . "\n";  // Hello, World!
23} catch (Exception $e) {
24    echo "Σφάλμα: " . $e->getMessage() . "\n";
25}
26?>
27

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε C#
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("Μη έγκυρη συμβολοσειρά Base64");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hello, World!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Κωδικοποιημένο: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Αποκωδικοποιημένο: {decoded}");  // Hello, World!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Σφάλμα: {e.Message}");
40        }
41    }
42}
43

1# Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Ruby
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 "Μη έγκυρη συμβολοσειρά Base64: #{e.message}"
13  end
14end
15
16# Παράδειγμα χρήσης
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Κωδικοποιημένο: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Αποκωδικοποιημένο: #{decoded}"  # Hello, World!
24rescue StandardError => e
25  puts "Σφάλμα: #{e.message}"
26end
27

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Go
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("μη έγκυρη συμβολοσειρά Base64: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    originalText := "Hello, World!"
23    encoded := encodeToBase64(originalText)
24    fmt.Println("Κωδικοποιημένο:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Σφάλμα:", err)
29    } else {
30        fmt.Println("Αποκωδικοποιημένο:", decoded)  // Hello, World!
31    }
32}
33

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Swift
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// Παράδειγμα χρήσης
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21    print("Κωδικοποιημένο: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Αποκωδικοποιημένο: \(decoded)")  // Hello, World!
25    } else {
26        print("Σφάλμα: Δεν μπόρεσε να αποκωδικοποιήσει τη συμβολοσειρά Base64")
27    }
28} else {
29    print("Σφάλμα: Δεν μπόρεσε να κωδικοποιήσει το κείμενο")
30}
31

1' Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Excel VBA
2' Σημείωση: Αυτό απαιτεί αναφορά στη 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 = "Σφάλμα: Μη έγκυρη συμβολοσειρά Base64"
39End Function
40
41' Χρήση σε ένα φύλλο εργασίας:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# Κωδικοποίηση/Αποκωδικοποίηση Base64 σε R
2# Απαιτεί την βιβλιοθήκη 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Μετατροπή κειμένου σε raw bytes, στη συνέχεια κωδικοποίηση
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    # Μετατροπή συμβολοσειράς base64 σε raw, στη συνέχεια αποκωδικοποίηση
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("Μη έγκυρη συμβολοσειρά Base64:", e$message))
21  })
22}
23
24# Παράδειγμα χρήσης
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Κωδικοποιημένο:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Αποκωδικοποιημένο:", decoded, "\n")  # Hello, World!
32}, error = function(e) {
33  cat("Σφάλμα:", e$message, "\n")
34})
35

1% Κωδικοποίηση/Αποκωδικοποίηση Base64 σε MATLAB
2function demo_base64()
3    originalText = 'Hello, World!';
4    
5    % Κωδικοποίηση
6    encoded = encode_to_base64(originalText);
7    fprintf('Κωδικοποιημένο: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Αποκωδικοποίηση
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Αποκωδικοποιημένο: %s\n', decoded);  % Hello, World!
13    catch e
14        fprintf('Σφάλμα: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Μετατροπή κειμένου σε uint8 πίνακα και κωδικοποίηση
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Αποκωδικοποίηση της συμβολοσειράς base64 σε uint8 πίνακα
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('Μη έγκυρη συμβολοσειρά Base64');
31    end
32end
33

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε C χρησιμοποιώντας 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; // Μη έγκυρη είσοδος Base64
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("Κωδικοποιημένο: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Αποκωδικοποιημένο: %s\n", decoded);  // Hello, World!
65        free(decoded);
66    } else {
67        printf("Σφάλμα: Μη έγκυρη συμβολοσειρά Base64\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Κωδικοποίηση/Αποκωδικοποίηση Base64 σε Rust
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!("Μη έγκυρη ακολουθία UTF-8: {}", e))
15            }
16        },
17        Err(e) => Err(format!("Μη έγκυρη συμβολοσειρά Base64: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hello, World!";
23    let encoded = encode_to_base64(original_text);
24    println!("Κωδικοποιημένο: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Αποκωδικοποιημένο: {}", decoded),  // Hello, World!
28        Err(e) => println!("Σφάλμα: {}", e)
29    }
30}
31

1// Υλοποίηση JavaScript με Άμεση Μετατροπή
2
3const textInput = document.getElementById('text-input');
4const base64Output = document.getElementById('base64-output');
5const liveConversionCheckbox = document.getElementById('live-conversion');
6let debounceTimeout = null;
7
8// Συνάρτηση για κωδικοποίηση με debouncing για απόδοση
9function liveEncode() {
10  // Καθαρίστε οποιοδήποτε υπάρχον timeout
11  if (debounceTimeout) {
12    clearTimeout(debounceTimeout);
13  }
14  
15  // Ορίστε ένα νέο timeout για να αποφευχθεί η υπερβολική επεξεργασία κατά τη διάρκεια γρήγορης πληκτρολόγησης
16  debounceTimeout = setTimeout(() => {
17    try {
18      const text = textInput.value;
19      if (text.trim()) {
20        base64Output.value = btoa(text);
21      } else {
22        base64Output.value = '';
23      }
24    } catch (e) {
25      console.error('Σφάλμα κωδικοποίησης:', e);
26      // Διαχειριστείτε το σφάλμα κατάλληλα στην διεπαφή χρήστη
27    }
28  }, 300); // 300ms καθυστέρηση debouncing
29}
30
31// Εκδηλώσεις
32liveConversionCheckbox.addEventListener('change', function() {
33  if (this.checked) {
34    // Ενεργοποιήστε την άμεση μετατροπή
35    textInput.addEventListener('input', liveEncode);
36    // Αρχική κωδικοποίηση
37    liveEncode();
38  } else {
39    // Απενεργοποιήστε την άμεση μετατροπή
40    textInput.removeEventListener('input', liveEncode);
41  }
42});
43