Base64 Kodirač i Dekodirač: Pretvorite Tekst u/iz Base64
Besplatni online alat za kodiranje teksta u Base64 ili dekodiranje Base64 nizova natrag u tekst. Podržava standardno i URL-sigurno Base64 kodiranje s trenutnom konverzijom.
Base64 Kodirač/ Dekoder
Pretvorite tekst u Base64 kodiranje i obrnuto
Dokumentacija
Base64 Encoder i Decoder
Uvod
Base64 je shema kodiranja binarnih podataka u tekst koja predstavlja binarne podatke u ASCII string formatu. Dizajnirana je za prenošenje podataka pohranjenih u binarnim formatima preko kanala koji pouzdano podržavaju samo tekstualni sadržaj. Base64 kodiranje pretvara binarne podatke u skup od 64 znaka (otuda i naziv) koji se mogu sigurno prenositi putem protokola temeljenih na tekstu bez oštećenja podataka.
Skup znakova Base64 sastoji se od:
- Velikih slova A-Z (26 znakova)
- Malih slova a-z (26 znakova)
- Brojeva 0-9 (10 znakova)
- Dva dodatna znaka, obično "+" i "/" (2 znaka)
Ovaj alat vam omogućuje da lako kodirate tekst u Base64 format ili dekodirate Base64 stringove natrag u njihov izvorni tekst. Osobito je koristan za programere, IT profesionalce i sve koji rade s podacima koji se trebaju sigurno prenositi preko kanala temeljenih na tekstu.
Kako Base64 Kodiranje Funkcionira
Proces Kodiranja
Base64 kodiranje radi tako da svaki skup od tri bajta (24 bita) binarnih podataka pretvara u četiri Base64 znaka. Proces slijedi ove korake:
- Pretvorite ulazni tekst u njegovu binarnu reprezentaciju (koristeći ASCII ili UTF-8 kodiranje)
- Grupirajte binarne podatke u komade od 24 bita (3 bajta)
- Podijelite svaki 24-bitni komad u četiri 6-bitne grupe
- Pretvorite svaku 6-bitnu grupu u njen odgovarajući Base64 znak
Kada duljina ulaza nije djeljiva s 3, dodaje se padding s "=" znakovima kako bi se održala omjer 4:3 između duljina izlaza i ulaza.
Matematička Reprezentacija
Za niz bajtova , odgovarajući Base64 znakovi izračunavaju se kao:
Gdje predstavlja -ti znak u Base64 abecedi.
Proces Dekodiranja
Base64 dekodiranje obrće proces kodiranja:
- Pretvorite svaki Base64 znak u njegovu 6-bitnu vrijednost
- Spojite ove 6-bitne vrijednosti
- Grupirajte bitove u 8-bitne komade (bajte)
- Pretvorite svaki bajt u njegov odgovarajući znak
Padding
Kada broj bajtova koji se kodiraju nije djeljiv s 3, primjenjuje se padding:
- Ako ostane jedan bajt, pretvara se u dva Base64 znaka praćena "=="
- Ako ostanu dva bajta, oni se pretvaraju u tri Base64 znaka praćena "="
Primjer
Kodirajmo tekst "Hello" u Base64:
- ASCII reprezentacija "Hello": 72 101 108 108 111
- Binarna reprezentacija: 01001000 01100101 01101100 01101100 01101111
- Grupiranje u 6-bitne komade: 010010 000110 010101 101100 011011 000110 1111
- Posljednji komad ima samo 4 bita, pa dodajemo nule: 010010 000110 010101 101100 011011 000110 111100
- Pretvaranje u decimalu: 18, 6, 21, 44, 27, 6, 60
- Pretraživanje u Base64 abecedi: S, G, V, s, b, G, 8
- Rezultat je "SGVsbG8="
Primijetite "=" padding na kraju jer duljina ulaza (5 bajtova) nije djeljiva s 3.
Formula
Opća formula za izračunavanje duljine Base64 kodiranog stringa je:
Gdje predstavlja funkciju zaokruživanja (zaokruživanje na najbliži cijeli broj prema gore).
Upotrebe
Base64 kodiranje se široko koristi u raznim aplikacijama:
-
Email Prilozi: MIME (Multipurpose Internet Mail Extensions) koristi Base64 za kodiranje binarnih priloga u emailovima.
-
Data URL-ovi: Uključivanje malih slika, fontova ili drugih resursa direktno u HTML, CSS ili JavaScript koristeći
data:URL shemu. -
API Komunikacije: Sigurno prenošenje binarnih podataka u JSON payload-ima ili drugim formatima API-ja temeljenim na tekstu.
-
Pohrana Binarnih Podataka u Tekstualnim Formatima: Kada se binarni podaci trebaju pohraniti u XML, JSON ili druge tekstualne formate.
-
Sustavi Autentifikacije: Osnovna autentifikacija u HTTP-u koristi Base64 kodiranje (iako nije za sigurnost, već za kodiranje).
-
Kriptografija: Kao dio raznih kriptografskih protokola i sustava, često za kodiranje ključeva ili certifikata.
-
Vrijednosti Kolačića: Kodiranje složenih struktura podataka za pohranu u kolačićima.
Alternativne Opcije
Iako je Base64 široko korišten, postoje alternativne opcije koje bi mogle biti prikladnije u određenim situacijama:
-
URL-sigurno Base64: Varijanta koja koristi "-" i "_" umjesto "+" i "/" kako bi izbjegla probleme s URL kodiranjem. Korisno za podatke koji će biti uključeni u URL-ove.
-
Base32: Koristi skup od 32 znaka, što rezultira dužim izlazom, ali s boljom čitljivošću za ljude i bez obzira na velika/mala slova.
-
Hex Kodiranje: Jednostavna konverzija u heksadecimalni oblik, koja je manje učinkovita (udvostručuje veličinu) ali vrlo jednostavna i široko podržana.
-
Binarni Prijenos: Za velike datoteke ili kada je učinkovitost ključna, izravni binarni prijenosni protokoli poput HTTP-a s odgovarajućim Content-Type zaglavljima su poželjniji.
-
Kompresija + Base64: Za velike tekstualne podatke, kompresija prije kodiranja može umanjiti povećanje veličine.
-
JSON/XML Serijalizacija: Za strukturirane podatke, korištenje izvorne JSON ili XML serijalizacije može biti prikladnije od Base64 kodiranja.
Povijest
Base64 kodiranje ima svoje korijene u ranom računalstvu i telekomunikacijskim sustavima gdje su se binarni podaci trebali prenositi preko kanala dizajniranih za tekst.
Formalna specifikacija Base64 prvi put je objavljena 1987. godine kao dio RFC 989, koji je definirao Privatno poboljšano poštansko (PEM). Ovo je kasnije ažurirano u RFC 1421 (1993) i RFC 2045 (1996, kao dio MIME).
Termin "Base64" dolazi od činjenice da kodiranje koristi 64 različita ASCII znaka za predstavljanje binarnih podataka. Ovaj izbor od 64 znaka bio je namjeran, jer je 64 potencija 2 (2^6), što čini konverziju između binarnog i Base64 učinkovitom.
S vremenom su se pojavile nekoliko varijanti Base64:
- Standardni Base64: Kako je definirano u RFC 4648, koristeći A-Z, a-z, 0-9, +, / i = za padding
- URL-sigurno Base64: Koristi - i _ umjesto + i / kako bi se izbjegli problemi s URL kodiranjem
- Sigurno za nazive datoteka Base64: Slično URL-sigurnom, dizajnirano za korištenje u nazivima datoteka
- Modificirani Base64 za IMAP: Koristi se u IMAP protokolu s različitim skupom posebnih znakova
Unatoč tome što je staro više od tri desetljeća, Base64 ostaje temeljni alat u modernom računalstvu, posebno s porastom web aplikacija i API-ja koji se snažno oslanjaju na formate podataka temeljen na tekstu kao što je JSON.
Primjeri Koda
Evo primjera Base64 kodiranja i dekodiranja u raznim programskim jezicima:
1// JavaScript Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
11 }
12}
13
14// Primjer korištenja
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Kodirano:", encoded); // SGVsbG8sIFdvcmxkIQ==
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Dekodirano:", decoded); // Hello, World!
22} catch (error) {
23 console.error(error.message);
24}
251# Python Base64 Kodiranje/Dekodiranje
2import base64
3
4def encode_to_base64(text):
5 # Pretvori string u bajtove i zatim kodiraj
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 # Pretvori base64 string u bajtove i zatim dekodiraj
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"Nevažeći Base64 string: {e}")
18
19# Primjer korištenja
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Kodirano: {encoded}") # SGVsbG8sIFdvcmxkIQ==
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Dekodirano: {decoded}") # Hello, World!
27except ValueError as e:
28 print(e)
291// Java Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string: " + 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("Kodirano: " + encoded); // SGVsbG8sIFdvcmxkIQ==
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Dekodirano: " + decoded); // Hello, World!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// PHP Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
11 }
12 return $decoded;
13}
14
15// Primjer korištenja
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Kodirano: " . $encoded . "\n"; // SGVsbG8sIFdvcmxkIQ==
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Dekodirano: " . $decoded . "\n"; // Hello, World!
23} catch (Exception $e) {
24 echo "Greška: " . $e->getMessage() . "\n";
25}
26?>
271// C# Base64 Kodiranje/Dekodiranje
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("Nevažeći Base64 string");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Hello, World!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Kodirano: {encoded}"); // SGVsbG8sIFdvcmxkIQ==
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Dekodirano: {decoded}"); // Hello, World!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Greška: {e.Message}");
40 }
41 }
42}
431# Ruby Base64 Kodiranje/Dekodiranje
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 "Nevažeći Base64 string: #{e.message}"
13 end
14end
15
16# Primjer korištenja
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Kodirano: #{encoded}" # SGVsbG8sIFdvcmxkIQ==
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Dekodirano: #{decoded}" # Hello, World!
24rescue StandardError => e
25 puts "Greška: #{e.message}"
26end
271// Go Base64 Kodiranje/Dekodiranje
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("nevažeći Base64 string: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Hello, World!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Kodirano:", encoded) // SGVsbG8sIFdvcmxkIQ==
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Greška:", err)
29 } else {
30 fmt.Println("Dekodirano:", decoded) // Hello, World!
31 }
32}
331// Swift Base64 Kodiranje/Dekodiranje
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// Primjer korištenja
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21 print("Kodirano: \(encoded)") // SGVsbG8sIFdvcmxkIQ==
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Dekodirano: \(decoded)") // Hello, World!
25 } else {
26 print("Greška: Ne može se dekodirati Base64 string")
27 }
28} else {
29 print("Greška: Ne može se kodirati tekst")
30}
311' Excel VBA Base64 Kodiranje/Dekodiranje
2' Napomena: Ovo zahtijeva referencu na 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 = "Greška: Nevažeći Base64 string"
39End Function
40
41' Korištenje u radnom listu:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# R Base64 Kodiranje/Dekodiranje
2# Zahtijeva paket 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Pretvori tekst u sirove bajtove, zatim kodiraj
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 # Pretvori base64 string u sirove bajtove, zatim dekodiraj
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("Nevažeći Base64 string:", e$message))
21 })
22}
23
24# Primjer korištenja
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Kodirano:", encoded, "\n") # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Dekodirano:", decoded, "\n") # Hello, World!
32}, error = function(e) {
33 cat("Greška:", e$message, "\n")
34})
351% MATLAB Base64 Kodiranje/Dekodiranje
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Kodiraj
6 encoded = encode_to_base64(originalText);
7 fprintf('Kodirano: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Dekodiraj
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Dekodirano: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Greška: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Pretvori tekst u uint8 niz i kodiraj
20 bytes = uint8(text);
21 encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25 try
26 % Dekodiraj base64 string u uint8 niz
27 bytes = base64decode(base64String);
28 decoded = char(bytes);
29 catch
30 error('Nevažeći Base64 string');
31 end
32end
331// C Base64 Kodiranje/Dekodiranje koristeći 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; // Nevažeći Base64 ulaz
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("Kodirano: %s\n", encoded); // SGVsbG8sIFdvcmxkIQ==
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Dekodirano: %s\n", decoded); // Hello, World!
65 free(decoded);
66 } else {
67 printf("Greška: Nevažeći Base64 string\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Rust Base64 Kodiranje/Dekodiranje
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!("Nevažeća UTF-8 sekvenca: {}", e))
15 }
16 },
17 Err(e) => Err(format!("Nevažeći Base64 string: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Hello, World!";
23 let encoded = encode_to_base64(original_text);
24 println!("Kodirano: {}", encoded); // SGVsbG8sIFdvcmxkIQ==
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Dekodirano: {}", decoded), // Hello, World!
28 Err(e) => println!("Greška: {}", e)
29 }
30}
31Rubne Slučajeve i Razmatranja
Kada radite s Base64 kodiranjem i dekodiranjem, budite svjesni ovih važnih razmatranja:
-
Unicode i Ne-ASCII Znakovi: Kada kodirate tekst s ne-ASCII znakovima, osigurajte pravilno kodiranje znakova (obično UTF-8) prije Base64 kodiranja.
-
Padding: Standardni Base64 koristi padding s "=" znakovima kako bi osigurao da duljina izlaza bude višekratnik 4. Neki implementacije dopuštaju izostavljanje paddinga, što može uzrokovati probleme s kompatibilnošću.
-
Prelomi Redova: Tradicionalne Base64 implementacije umetnu prelome redova (obično svakih 76 znakova) radi čitljivosti, ali moderne aplikacije često izostavljaju ove.
-
URL-sigurno Base64: Standardni Base64 koristi "+" i "/" znakove koji imaju posebna značenja u URL-ovima. Za kontekste URL-a, koristite URL-sigurno Base64 koje zamjenjuje ove s "-" i "_".
-
Bijeg: Pri dekodiranju, neke implementacije su tolerantne i ignoriraju bijeg, dok druge zahtijevaju točan ulaz.
-
Povećanje Veličine: Base64 kodiranje povećava veličinu podataka za otprilike 33% (4 izlazna bajta za svaki 3 ulazna bajta).
-
Učinkovitost: Base64 kodiranje/dekodiranje može biti računalno intenzivno za vrlo velike podatke. Razmislite o pristupima strujanja za velike datoteke.
Reference
Povratne informacije
Kliknite na obavijest o povratnim informacijama da biste započeli davati povratne informacije o ovom alatu
Povezani alati
Otkrijte više alata koji bi mogli biti korisni za vaš radni proces