Base64 Encoder und Decoder: Konvertiere Text zu/von Base64

Base64 Encoder und Decoder

Einführung

Base64 ist ein Binär-zu-Text-Codierungschema, das Binärdaten in einem ASCII-Zeichenformat darstellt. Es wurde entwickelt, um Daten, die in Binärformaten gespeichert sind, über Kanäle zu übertragen, die nur zuverlässig Textinhalte unterstützen. Die Base64-Codierung konvertiert Binärdaten in eine Menge von 64 Zeichen (daher der Name), die sicher über textbasierte Protokolle ohne Datenkorruption übertragen werden können.

Der Base64-Zeichensatz besteht aus:

Großbuchstaben A-Z (26 Zeichen)
Kleinbuchstaben a-z (26 Zeichen)
Ziffern 0-9 (10 Zeichen)
Zwei zusätzliche Zeichen, typischerweise "+" und "/" (2 Zeichen)

Dieses Tool ermöglicht es Ihnen, Text einfach in das Base64-Format zu codieren oder Base64-Zeichenfolgen zurück in ihren ursprünglichen Text zu decodieren. Es ist besonders nützlich für Entwickler, IT-Profis und jeden, der mit Daten arbeitet, die sicher über textbasierte Kanäle übertragen werden müssen.

Wie Base64-Codierung funktioniert

Codierungsprozess

Die Base64-Codierung funktioniert, indem jede Gruppe von drei Bytes (24 Bit) Binärdaten in vier Base64-Zeichen umgewandelt wird. Der Prozess folgt diesen Schritten:

Konvertieren Sie den Eingabetext in seine binäre Darstellung (unter Verwendung von ASCII oder UTF-8-Codierung)
Gruppieren Sie die Binärdaten in Blöcke von 24 Bit (3 Bytes)
Teilen Sie jeden 24-Bit-Block in vier 6-Bit-Gruppen auf
Konvertieren Sie jede 6-Bit-Gruppe in ihr entsprechendes Base64-Zeichen

Wenn die Eingabelänge nicht durch 3 teilbar ist, wird mit "="-Zeichen aufgefüllt, um das Verhältnis von 4:3 zwischen Ausgaben- und Eingabelängen aufrechtzuerhalten.

Mathematische Darstellung

Für eine Byte-Sequenz $b_1, b_2, b_3$ werden die entsprechenden Base64-Zeichen $c_1, c_2, c_3, c_4$ wie folgt berechnet:

$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)]$

Wobei $\text{Base64}[i]$ das $i$ -te Zeichen im Base64-Alphabet darstellt.

Decodierungsprozess

Die Base64-Decodierung kehrt den Codierungsprozess um:

Konvertieren Sie jedes Base64-Zeichen in seinen 6-Bit-Wert
Verketten Sie diese 6-Bit-Werte
Gruppieren Sie die Bits in 8-Bit-Blöcke (Bytes)
Konvertieren Sie jedes Byte in sein entsprechendes Zeichen

Auffüllung

Wenn die zu codierende Anzahl von Bytes nicht durch 3 teilbar ist, wird Auffüllung angewendet:

Wenn ein Byte übrig bleibt, wird es in zwei Base64-Zeichen umgewandelt, gefolgt von "=="
Wenn zwei Bytes übrig bleiben, werden sie in drei Base64-Zeichen umgewandelt, gefolgt von "="

Beispiel

Lassen Sie uns den Text "Hallo" in Base64 codieren:

ASCII-Darstellung von "Hallo": 72 101 108 108 111
Binäre Darstellung: 01001000 01100101 01101100 01101100 01101111
Gruppierung in 6-Bit-Chunks: 010010 000110 010101 101100 011011 000110 1111
Der letzte Chunk hat nur 4 Bits, also fügen wir Nullen hinzu: 010010 000110 010101 101100 011011 000110 111100
Umwandlung in Dezimal: 18, 6, 21, 44, 27, 6, 60
Nachschlagen im Base64-Alphabet: S, G, V, s, b, G, 8
Das Ergebnis ist "SGVsbG8="

Beachten Sie die "=" Auffüllung am Ende, da die Eingabelänge (5 Bytes) nicht durch 3 teilbar ist.

Formel

Die allgemeine Formel zur Berechnung der Länge einer Base64-codierten Zeichenfolge lautet:

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

Wobei $\lceil x \rceil$ die Aufrundungsfunktion (Aufrundung auf die nächste ganze Zahl) darstellt.

Anwendungsfälle

Die Base64-Codierung wird in verschiedenen Anwendungen häufig verwendet:

E-Mail-Anhänge: MIME (Multipurpose Internet Mail Extensions) verwendet Base64 zur Codierung binärer Anhänge in E-Mails.
Daten-URLs: Einbetten kleiner Bilder, Schriftarten oder anderer Ressourcen direkt in HTML, CSS oder JavaScript unter Verwendung des data: URL-Schemas.
API-Kommunikation: Sicheres Übertragen von Binärdaten in JSON-Nutzlasten oder anderen textbasierten API-Formaten.
Speichern von Binärdaten in Textformaten: Wenn Binärdaten in XML, JSON oder anderen textbasierten Formaten gespeichert werden müssen.
Authentifizierungssysteme: Die grundlegende Authentifizierung in HTTP verwendet Base64-Codierung (obwohl es nicht um Sicherheit geht, sondern um Codierung).
Kryptografie: Als Teil verschiedener kryptografischer Protokolle und Systeme, oft zur Codierung von Schlüsseln oder Zertifikaten.
Cookie-Werte: Codierung komplexer Datenstrukturen, die in Cookies gespeichert werden sollen.

Alternativen

Obwohl Base64 weit verbreitet ist, gibt es Alternativen, die in bestimmten Situationen geeigneter sein könnten:

URL-sichere Base64: Eine Variante, die "-" und "_" anstelle von "+" und "/" verwendet, um Probleme mit der URL-Codierung zu vermeiden. Nützlich für Daten, die in URLs enthalten sein sollen.
Base32: Verwendet ein 32-Zeichen-Set, was zu einer längeren Ausgabe führt, aber eine bessere Lesbarkeit und Fallunempfindlichkeit bietet.
Hex-Codierung: Einfache Umwandlung in Hexadezimal, die weniger effizient ist (verdoppelt die Größe), aber sehr einfach und weit verbreitet unterstützt wird.
Binärübertragung: Für große Dateien oder wenn Effizienz entscheidend ist, sind direkte binäre Übertragungsprotokolle wie HTTP mit geeigneten Content-Type-Headern vorzuziehen.
Kompression + Base64: Bei großen Textdaten kann das Komprimieren vor der Codierung die Größensteigerung verringern.
JSON/XML-Serialisierung: Für strukturierte Daten könnte die Verwendung der nativen JSON- oder XML-Serialisierung geeigneter sein als die Base64-Codierung.

Geschichte

Die Base64-Codierung hat ihre Wurzeln in den frühen Computer- und Telekommunikationssystemen, in denen Binärdaten über Kanäle übertragen werden mussten, die für Text ausgelegt waren.

Die formale Spezifikation von Base64 wurde erstmals 1987 im RFC 989 veröffentlicht, das Privacy Enhanced Mail (PEM) definierte. Dies wurde später im RFC 1421 (1993) und RFC 2045 (1996, als Teil von MIME) aktualisiert.

Der Begriff "Base64" stammt daher, dass die Codierung 64 verschiedene ASCII-Zeichen verwendet, um Binärdaten darzustellen. Diese Wahl von 64 Zeichen war absichtlich, da 64 eine Potenz von 2 ist (2^6), was die Umwandlung zwischen Binär- und Base64 effizient macht.

Im Laufe der Zeit sind mehrere Varianten von Base64 entstanden:

Standard Base64: Wie im RFC 4648 definiert, verwendet A-Z, a-z, 0-9, +, / und = zur Auffüllung
URL-sichere Base64: Verwendet - und _ anstelle von + und /, um Probleme mit der URL-Codierung zu vermeiden
Dateiname-sichere Base64: Ähnlich wie URL-sichere, für die Verwendung in Dateinamen entwickelt
Modifizierte Base64 für IMAP: Wird im IMAP-Protokoll mit einem anderen Satz von Sonderzeichen verwendet

Trotz seines über drei Jahrzehnten alten Bestehens bleibt Base64 ein grundlegendes Werkzeug in der modernen Informatik, insbesondere mit dem Aufkommen von Webanwendungen und APIs, die stark auf textbasierte Datenformate wie JSON angewiesen sind.

Codebeispiele

Hier sind Beispiele für Base64-Codierung und -Decodierung in verschiedenen Programmiersprachen:

1// JavaScript Base64 Codierung/Dekodierung
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("Ungültige Base64-Zeichenfolge");
11  }
12}
13
14// Beispielverwendung
15const originalText = "Hallo, Welt!";
16const encoded = encodeToBase64(originalText);
17console.log("Codiert:", encoded);  // SGVsbG8sIFdvcmxkIQ==
18
19try {
20  const decoded = decodeFromBase64(encoded);
21  console.log("Dekodiert:", decoded);  // Hallo, Welt!
22} catch (error) {
23  console.error(error.message);
24}
25

1# Python Base64 Codierung/Dekodierung
2import base64
3
4def encode_to_base64(text):
5    # Konvertieren Sie den String in Bytes und codieren Sie ihn
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        # Konvertieren Sie die Base64-Zeichenfolge in Bytes und dekodieren Sie sie
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"Ungültige Base64-Zeichenfolge: {e}")
18
19# Beispielverwendung
20original_text = "Hallo, Welt!"
21encoded = encode_to_base64(original_text)
22print(f"Codiert: {encoded}")  # SGVsbG8sIFdvcmxkIQ==
23
24try:
25    decoded = decode_from_base64(encoded)
26    print(f"Dekodiert: {decoded}")  # Hallo, Welt!
27except ValueError as e:
28    print(e)
29

1// Java Base64 Codierung/Dekodierung
2import java.util.Base64;
3import java.nio.charset.StandardCharsets;
4
5public class Base64Beispiel {
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("Ungültige Base64-Zeichenfolge: " + e.getMessage());
19        }
20    }
21    
22    public static void main(String[] args) {
23        String originalText = "Hallo, Welt!";
24        String encoded = encodeToBase64(originalText);
25        System.out.println("Codiert: " + encoded);  // SGVsbG8sIFdvcmxkIQ==
26        
27        try {
28            String decoded = decodeFromBase64(encoded);
29            System.out.println("Dekodiert: " + decoded);  // Hallo, Welt!
30        } catch (IllegalArgumentException e) {
31            System.err.println(e.getMessage());
32        }
33    }
34}
35

1<?php
2// PHP Base64 Codierung/Dekodierung
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("Ungültige Base64-Zeichenfolge");
11    }
12    return $decoded;
13}
14
15// Beispielverwendung
16$originalText = "Hallo, Welt!";
17$encoded = encodeToBase64($originalText);
18echo "Codiert: " . $encoded . "\n";  // SGVsbG8sIFdvcmxkIQ==
19
20try {
21    $decoded = decodeFromBase64($encoded);
22    echo "Dekodiert: " . $decoded . "\n";  // Hallo, Welt!
23} catch (Exception $e) {
24    echo "Fehler: " . $e->getMessage() . "\n";
25}
26?>
27

1// C# Base64 Codierung/Dekodierung
2using System;
3using System.Text;
4
5class Base64Beispiel
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("Ungültige Base64-Zeichenfolge");
23        }
24    }
25    
26    static void Main()
27    {
28        string originalText = "Hallo, Welt!";
29        string encoded = EncodeToBase64(originalText);
30        Console.WriteLine($"Codiert: {encoded}");  // SGVsbG8sIFdvcmxkIQ==
31        
32        try
33        {
34            string decoded = DecodeFromBase64(encoded);
35            Console.WriteLine($"Dekodiert: {decoded}");  // Hallo, Welt!
36        }
37        catch (FormatException e)
38        {
39            Console.WriteLine($"Fehler: {e.Message}");
40        }
41    }
42}
43

1# Ruby Base64 Codierung/Dekodierung
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 "Ungültige Base64-Zeichenfolge: #{e.message}"
13  end
14end
15
16# Beispielverwendung
17original_text = "Hallo, Welt!"
18encoded = encode_to_base64(original_text)
19puts "Codiert: #{encoded}"  # SGVsbG8sIFdvcmxkIQ==
20
21begin
22  decoded = decode_from_base64(encoded)
23  puts "Dekodiert: #{decoded}"  # Hallo, Welt!
24rescue StandardError => e
25  puts "Fehler: #{e.message}"
26end
27

1// Go Base64 Codierung/Dekodierung
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(base64String string) (string, error) {
14    bytes, err := base64.StdEncoding.DecodeString(base64String)
15    if err != nil {
16        return "", fmt.Errorf("ungültige Base64-Zeichenfolge: %v", err)
17    }
18    return string(bytes), nil
19}
20
21func main() {
22    originalText := "Hallo, Welt!"
23    encoded := encodeToBase64(originalText)
24    fmt.Println("Codiert:", encoded)  // SGVsbG8sIFdvcmxkIQ==
25    
26    decoded, err := decodeFromBase64(encoded)
27    if err != nil {
28        fmt.Println("Fehler:", err)
29    } else {
30        fmt.Println("Dekodiert:", decoded)  // Hallo, Welt!
31    }
32}
33

1// Swift Base64 Codierung/Dekodierung
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// Beispielverwendung
19let originalText = "Hallo, Welt!"
20if let encoded = encodeToBase64(originalText) {
21    print("Codiert: \(encoded)")  // SGVsbG8sIFdvcmxkIQ==
22    
23    if let decoded = decodeFromBase64(encoded) {
24        print("Dekodiert: \(decoded)")  // Hallo, Welt!
25    } else {
26        print("Fehler: Konnte die Base64-Zeichenfolge nicht dekodieren")
27    }
28} else {
29    print("Fehler: Konnte den Text nicht codieren")
30}
31

1' Excel VBA Base64 Codierung/Dekodierung
2' Hinweis: Dies erfordert einen Verweis auf 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 = "Fehler: Ungültige Base64-Zeichenfolge"
39End Function
40
41' Verwendung in einem Arbeitsblatt:
42' =EncodeToBase64("Hallo, Welt!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
44

1# R Base64 Codierung/Dekodierung
2# Erfordert das 'base64enc'-Paket
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7  # Konvertieren Sie den Text in rohe Bytes, dann codieren
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    # Konvertieren Sie die Base64-Zeichenfolge in rohe Bytes, dann dekodieren
16    base64_raw <- charToRaw(base64_string)
17    decoded_raw <- base64decode(base64_raw)
18    return(rawToChar(decoded_raw))
19  }, error = function(e) {
20    stop(paste("Ungültige Base64-Zeichenfolge:", e$message))
21  })
22}
23
24# Beispielverwendung
25original_text <- "Hallo, Welt!"
26encoded <- encode_to_base64(original_text)
27cat("Codiert:", encoded, "\n")  # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30  decoded <- decode_from_base64(encoded)
31  cat("Dekodiert:", decoded, "\n")  # Hallo, Welt!
32}, error = function(e) {
33  cat("Fehler:", e$message, "\n")
34})
35

1% MATLAB Base64 Codierung/Dekodierung
2function demo_base64()
3    originalText = 'Hallo, Welt!';
4    
5    % Codieren
6    encoded = encode_to_base64(originalText);
7    fprintf('Codiert: %s\n', encoded);  % SGVsbG8sIFdvcmxkIQ==
8    
9    % Dekodieren
10    try
11        decoded = decode_from_base64(encoded);
12        fprintf('Dekodiert: %s\n', decoded);  % Hallo, Welt!
13    catch e
14        fprintf('Fehler: %s\n', e.message);
15    end
16end
17
18function encoded = encode_to_base64(text)
19    % Konvertieren Sie den Text in ein uint8-Array und codieren Sie ihn
20    bytes = uint8(text);
21    encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25    try
26        % Dekodieren Sie die Base64-Zeichenfolge in ein uint8-Array
27        bytes = base64decode(base64String);
28        decoded = char(bytes);
29    catch
30        error('Ungültige Base64-Zeichenfolge');
31    end
32end
33

1// C Base64 Codierung/Dekodierung mit 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; // Ungültige Base64-Eingabe
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 = "Hallo, Welt!";
58    
59    char* encoded = encode_to_base64(original_text);
60    printf("Codiert: %s\n", encoded);  // SGVsbG8sIFdvcmxkIQ==
61    
62    char* decoded = decode_from_base64(encoded);
63    if (decoded) {
64        printf("Dekodiert: %s\n", decoded);  // Hallo, Welt!
65        free(decoded);
66    } else {
67        printf("Fehler: Ungültige Base64-Zeichenfolge\n");
68    }
69    
70    free(encoded);
71    
72    return 0;
73}
74

1// Rust Base64 Codierung/Dekodierung
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!("Ungültige UTF-8-Sequenz: {}", e))
15            }
16        },
17        Err(e) => Err(format!("Ungültige Base64-Zeichenfolge: {}", e))
18    }
19}
20
21fn main() {
22    let original_text = "Hallo, Welt!";
23    let encoded = encode_to_base64(original_text);
24    println!("Codiert: {}", encoded);  // SGVsbG8sIFdvcmxkIQ==
25    
26    match decode_from_base64(&encoded) {
27        Ok(decoded) => println!("Dekodiert: {}", decoded),  // Hallo, Welt!
28        Err(e) => println!("Fehler: {}", e)
29    }
30}
31

Randfälle und Überlegungen

Beim Arbeiten mit Base64-Codierung und -Decodierung sollten Sie sich dieser wichtigen Überlegungen bewusst sein:

Unicode und Nicht-ASCII-Zeichen: Stellen Sie sicher, dass Sie vor der Base64-Codierung die richtige Zeichencodierung (in der Regel UTF-8) verwenden, wenn Sie Texte mit Nicht-ASCII-Zeichen codieren.
Auffüllung: Standard-Base64 verwendet Auffüllung mit "="-Zeichen, um sicherzustellen, dass die Ausgabelänge ein Vielfaches von 4 ist. Einige Implementierungen erlauben das Weglassen der Auffüllung, was zu Kompatibilitätsproblemen führen kann.
Zeilenumbrüche: Traditionelle Base64-Implementierungen fügen Zeilenumbrüche (typischerweise alle 76 Zeichen) zur Lesbarkeit hinzu, aber moderne Anwendungen lassen diese oft weg.
URL-sichere Base64: Standard-Base64 verwendet "+" und "/" Zeichen, die in URLs eine spezielle Bedeutung haben. Verwenden Sie für URL-Kontexte URL-sichere Base64, die diese durch "-" und "_" ersetzt.
Whitespace: Einige Implementierungen sind nachsichtig und ignorieren Whitespace beim Dekodieren, während andere exakte Eingaben erfordern.
Größenzunahme: Die Base64-Codierung erhöht die Größe der Daten um etwa 33% (4 Ausgabebytes für 3 Eingabebytes).
Leistung: Die Base64-Codierung/-Dekodierung kann bei sehr großen Daten rechnerisch intensiv sein. Berücksichtigen Sie Streaming-Ansätze für große Dateien.

Whiz Tools

Base64 Encoder und Decoder: Konvertiere Text zu/von Base64

Base64 Encoder/Decoder

Dokumentation