Gratis nettverktøy for å kode tekst til Base64 eller dekode Base64-strenger tilbake til tekst. Støtter standard og URL-sikker Base64-koding med øyeblikkelig konvertering.
Base64 er et binær-til-tekst kodingsskjema som representerer binær data i et ASCII-strengformat. Det er designet for å overføre data lagret i binære formater over kanaler som bare pålitelig støtter tekstinnhold. Base64-koding konverterer binær data til et sett med 64 tegn (derav navnet) som kan overføres trygt over tekstbaserte protokoller uten datakorruptjon.
Base64-tegnsettet består av:
Dette verktøyet lar deg enkelt kode tekst til Base64-format eller dekode Base64-strenger tilbake til deres opprinnelige tekst. Det er spesielt nyttig for utviklere, IT-profesjonelle og alle som arbeider med data som må overføres trygt over tekstbaserte kanaler. Med vår sanntidskonverteringsfunksjon kan du umiddelbart se resultatene mens du skriver, noe som gjør arbeidsflyten din for koding og dekoding mer effektiv.
Base64-koding fungerer ved å konvertere hver gruppe av tre byte (24 biter) av binær data til fire Base64-tegn. Prosessen følger disse trinnene:
Når inndatalengden ikke er delelig med 3, legges det til padding med "=" tegn for å opprettholde 4:3-forholdet mellom utdata og inndata lengder.
For en sekvens av byte , beregnes de tilsvarende Base64-tegnene som:
Hvor representerer det -te tegnet i Base64-alphabetet.
Base64-dekoding reverserer kodingprosessen:
Når antallet byte som skal kodes ikke er delelig med 3, brukes padding:
La oss kode teksten "Hello" til Base64:
Merk "=" padding på slutten fordi inndatalengden (5 byte) ikke er delelig med 3.
Den generelle formelen for å beregne lengden på en Base64-kodet streng er:
Hvor representerer takfunksjonen (avrunder opp til nærmeste heltall).
Vårt Base64-verktøy gir en enkel og effektiv måte å kode tekst til Base64 eller dekode Base64 tilbake til tekst. Slik bruker du det:
Verktøyet vårt inkluderer nå en sanntidskonverteringsmulighet som oppdaterer utdataene mens du skriver:
Sanntidskonverteringsfunksjonen er spesielt nyttig når:
For veldig store inndata bruker verktøyet debouncing for å opprettholde ytelsen, og sikrer at konvertering bare skjer etter at du har stoppet skrivingen kort, i stedet for ved hver tastetrykk.
Base64-koding brukes mye i ulike applikasjoner:
E-postvedlegg: MIME (Multipurpose Internet Mail Extensions) bruker Base64 for å kode binære vedlegg i e-post.
Data-URL-er: Inkludere små bilder, skrifttyper eller andre ressurser direkte i HTML, CSS eller JavaScript ved hjelp av data: URL-skjemaet.
API-kommunikasjon: Trygt overføre binær data i JSON-payloads eller andre tekstbaserte API-formater.
Lagring av binær data i tekstformater: Når binær data må lagres i XML, JSON eller andre tekstbaserte formater.
Autentiseringssystemer: Grunnleggende autentisering i HTTP bruker Base64-koding (selv om det ikke er for sikkerhet, bare for koding).
Kryptografi: Som en del av ulike kryptografiske protokoller og systemer, ofte for å kode nøkler eller sertifikater.
Cookie-verdier: Koding av komplekse datastrukturer for å lagres i informasjonskapsler.
Selv om Base64 er mye brukt, finnes det alternativer som kan være mer passende i visse situasjoner:
URL-sikker Base64: En variant som bruker "-" og "_" i stedet for "+" og "/" for å unngå URL-koding problemer. Nyttig for data som skal inkluderes i URL-er.
Base32: Bruker et 32-tegns sett, noe som resulterer i lengre utdata, men med bedre menneskelig lesbarhet og case-insensitivitet.
Hex-koding: Enkel konvertering til heksadesimal, som er mindre effektiv (dobler størrelsen) men veldig enkel og mye støttet.
Binær overføring: For store filer eller når effektivitet er avgjørende, er direkte binær overføringsprotokoller som HTTP med passende Content-Type-hoder å foretrekke.
Kompresjon + Base64: For store tekstdata kan komprimering før koding redusere størrelsesøkningen.
JSON/XML-serialisering: For strukturerte data kan bruk av native JSON eller XML-serialisering være mer passende enn Base64-koding.
Base64-koding har sine røtter i tidlig databehandling og telekommunikasjonssystemer der binær data måtte overføres over kanaler designet for tekst.
Den formelle spesifikasjonen av Base64 ble først publisert i 1987 som en del av RFC 989, som definerte Privacy Enhanced Mail (PEM). Dette ble senere oppdatert i RFC 1421 (1993) og RFC 2045 (1996, som en del av MIME).
Begrepet "Base64" kommer fra det faktum at kodingen bruker 64 forskjellige ASCII-tegn for å representere binær data. Dette valget av 64 tegn var bevisst, ettersom 64 er en makt av 2 (2^6), noe som gjør konverteringen mellom binær og Base64 effektiv.
Over tid har flere varianter av Base64 dukket opp:
Til tross for at den er over tre tiår gammel, forblir Base64 et grunnleggende verktøy i moderne databehandling, spesielt med fremveksten av webapplikasjoner og API-er som i stor grad er avhengige av tekstbaserte dataformater som JSON.
Her er eksempler på Base64-koding og dekoding i forskjellige programmeringsspråk:
1// JavaScript Base64 Koding/Dekoding
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("Ugyldig Base64-streng");
11 }
12}
13
14// Eksempel på bruk
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Kodet:", encoded); // SGVsbG8sIFdvcmxkIQ==
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Dekodet:", decoded); // Hello, World!
22} catch (error) {
23 console.error(error.message);
24}
251# Python Base64 Koding/Dekoding
2import base64
3
4def encode_to_base64(text):
5 # Konvertere streng til bytes og deretter kode
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 # Konvertere base64-streng til bytes og deretter dekode
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"Ugyldig Base64-streng: {e}")
18
19# Eksempel på bruk
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Kodet: {encoded}") # SGVsbG8sIFdvcmxkIQ==
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Dekodet: {decoded}") # Hello, World!
27except ValueError as e:
28 print(e)
291// Java Base64 Koding/Dekoding
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("Ugyldig Base64-streng: " + 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("Kodet: " + encoded); // SGVsbG8sIFdvcmxkIQ==
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Dekodet: " + decoded); // Hello, World!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// PHP Base64 Koding/Dekoding
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("Ugyldig Base64-streng");
11 }
12 return $decoded;
13}
14
15// Eksempel på bruk
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Kodet: " . $encoded . "\n"; // SGVsbG8sIFdvcmxkIQ==
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Dekodet: " . $decoded . "\n"; // Hello, World!
23} catch (Exception $e) {
24 echo "Feil: " . $e->getMessage() . "\n";
25}
26?>
271// C# Base64 Koding/Dekoding
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("Ugyldig Base64-streng");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Hello, World!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Kodet: {encoded}"); // SGVsbG8sIFdvcmxkIQ==
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Dekodet: {decoded}"); // Hello, World!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Feil: {e.Message}");
40 }
41 }
42}
431# Ruby Base64 Koding/Dekoding
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 "Ugyldig Base64-streng: #{e.message}"
13 end
14end
15
16# Eksempel på bruk
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Kodet: #{encoded}" # SGVsbG8sIFdvcmxkIQ==
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Dekodet: #{decoded}" # Hello, World!
24rescue StandardError => e
25 puts "Feil: #{e.message}"
26end
271// Go Base64 Koding/Dekoding
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("ugyldig Base64-streng: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Hello, World!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Kodet:", encoded) // SGVsbG8sIFdvcmxkIQ==
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Feil:", err)
29 } else {
30 fmt.Println("Dekodet:", decoded) // Hello, World!
31 }
32}
331// Swift Base64 Koding/Dekoding
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(_ base64_string: String) -> String? {
12 if let data = Data(base64Encoded: base64_string) {
13 return String(data: data, encoding: .utf8)
14 }
15 return nil
16}
17
18// Eksempel på bruk
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21 print("Kodet: \(encoded)") // SGVsbG8sIFdvcmxkIQ==
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Dekodet: \(decoded)") // Hello, World!
25 } else {
26 print("Feil: Kunne ikke dekode Base64-streng")
27 }
28} else {
29 print("Feil: Kunne ikke kode tekst")
30}
311' Excel VBA Base64 Koding/Dekoding
2' Merk: Dette krever en referanse til 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 = "Feil: Ugyldig Base64-streng"
39End Function
40
41' Bruk i et regneark:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# R Base64 Koding/Dekoding
2# Krever 'base64enc' pakken
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Konvertere tekst til rå byte, deretter kode
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 # Konvertere base64-streng til rå, deretter dekode
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("Ugyldig Base64-streng:", e$message))
21 })
22}
23
24# Eksempel på bruk
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Kodet:", encoded, "\n") # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Dekodet:", decoded, "\n") # Hello, World!
32}, error = function(e) {
33 cat("Feil:", e$message, "\n")
34})
351% MATLAB Base64 Koding/Dekoding
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Kode
6 encoded = encode_to_base64(originalText);
7 fprintf('Kodet: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Dekode
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Dekodet: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Feil: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Konvertere tekst til uint8-array og kode
20 bytes = uint8(text);
21 encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25 try
26 % Dekode base64-streng til uint8-array
27 bytes = base64decode(base64String);
28 decoded = char(bytes);
29 catch
30 error('Ugyldig Base64-streng');
31 end
32end
331// C Base64 Koding/Dekoding ved bruk av 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; // Ugyldig Base64-inndata
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("Kodet: %s\n", encoded); // SGVsbG8sIFdvcmxkIQ==
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Dekodet: %s\n", decoded); // Hello, World!
65 free(decoded);
66 } else {
67 printf("Feil: Ugyldig Base64-streng\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Rust Base64 Koding/Dekoding
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!("Ugyldig UTF-8-sekvens: {}", e))
15 }
16 },
17 Err(e) => Err(format!("Ugyldig Base64-streng: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Hello, World!";
23 let encoded = encode_to_base64(original_text);
24 println!("Kodet: {}", encoded); // SGVsbG8sIFdvcmxkIQ==
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Dekodet: {}", decoded), // Hello, World!
28 Err(e) => println!("Feil: {}", e)
29 }
30}
31Her er et eksempel på hvordan du kan implementere sanntidskonverteringsfunksjonen i JavaScript:
1// JavaScript-implementasjon med sanntidskonvertering
2const textInput = document.getElementById('text-input');
3const base64Output = document.getElementById('base64-output');
4const liveConversionCheckbox = document.getElementById('live-conversion');
5let debounceTimeout = null;
6
7// Funksjon for å kode med debouncing for ytelse
8function liveEncode() {
9 // Tøm eventuelle eksisterende tidsavbrudd
10 if (debounceTimeout) {
11 clearTimeout(debounceTimeout);
12 }
13
14 // Sett et nytt tidsavbrudd for å forhindre overdreven behandling under rask skriving
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('Koding feil:', e);
25 // Håndtere feil på passende måte i brukergrensesnittet
26 }
27 }, 300); // 300ms debounce-forsinkelse
28}
29
30// Hendelseslyttere
31liveConversionCheckbox.addEventListener('change', function() {
32 if (this.checked) {
33 // Aktiver sanntidskonvertering
34 textInput.addEventListener('input', liveEncode);
35 // Første kode
36 liveEncode();
37 } else {
38 // Deaktiver sanntidskonvertering
39 textInput.removeEventListener('input', liveEncode);
40 }
41});
42Når du arbeider med Base64-koding og dekoding, vær oppmerksom på disse viktige hensynene:
Unicode og ikke-ASCII-tegn: Når du koder tekst med ikke-ASCII-tegn, må du sørge for riktig tegnkoding (vanligvis UTF-8) før Base64-koding.
Padding: Standard Base64 bruker padding med "=" tegn for å sikre at utdata lengden er et multiplum av 4. Noen implementeringer tillater å utelate padding, noe som kan forårsake kompatibilitetsproblemer.
Linjeskift: Tradisjonelle Base64-implementeringer setter inn linjeskift (vanligvis hver 76 tegn) for lesbarhet, men moderne applikasjoner utelater ofte disse.
URL-sikker Base64: Standard Base64 bruker "+" og "/" tegn som har spesielle betydninger i URL-er. For URL-kontekster, bruk URL-sikker Base64 som erstatter disse med "-" og "_".
Whitespace: Ved dekoding er noen implementeringer tolerante og ignorerer whitespace, mens andre krever nøyaktig inndata.
Størrelsesøkning: Base64-koding øker størrelsen på data med omtrent 33% (4 utdata byte for hver 3 inndata byte).
Ytelse: Base64-koding/dekoding kan være beregningsmessig intensivt for veldig store data. Verktøyet vårt bruker debouncing for å opprettholde responsivitet selv med større inndata.
Sanntidskonverteringshensyn: Når du bruker sanntidskonverteringsfunksjonen med veldig store inndata, kan du merke en liten forsinkelse når verktøyet behandler dataene. Dette er normalt og hjelper til med å opprettholde nettleserens ytelse.
Sanntidskonverteringsfunksjonen oppdaterer automatisk utdataene mens du skriver, uten å kreve at du klikker på kode- eller dekodeknappen. Dette gir umiddelbar tilbakemelding og gjør verktøyet mer interaktivt og effektivt å bruke.
Vår implementering bruker debouncing for å sikre god ytelse selv med større inndata. Konverteringen skjer bare etter at du har stoppet skrivingen kort, i stedet for ved hver tastetrykk, noe som forhindrer overdreven behandling under rask skriving.
Sanntidskonvertering er ideell for interaktivt arbeid der du vil ha umiddelbar tilbakemelding. For veldig store datasett eller når du vil gjennomgå inndataene dine før konvertering, kan du foretrekke den manuelle konverteringsalternativet.
Ja, sanntidskonverteringsfunksjonen fungerer i begge retninger - fra tekst til Base64 og fra Base64 til tekst.
Hvis du skriver inn ugyldige Base64-tegn mens du er i dekodingsmodus med sanntidskonvertering aktivert, vil verktøyet vise en feilmelding i sanntid, noe som hjelper deg med å identifisere og korrigere problemet umiddelbart.
Prøv vårt Base64 Encoder/Decoder-verktøy i dag for raskt å konvertere mellom tekst og Base64-formater med bekvemmeligheten av sanntidskonvertering. Enten du er en utvikler som arbeider med API-er, håndterer e-postvedlegg, eller innebygger binær data i tekstformater, gjør vårt verktøy prosessen enkel og effektiv.
Oppdag flere verktøy som kan være nyttige for arbeidsflyten din