Base64 डिकोड

संबंधित सुझाव

Base64 डिकोड क्या है?

उपयोग के मामले

• API द्वारा लौटाए गए Base64 fields को डिकोड करके मूल content देखना
• लॉग में मौजूद Base64-encoded data को बहाल करना
• कॉन्फ़िग फाइल के Base64 values को रिकवर करना
• Base64 decode errors जैसे missing padding या invalid characters की जांच करना
• JWT token के header और payload को डिकोड करके user info देखना
• HTTP Basic Authentication credentials को डिकोड करके username और password देखना
• Data URI Scheme से image या resource data बहाल करना

उपयोग कैसे करें

1. जिस Base64 string को डिकोड करना है उसे पेस्ट करें
2. कैरेक्टरसेट चुनें (UTF-8/ASCII/ISO-8859-1)
3. टूल अपने आप Base64 डिकोड करके परिणाम दिखाएगा
4. डिबगिंग या दस्तावेज़ीकरण के लिए decoded result कॉपी करें

विशेषताएं

• रियल-टाइम दो-तरफ़ा कन्वर्ज़न: इनपुट देते ही 300ms debounce के साथ तुरंत डिकोड
• मल्टी-कैरेक्टरसेट सपोर्ट: UTF-8, ASCII और ISO-8859-1, हिंदी/अंग्रेज़ी/मल्टीलिंगुअल उपयोग के लिए
• URL-safe Base64 संगतता: `-` और `_` को अपने आप संभालता है और no-padding format को सपोर्ट करता है
• Invalid character detection: डिकोड विफल होने पर विशिष्ट error position दिखाता है
• एक-क्लिक कॉपी और डाउनलोड: decoded result को clipboard में कॉपी करें या `.txt` फाइल के रूप में डाउनलोड करें
• Automatic Padding handling: `=` padding को अपने आप जोड़ता या हटाता है
• MIME variant support: हर 76 कैरेक्टर पर line break वाले MIME Base64 को पहचानकर संभालता है

कोड उदाहरण

// Standard Base64 decode (plain English / Latin-1)
function b64Decode(str) {
  try {
    return atob(str);
  } catch (e) {
    return 'Decode failed: ' + e.message;
  }
}

console.log(b64Decode('SGVsbG8gV29ybGQ=')); // "Hello World"

// UTF-8 decode (recommended)
function b64DecodeUtf8(str) {
  const binary = atob(str);
  const bytes = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i++) {
    bytes[i] = binary.charCodeAt(i);
  }
  return new TextDecoder('utf-8').decode(bytes);
}

console.log(b64DecodeUtf8('5LiW55WM')); // UTF-8 text

import base64

# Standard decode
encoded = 'SGVsbG8g5LiW55WM'
decoded = base64.b64decode(encoded).decode('utf-8')
print(decoded)

# URL-Safe decode
url_encoded = 'SGVsbG8g5LiW55WM'
decoded = base64.urlsafe_b64decode(url_encoded + '=' * (4 - len(url_encoded) % 4))
print(decoded.decode('utf-8'))

# MIME decode (after removing line breaks)
mime_encoded = 'SGVs\nbG8g\nV29y\nbGQ='
decoded = base64.b64decode(mime_encoded.replace('\n', '')).decode('utf-8')
print(decoded)

# Ignore invalid characters automatically
import re
cleaned = re.sub(r'[^A-Za-z0-9+/=]', '', encoded)
decoded = base64.b64decode(cleaned).decode('utf-8')
print(decoded)

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64DecodeExample {
    public static void main(String[] args) {
        String encoded = "SGVsbG8g5LiW55WM";

        // Standard decode
        byte[] decoded = Base64.getDecoder().decode(encoded);
        System.out.println(new String(decoded, StandardCharsets.UTF_8));

        // URL-Safe decode
        byte[] urlDecoded = Base64.getUrlDecoder().decode(encoded);
        System.out.println(new String(urlDecoded, StandardCharsets.UTF_8));

        // MIME decode (handles line breaks automatically)
        String mime = "SGVs\nbG8g\nV29y\nbGQ=";
        byte[] mimeDecoded = Base64.getMimeDecoder().decode(mime);
        System.out.println(new String(mimeDecoded, StandardCharsets.UTF_8));

        // Error handling
        try {
            Base64.getDecoder().decode("invalid@base64");
        } catch (IllegalArgumentException e) {
            System.err.println("Decode failed: " + e.getMessage());
        }
    }
}

सामान्य प्रश्न

शब्दकोश

Base64

64 printable ASCII कैरेक्टर पर आधारित binary-to-text एन्कोडिंग तरीका, जिसे RFC 4648 में परिभाषित किया गया है। हर 3 bytes को 4 characters में बदला जाता है, इसलिए आकार लगभग 33% बढ़ जाता है।

atob()

ब्राउज़र का native Base64 decode फ़ंक्शन (ASCII to Binary)। यह केवल Latin-1 सपोर्ट करता है; UTF-8 टेक्स्ट के लिए TextDecoder की ज़रूरत पड़ती है।

Padding

Base64 एन्कोडिंग के अंत में `=` जोड़कर लंबाई को 4 का गुणक बनाया जाता है। डिकोड के समय padding आम तौर पर अपने आप संभाल लिया जाता है। URL-safe variant में padding अक्सर छोड़ा जाता है।

URL-Safe Base64

RFC 4648 §5 में परिभाषित URL-safe variant, जिसमें `+` और `/` की जगह `-` और `_` होते हैं ताकि URL encoding समस्या न हो। यह JWT और OAuth PKCE में आम है।

MIME Base64

RFC 2045 के अनुसार हर 76 कैरेक्टर पर CRLF line break डालने वाला Base64 variant, जो मुख्य रूप से ईमेल अटैचमेंट ट्रांसफर में उपयोग होता है।

UTF-8

Unicode का variable-length encoding format। हिंदी, चीनी जैसी multi-byte languages को सही बहाल करने के लिए Base64 डिकोड में UTF-8 चुनना ज़रूरी है।

InvalidCharacterError

जब `atob()` को spaces, newlines या गैर-Base64 कैरेक्टर मिलते हैं तो ब्राउज़र यह error देता है। इसका मतलब input में invalid characters हैं।

Latin-1 (ISO-8859-1)

Single-byte character set जो मुख्यतः पश्चिमी यूरोपीय भाषाओं को कवर करता है। ब्राउज़र का `atob` और `btoa` इसी तक सीमित है और सीधे UTF-8 टेक्स्ट नहीं संभालता।

Base64 के तीन variants की तुलना

डिकोड से पहले input Base64 variant पहचानें और सही mode चुनें ताकि errors या garbled output से बचा जा सके।

Base64 decode की 5 सामान्य errors

डिकोड error आने पर नीचे दी गई तालिका से कारण जल्दी पहचानें।

Authoritative References

• IETFRFC 4648 - The Base16, Base32, and Base64 Data Encodings
• IETFRFC 2045 - MIME Part One: Format of Internet Message Bodies
• IETFRFC 7519 - JSON Web Token (JWT)
• MDNMDN - Window atob()
• MDNMDN - Window btoa()
• MDNMDN - TextDecoder
• WikipediaWikipedia - Base64