Base64 kodeerija/dekodeerija

// JavaScript Base64 Kodeerimine/Dekodeerimine
function encodeToBase64(text) {
  return btoa(text);
}

function decodeFromBase64(base64String) {
  try {
    return atob(base64String);
  } catch (e) {
    throw new Error("Vale Base64 string");
  }
}

// Näidis kasutamine
const originalText = "Tere, Maailm!";
const encoded = encodeToBase64(originalText);
console.log("Kodeeritud:", encoded);  // VGVyZSwgTWFpbG0h

try {
  const decoded = decodeFromBase64(encoded);
  console.log("Dekodeeritud:", decoded);  // Tere, Maailm!
} catch (error) {
  console.error(error.message);
}

# Python Base64 Kodeerimine/Dekodeerimine
import base64

def encode_to_base64(text):
    # Muutke string baitideks ja seejärel kodeerige
    text_bytes = text.encode('utf-8')
    base64_bytes = base64.b64encode(text_bytes)
    return base64_bytes.decode('utf-8')

def decode_from_base64(base64_string):
    try:
        # Muutke Base64 string baitideks ja seejärel dekodeerige
        base64_bytes = base64_string.encode('utf-8')
        text_bytes = base64.b64decode(base64_bytes)
        return text_bytes.decode('utf-8')
    except Exception as e:
        raise ValueError(f"Vale Base64 string: {e}")

# Näidis kasutamine
original_text = "Tere, Maailm!"
encoded = encode_to_base64(original_text)
print(f"Kodeeritud: {encoded}")  # VGVyZSwgTWFpbG0h

try:
    decoded = decode_from_base64(encoded)
    print(f"Dekodeeritud: {decoded}")  # Tere, Maailm!
except ValueError as e:
    print(e)

// Java Base64 Kodeerimine/Dekodeerimine
import java.util.Base64;
import java.nio.charset.StandardCharsets;

public class Base64Example {
    public static String encodeToBase64(String text) {
        byte[] textBytes = text.getBytes(StandardCharsets.UTF_8);
        byte[] encodedBytes = Base64.getEncoder().encode(textBytes);
        return new String(encodedBytes, StandardCharsets.UTF_8);
    }
    
    public static String decodeFromBase64(String base64String) {
        try {
            byte[] base64Bytes = base64String.getBytes(StandardCharsets.UTF_8);
            byte[] decodedBytes = Base64.getDecoder().decode(base64Bytes);
            return new String(decodedBytes, StandardCharsets.UTF_8);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Vale Base64 string: " + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        String originalText = "Tere, Maailm!";
        String encoded = encodeToBase64(originalText);
        System.out.println("Kodeeritud: " + encoded);  // VGVyZSwgTWFpbG0h
        
        try {
            String decoded = decodeFromBase64(encoded);
            System.out.println("Dekodeeritud: " + decoded);  // Tere, Maailm!
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

<?php
// PHP Base64 Kodeerimine/Dekodeerimine
function encodeToBase64($text) {
    return base64_encode($text);
}

function decodeFromBase64($base64String) {
    $decoded = base64_decode($base64String, true);
    if ($decoded === false) {
        throw new Exception("Vale Base64 string");
    }
    return $decoded;
}

// Näidis kasutamine
$originalText = "Tere, Maailm!";
$encoded = encodeToBase64($originalText);
echo "Kodeeritud: " . $encoded . "\n";  // VGVyZSwgTWFpbG0h

try {
    $decoded = decodeFromBase64($encoded);
    echo "Dekodeeritud: " . $decoded . "\n";  // Tere, Maailm!
} catch (Exception $e) {
    echo "Viga: " . $e->getMessage() . "\n";
}
?>

// C# Base64 Kodeerimine/Dekodeerimine
using System;
using System.Text;

class Base64Example
{
    public static string EncodeToBase64(string text)
    {
        byte[] textBytes = Encoding.UTF8.GetBytes(text);
        return Convert.ToBase64String(textBytes);
    }
    
    public static string DecodeFromBase64(string base64String)
    {
        try
        {
            byte[] base64Bytes = Convert.FromBase64String(base64String);
            return Encoding.UTF8.GetString(base64Bytes);
        }
        catch (FormatException)
        {
            throw new FormatException("Vale Base64 string");
        }
    }
    
    static void Main()
    {
        string originalText = "Tere, Maailm!";
        string encoded = EncodeToBase64(originalText);
        Console.WriteLine($"Kodeeritud: {encoded}");  // VGVyZSwgTWFpbG0h
        
        try
        {
            string decoded = DecodeFromBase64(encoded);
            Console.WriteLine($"Dekodeeritud: {decoded}");  // Tere, Maailm!
        }
        catch (FormatException e)
        {
            Console.WriteLine($"Viga: {e.Message}");
        }
    }
}

# Ruby Base64 Kodeerimine/Dekodeerimine
require 'base64'

def encode_to_base64(text)
  Base64.strict_encode64(text)
end

def decode_from_base64(base64_string)
  begin
    Base64.strict_decode64(base64_string)
  rescue ArgumentError => e
    raise "Vale Base64 string: #{e.message}"
  end
end

# Näidis kasutamine
original_text = "Tere, Maailm!"
encoded = encode_to_base64(original_text)
puts "Kodeeritud: #{encoded}"  # VGVyZSwgTWFpbG0h

begin
  decoded = decode_from_base64(encoded)
  puts "Dekodeeritud: #{decoded}"  # Tere, Maailm!
rescue StandardError => e
  puts "Viga: #{e.message}"
end

// Go Base64 Kodeerimine/Dekodeerimine
package main

import (
    "encoding/base64"
    "fmt"
)

func encodeToBase64(text string) string {
    return base64.StdEncoding.EncodeToString([]byte(text))
}

func decodeFromBase64(base64String string) (string, error) {
    bytes, err := base64.StdEncoding.DecodeString(base64String)
    if err != nil {
        return "", fmt.Errorf("vale Base64 string: %v", err)
    }
    return string(bytes), nil
}

func main() {
    originalText := "Tere, Maailm!"
    encoded := encodeToBase64(originalText)
    fmt.Println("Kodeeritud:", encoded)  // VGVyZSwgTWFpbG0h
    
    decoded, err := decodeFromBase64(encoded)
    if err != nil {
        fmt.Println("Viga:", err)
    } else {
        fmt.Println("Dekodeeritud:", decoded)  // Tere, Maailm!
    }
}

// Swift Base64 Kodeerimine/Dekodeerimine
import Foundation

func encodeToBase64(_ text: String) -> String? {
    if let data = text.data(using: .utf8) {
        return data.base64EncodedString()
    }
    return nil
}

func decodeFromBase64(_ base64String: String) -> String? {
    if let data = Data(base64Encoded: base64String) {
        return String(data: data, encoding: .utf8)
    }
    return nil
}

// Näidis kasutamine
let originalText = "Tere, Maailm!"
if let encoded = encodeToBase64(originalText) {
    print("Kodeeritud: \(encoded)")  // VGVyZSwgTWFpbG0h
    
    if let decoded = decodeFromBase64(encoded) {
        print("Dekodeeritud: \(decoded)")  // Tere, Maailm!
    } else {
        print("Viga: Ei suutnud dekodeerida Base64 stringi")
    }
} else {
    print("Viga: Ei suutnud kodeerida teksti")
}

' Excel VBA Base64 Kodeerimine/Dekodeerimine
' Märkus: See vajab viidet Microsoft XML, v6.0
Function EncodeToBase64(text As String) As String
    Dim xmlObj As Object
    Set xmlObj = CreateObject("MSXML2.DOMDocument")
    
    Dim xmlNode As Object
    Set xmlNode = xmlObj.createElement("b64")
    
    xmlNode.DataType = "bin.base64"
    xmlNode.nodeTypedValue = StrConv(text, vbFromUnicode)
    
    EncodeToBase64 = xmlNode.text
    
    Set xmlNode = Nothing
    Set xmlObj = Nothing
End Function

Function DecodeFromBase64(base64String As String) As String
    On Error GoTo ErrorHandler
    
    Dim xmlObj As Object
    Set xmlObj = CreateObject("MSXML2.DOMDocument")
    
    Dim xmlNode As Object
    Set xmlNode = xmlObj.createElement("b64")
    
    xmlNode.DataType = "bin.base64"
    xmlNode.text = base64String
    
    DecodeFromBase64 = StrConv(xmlNode.nodeTypedValue, vbUnicode)
    
    Set xmlNode = Nothing
    Set xmlObj = Nothing
    Exit Function
    
ErrorHandler:
    DecodeFromBase64 = "Viga: Vale Base64 string"
End Function

' Kasutamine töölehe sees:
' =EncodeToBase64("Tere, Maailm!")
' =DecodeFromBase64("VGVyZSwgTWFpbG0h")

# R Base64 Kodeerimine/Dekodeerimine
# Nõuab 'base64enc' paketti
# install.packages("base64enc")
library(base64enc)

encode_to_base64 <- function(text) {
  # Muutke tekst toorandmeteks, seejärel kodeerige
  text_raw <- charToRaw(text)
  base64_encoded <- base64encode(text_raw)
  return(rawToChar(base64_encoded))
}

decode_from_base64 <- function(base64_string) {
  tryCatch({
    # Muutke base64 string toorandmeteks, seejärel dekodeerige
    base64_raw <- charToRaw(base64_string)
    decoded_raw <- base64decode(base64_raw)
    return(rawToChar(decoded_raw))
  }, error = function(e) {
    stop(paste("Vale Base64 string:", e$message))
  })
}

# Näidis kasutamine
original_text <- "Tere, Maailm!"
encoded <- encode_to_base64(original_text)
cat("Kodeeritud:", encoded, "\n")  # VGVyZSwgTWFpbG0h

tryCatch({
  decoded <- decode_from_base64(encoded)
  cat("Dekodeeritud:", decoded, "\n")  # Tere, Maailm!
}, error = function(e) {
  cat("Viga:", e$message, "\n")
})

% MATLAB Base64 Kodeerimine/Dekodeerimine
function demo_base64()
    originalText = 'Tere, Maailm!';
    
    % Kodeerimine
    encoded = encode_to_base64(originalText);
    fprintf('Kodeeritud: %s\n', encoded);  % VGVyZSwgTWFpbG0h
    
    % Dekodeerimine
    try
        decoded = decode_from_base64(encoded);
        fprintf('Dekodeeritud: %s\n', decoded);  % Tere, Maailm!
    catch e
        fprintf('Viga: %s\n', e.message);
    end
end

function encoded = encode_to_base64(text)
    % Muutke tekst uint8 massiiviks ja kodeerige
    bytes = uint8(text);
    encoded = base64encode(bytes);
end

function decoded = decode_from_base64(base64String)
    try
        % Dekodeerige base64 string uint8 massiiviks
        bytes = base64decode(base64String);
        decoded = char(bytes);
    catch
        error('Vale Base64 string');
    end
end

// C Base64 Kodeerimine/Dekodeerimine kasutades OpenSSL
#include <stdio.h>
#include <string.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/buffer.h>
#include <stdint.h>

char* encode_to_base64(const char* input) {
    BIO *bio, *b64;
    BUF_MEM *bufferPtr;
    
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new(BIO_s_mem());
    bio = BIO_push(b64, bio);
    
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
    BIO_write(bio, input, strlen(input));
    BIO_flush(bio);
    BIO_get_mem_ptr(bio, &bufferPtr);
    
    char* result = (char*)malloc(bufferPtr->length + 1);
    memcpy(result, bufferPtr->data, bufferPtr->length);
    result[bufferPtr->length] = '\0';
    
    BIO_free_all(bio);
    
    return result;
}

char* decode_from_base64(const char* input) {
    BIO *bio, *b64;
    size_t length = strlen(input);
    char* buffer = (char*)malloc(length);
    
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_new_mem_buf(input, -1);
    bio = BIO_push(b64, bio);
    
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
    int decoded_length = BIO_read(bio, buffer, length);
    
    if (decoded_length <= 0) {
        free(buffer);
        BIO_free_all(bio);
        return NULL; // Vale Base64 sisend
    }
    
    buffer[decoded_length] = '\0';
    
    BIO_free_all(bio);
    
    return buffer;
}

int main() {
    const char* original_text = "Tere, Maailm!";
    
    char* encoded = encode_to_base64(original_text);
    printf("Kodeeritud: %s\n", encoded);  // VGVyZSwgTWFpbG0h
    
    char* decoded = decode_from_base64(encoded);
    if (decoded) {
        printf("Dekodeeritud: %s\n", decoded);  // Tere, Maailm!
        free(decoded);
    } else {
        printf("Viga: Vale Base64 string\n");
    }
    
    free(encoded);
    
    return 0;
}

// Rust Base64 Kodeerimine/Dekodeerimine
use base64::{encode, decode};
use std::str;

fn encode_to_base64(text: &str) -> String {
    encode(text)
}

fn decode_from_base64(base64_string: &str) -> Result<String, String> {
    match decode(base64_string) {
        Ok(bytes) => {
            match str::from_utf8(&bytes) {
                Ok(text) => Ok(text.to_string()),
                Err(e) => Err(format!("Vale UTF-8 järjestus: {}", e))
            }
        },
        Err(e) => Err(format!("Vale Base64 string: {}", e))
    }
}

fn main() {
    let original_text = "Tere, Maailm!";
    let encoded = encode_to_base64(original_text);
    println!("Kodeeritud: {}", encoded);  // VGVyZSwgTWFpbG0h
    
    match decode_from_base64(&encoded) {
        Ok(decoded) => println!("Dekodeeritud: {}", decoded),  // Tere, Maailm!
        Err(e) => println!("Viga: {}", e)
    }
}