Base64 Opmaak

Gerelateerde aanbevelingen

Wat is Base64-opmaak?

Toepassingsgevallen

• Lange Base64-strings op aanpasbare breedte verdelen voor betere leesbaarheid en screenshots
• Base64 opmaken voor technische documentatie, ticketregistratie of e-mailpresentatie
• Base64-opmaak optimaliseren voor printen of archivering
• Combineren met splits- en samenvoegtools voor Base64-structuuraanpassing
• Base64 op MIME-standaard (76 tekens) vouwen voor e-mailbijlagen
• Base64 over meerdere regels weergeven bij code-review om afwijkende tekens te vinden
• Base64 insluiten in Markdown met 4 spaties inspringing om codestijl te behouden
• Monitoring-dashboards: lange Base64-payloads over meerdere regels weergeven

Hoe te gebruiken

1. Plak de te formatteren Base64-string (met of zonder regelovergangen)
2. Kies de tekenbreedte per regel: 64 / 76 / 80 / 100
3. Kies de inspringing: 0 / 2 / 4 spaties
4. De tool formatteert realtime volgens de gekozen breedte en inspringing
5. Kopieer het opmaakresultaat voor documentatie, of klik op Herstel om regelovergangen te verwijderen

Functies

• Aanpasbare tekenbreedte: ondersteunt 64 / 76 / 80 / 100 tekens per regel, flexibel voor uiteenlopende opmaakbehoeften
• Configureerbare inspringing: ondersteunt 0 / 2 / 4 spaties inspringing, handig voor uitlijning in codeblokken of Markdown
• Pure weergave-optimalisatie: past alleen de weergave aan, wijzigt de oorspronkelijke Base64-coderingsdata niet
• Realtime opmaak: 200 ms debounce, opmaak tijdens het typen zonder vertraging
• Eén-klik herstel: verwijder alle regelovergangen en inspringing, herstel naar Base64 op één regel
• Teken- en regeltelling: realtime weergave van aantal tekens en totaal aantal regels
• Eén-klik kopiëren: opmaakresultaat direct naar klembord kopiëren, voor documentatie of ticketregistratie
• Lokaal in de browser, geen upload: alle opmaak gebeurt in de browser, zonder tussenkomst van een server

Codevoorbeelden

// Base64-opmaakfunctie (logica identiek aan deze tool)
function formatBase64(input, lineLength = 76, indent = 0) {
  // 1. Verwijder alle witruimtetekens
  const clean = input.replace(/\s/g, '');
  if (!clean) return '';

  // 2. Splits op opgegeven breedte
  const lines = [];
  for (let i = 0; i < clean.length; i += lineLength) {
    const line = clean.slice(i, i + lineLength);
    lines.push(' '.repeat(indent) + line);
  }

  // 3. Voeg samen met regelovergangen
  return lines.join('\n');
}

// Gebruiksvoorbeeld
const b64 = 'a'.repeat(200);
console.log(formatBase64(b64, 76, 0));
// Uitvoer: Base64 met 76 tekens per regel

// Ontformatteren (voor decodering of transmissie)
function unformatBase64(input) {
  return input.replace(/\s/g, '');
}

console.log(unformatBase64(formatBase64(b64, 76, 0)).length); // 200

import textwrap

def format_base64(b64_str: str, width: int = 76, indent: int = 0) -> str:
    """Formatteer Base64-string naar meerdere regels"""
    # Verwijder alle witruimte
    clean = ''.join(b64_str.split())
    if not clean:
        return ''

    # Gebruik textwrap om op breedte te splitsen
    lines = textwrap.wrap(clean, width=width)

    # Voeg inspringing toe
    if indent > 0:
        lines = [' ' * indent + line for line in lines]

    return '\n'.join(lines)


# Gebruiksvoorbeeld
b64 = 'aGVsbG8gd29ybGQ=' * 10
print(format_base64(b64, 76, 0))

# Reproduceer MIME Base64 (RFC 2045)
mime_format = format_base64(b64, 76)
print(f'MIME Base64 aantal regels: {len(mime_format.splitlines())}')

# Herstel naar één regel
single_line = b64.replace('\n', '').replace(' ', '')
print(f'Enkele regel lengte: {len(single_line)}')

# 1. Base64 invoer -> vouwen op 76 tekens (MIME-standaard)
echo "aGVsbG8gd29ybGQ=" | base64 | base64 | fold -w 76

# 2. Lang Base64-bestand formatteren -> uitvoer naar nieuw bestand
fold -w 76 encoded.txt > formatted.txt

# 3. Vouwen op 64 tekens (compacte weergave)
fold -w 64 encoded.txt > compact.txt

# 4. Verwijder alle regelovergangen tegelijk (ontformatteren)
tr -d '\n' < formatted.txt > single-line.txt

# 5. Verificatie: Base64-lengte + aantal regels
wc -c encoded.txt | awk '{print "Aantal tekens:", $1}'
wc -l formatted.txt | awk '{print "Aantal regels:", $1}'

# 6. Combineer met openssl voor volledige base64-codering + opmaak
echo "Hello wereld" | openssl base64 -A | fold -w 76 > hello.b64.txt
cat hello.b64.txt

Veelgestelde vragen

Probleemoplossing

Woordenlijst

Base64-opmaak

Verdeelt een Base64-string op weergaveniveau in meerdere regels volgens opgegeven breedte; beïnvloedt alleen de visuele weergave, niet de codering zelf.

MIME Base64

De Base64-variant volgens RFC 2045 met regelovergang na elke 76 tekens, voornamelijk voor e-mailbijlagen.

Tekenbreedte (line length)

Aantal Base64-tekens per regel. Gangbare waarden: 64 (compact), 76 (MIME-standaard), 80 (standaard print), 100 (breedbeeld).

Inspringing (indent)

Aantal spaties aan het begin van elke regel. Gangbare waarden: 0 (geen), 2 (codestijl), 4 (Markdown-codeblok).

Witruimtetekens (whitespace)

Mogelijke spaties, tabs en regelovergangen in een Base64-string. Bij opmaak worden deze eerst verwijderd en vervolgens opnieuw ingevoegd volgens de opgegeven breedte.

Ontformatteren (unformat)

Zet opgemaakte Base64 (meerdere regels + inspringing) terug naar een enkele regel zonder witruimte, voor decodering of transmissie.

Vergelijkingstabel van 4 tekenbreedtes

Verschillende tekenbreedtes zijn geschikt voor verschillende weergavescenario's; kies op basis van de doelomgeving.

Vergelijkingstabel van 3 inspringstijlen

Verschillende inspringstijlen passen bij verschillende codenormen; kies op basis van team-/projectgewoonte.

Authoritative References

• IETFRFC 4648 - Base16, Base32, Base64 coderingsstandaard
• IETFRFC 2045 - MIME Deel één (76-tekens vouwstandaard)
• MDNMDN - window.atob() Base64-decodering
• MDNMDN - Woordenlijst: Base64
• WikipediaWikipedia - Base64