การจัดรูปแบบ Base64

Internationsty Base64

0 อักขระ

Internationsty Base64

0 อักขระ

ผลการฟอร์แมต

0 บรรทัด · 76 อักขระต่อบรรทัด

จัดรูปแบบสตริง Base64 ออนไลน์ รองรับการแบ่งบรรทัดตามความกว้างตัวอักษรที่กำหนดเอง (64/76/80/100 ตัวอักษร) และการเยื้อง (0/2/4 ช่องว่าง) เหมาะสำหรับการอ่านสตริงยาว การเปรียบเทียบภาพหน้าจอ และการจัดวางเอกสาร แก้ไขเฉพาะรูปแบบการแสดงผล ไม่เปลี่ยนแปลงข้อมูลการเข้ารหัส Base64 ดั้งเดิม

คำแนะนำที่เกี่ยวข้อง

สถิติความยาว Base64

แปลงเสียงเป็น Base64

ตัวเข้ารหัสและถอดรหัส Base32

Base64 เป็นไฟล์

แปลงรูปภาพเป็น Base64

ตัวแยกวิเคราะห์ URL

การจัดรูปแบบ Base64 คืออะไร?

การจัดรูปแบบ Base64 คือการแบ่งสตริง Base64 ยาวออกเป็นหลายบรรทัดตามความกว้างตัวอักษรที่กำหนด (เช่น 64/76/80/100) ในระดับการแสดงผล และรองรับการเยื้อง 0/2/4 ช่องว่าง ผลลัพธ์ที่จัดรูปแบบแล้วจะอ่านง่ายขึ้นในเชิงภาพ เหมาะสำหรับการถ่ายภาพหน้าจอ การพิมพ์ และการจัดวางเอกสาร แต่**ไม่เปลี่ยนแปลงเนื้อหาไบต์ดั้งเดิม**——เมื่อลบการขึ้นบรรทัดและการเยื้องทั้งหมด จะสามารถกู้คืนเป็น Base64 บรรทัดเดียวดั้งเดิมได้

**เหตุใดจึงต้องจัดรูปแบบ?** Base64 มาตรฐาน RFC 4648 ไม่ได้บังคับให้ขึ้นบรรทัดใหม่ แต่ในการใช้งานจริง: ①สตริง Base64 ยาวมักล้นทำให้เกิดการเลื่อนแนวนอนในระบบตั๋วงาน เครื่องมือแชท เอกสาร Markdown; ②โปรโตคอล MIME (RFC 2045) กำหนดให้ขึ้นบรรทัดใหม่ทุก 76 ตัวอักษร (ใช้สำหรับไฟล์แนบอีเมล); ③การตรวจสอบโค้ดจะค้นหาตัวอักษรผิดปกติได้ง่ายขึ้นเมื่อแสดงหลายบรรทัด; ④การจัดวางภาพหน้าจอในเอกสารต้องการการจัดตำแหน่งที่สวยงาม

**สถานการณ์การใช้งานทั่วไป:** ①การจัดวางเอกสารทางเทคนิค: ฝัง Base64 ยาวใน Markdown / Confluence / Notion; ②การเปรียบเทียบภาพหน้าจอ: อำนวยความสะดวกให้ทีมดูสตริง Base64 ทั้งหมดในภาพหน้าจอรายงาน PR / Bug; ③การตรวจสอบด้วยตนเอง: ค้นหาตัวอักษรผิดกฎหมาย (เช่น การปนของขึ้นบรรทัด ช่องว่าง) อย่างรวดเร็วในการตรวจสอบโค้ด; ④ไฟล์แนบอีเมล: ขึ้นบรรทัดใหม่ตามมาตรฐาน MIME 76 ตัวอักษรเพื่อความสะดวกในการส่ง SMTP; ⑤การแสดงผลโลโก้บนหน้าจอขนาดใหญ่: แสดงผลหลายบรรทัดบนหน้าจอตรวจสอบเพื่อความสะดวกในการดู

**ความแตกต่างจาก MIME Base64:** MIME Base64 (RFC 2045) ขึ้นบรรทัดใหม่ทุก 76 ตัวอักษรอย่างตายตัว ซึ่งเป็นข้อกำหนดบังคับระดับโปรโตคอล การจัดรูปแบบของเครื่องมือนี้มีความยืดหยุ่นมากขึ้น รองรับความกว้างหลายแบบ 64/76/80/100 ตัวอักษร + การเยื้อง 0/2/4 ช่องว่าง เหมาะสำหรับสถานการณ์เอกสารต่างๆ สามารถจำลองการขึ้นบรรทัด MIME ได้โดยเลือกความกว้าง 76 ตัวอักษร

**ความปลอดภัยของการจัดรูปแบบ:** เครื่องมือแทรกอักขระขึ้นบรรทัดและช่องว่างเยื้องในระดับการแสดงผลเท่านั้น **ไม่แก้ไขเนื้อหาไบต์ของ Base64 ดั้งเดิมอย่างแน่นอน** เมื่อลบอักขระว่างทั้งหมดจากผลลัพธ์ที่จัดรูปแบบแล้ว จะสามารถกู้คืนเป็นสตริง Base64 ดั้งเดิมที่เหมือนกันทุกประการ ตัวถอดรหัส Base64 ส่วนใหญ่จะละเว้นอักขระว่างโดยอัตโนมัติ ดังนั้นผลลัพธ์ที่จัดรูปแบบสามารถนำไปถอดรหัสได้โดยตรง

กรณีการใช้งาน

แบ่งสตริง Base64 ที่ยาวมากเป็นบรรทัดตามความกว้างที่กำหนดเพื่อความสะดวกในการอ่านและถ่ายภาพหน้าจอ
จัดรูปแบบ Base64 สำหรับเอกสารทางเทคนิค บันทึกตั๋วงาน หรือการแสดงผลในอีเมล
เพิ่มประสิทธิภาพการจัดวาง Base64 เมื่อพิมพ์หรือเก็บถาวร
ปรับโครงสร้าง Base64 ร่วมกับเครื่องมือแยกและรวม
ขึ้นบรรทัด Base64 ตามมาตรฐาน MIME (76 ตัวอักษร) สำหรับไฟล์แนบอีเมล
แสดง Base64 หลายบรรทัดเมื่อตรวจสอบโค้ดเพื่อค้นหาตัวอักษรผิดปกติได้ง่าย
เยื้อง 4 ช่องว่างเมื่อฝัง Base64 ใน Markdown เพื่อรักษารูปแบบโค้ด
การแสดงผลโลโก้บนหน้าจอขนาดใหญ่: แสดงเพย์โหลด Base64 ยาวหลายบรรทัดในระบบตรวจสอบ

วิธีการใช้งาน

วางสตริง Base64 ที่ต้องการจัดรูปแบบ (อาจมีหรือไม่มีขึ้นบรรทัดก็ได้)
เลือกความกว้างตัวอักษรต่อบรรทัด: 64 / 76 / 80 / 100
เลือกการเยื้อง: 0 / 2 / 4 ช่องว่าง
เครื่องมือจะจัดรูปแบบและแสดงผลตามความกว้างและการเยื้องที่กำหนดแบบเรียลไทม์
คัดลอกผลลัพธ์ที่จัดรูปแบบเพื่อใช้ในเอกสาร หรือคลิกกู้คืนเพื่อลบการขึ้นบรรทัด

คุณสมบัติ

ความกว้างตัวอักษรที่กำหนดเอง: รองรับ 64 / 76 / 80 / 100 ตัวอักษรต่อบรรทัด ยืดหยุ่นเหมาะกับความต้องการจัดวางต่างๆ
การเยื้องที่กำหนดค่าได้: รองรับการเยื้อง 0 / 2 / 4 ช่องว่าง สะดวกสำหรับการจัดตำแหน่งในบล็อกโค้ดหรือ Markdown
เพิ่มประสิทธิภาพการแสดงผลอย่างเดียว: ปรับเฉพาะวิธีการแสดงผล ไม่เปลี่ยนแปลงข้อมูลการเข้ารหัส Base64 ดั้งเดิม
จัดรูปแบบแบบเรียลไทม์: ดีเลย์ 200ms จัดรูปแบบทันทีเมื่อป้อน ไม่มีความล่าช้า
กู้คืนได้ด้วยคลิกเดียว: ลบการขึ้นบรรทัดและการเยื้องทั้งหมด กู้คืนเป็น Base64 บรรทัดเดียว
สถิติจำนวนตัวอักษรและจำนวนบรรทัด: แสดงจำนวนตัวอักษรที่ป้อนและจำนวนบรรทัดเอาต์พุตแบบเรียลไทม์
คัดลอกด้วยคลิกเดียว: สามารถคัดลอกผลลัพธ์ที่จัดรูปแบบไปยังคลิปบอร์ดโดยตรง สำหรับใช้ในเอกสารหรือบันทึกตั๋วงาน
ประมวลผลในเบราว์เซอร์ไม่อัปโหลด: การจัดรูปแบบทั้งหมดเสร็จสิ้นในเบราว์เซอร์ ไม่ผ่านเซิร์ฟเวอร์ใดๆ

ตัวอย่างโค้ด

JavaScript: การนำไปใช้จัดรูปแบบ Base64 ด้วยตนเอง (ทำความเข้าใจหลักการ)

javascript

ทำความเข้าใจตรรกะเบื้องหลังการจัดรูปแบบ Base64——แบ่งตามความกว้างตัวอักษรและแทรกอักขระขึ้นบรรทัด

// ฟังก์ชันจัดรูปแบบ Base64 (สอดคล้องกับตรรกะของเครื่องมือนี้)
function formatBase64(input, lineLength = 76, indent = 0) {
  // 1. ลบอักขระว่างทั้งหมด
  const clean = input.replace(/\s/g, '');
  if (!clean) return '';

  // 2. แบ่งตามความกว้างที่กำหนด
  const lines = [];
  for (let i = 0; i < clean.length; i += lineLength) {
    const line = clean.slice(i, i + lineLength);
    lines.push(' '.repeat(indent) + line);
  }

  // 3. เชื่อมด้วยอักขระขึ้นบรรทัด
  return lines.join('\n');
}

// ตัวอย่างการใช้งาน
const b64 = 'a'.repeat(200);
console.log(formatBase64(b64, 76, 0));
// เอาต์พุต: Base64 ที่มี 76 ตัวอักษรต่อบรรทัด

// ยกเลิกรูปแบบ (สำหรับถอดรหัสหรือส่ง)
function unformatBase64(input) {
  return input.replace(/\s/g, '');
}

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

Python: จัดรูปแบบ Base64 + ขึ้นบรรทัด MIME

python

การนำไปใช้ Python สำหรับขึ้นบรรทัดทุก 76 ตัวอักษร (มาตรฐาน MIME) และสามารถกำหนดการเยื้องได้

import textwrap

def format_base64(b64_str: str, width: int = 76, indent: int = 0) -> str:
    """จัดรูปแบบสตริง Base64 เป็นหลายบรรทัด"""
    # ลบช่องว่างทั้งหมด
    clean = ''.join(b64_str.split())
    if not clean:
        return ''

    # ใช้ textwrap แบ่งตามความกว้าง
    lines = textwrap.wrap(clean, width=width)

    # เพิ่มการเยื้อง
    if indent > 0:
        lines = [' ' * indent + line for line in lines]

    return '\n'.join(lines)


# ตัวอย่างการใช้งาน
b64 = 'aGVsbG8gd29ybGQ=' * 10
print(format_base64(b64, 76, 0))

# จำลอง MIME Base64 (RFC 2045)
mime_format = format_base64(b64, 76)
print(f'จำนวนบรรทัด MIME Base64: {len(mime_format.splitlines())}')

# กู้คืนเป็นบรรทัดเดียว
single_line = b64.replace('\n', '').replace(' ', '')
print(f'ความยาวบรรทัดเดียว: {len(single_line)}')

บรรทัดคำสั่ง: เครื่องมือ fold + ขึ้นบรรทัด MIME Base64

bash

เครื่องมือ fold ที่มาพร้อมกับระบบ Linux/macOS สามารถจัดรูปแบบ Base64 ได้อย่างรวดเร็วในบรรทัดคำสั่ง

# 1. ป้อน Base64 → ขึ้นบรรทัดทุก 76 ตัวอักษร (มาตรฐาน MIME)
echo "aGVsbG8gd29ybGQ=" | base64 | base64 | fold -w 76

# 2. จัดรูปแบบไฟล์ Base64 ยาว → ส่งออกไปยังไฟล์ใหม่
fold -w 76 encoded.txt > formatted.txt

# 3. ขึ้นบรรทัดทุก 64 ตัวอักษร (การแสดงผลที่กระชับ)
fold -w 64 encoded.txt > compact.txt

# 4. ลบการขึ้นบรรทัดทั้งหมดในเวลาเดียวกัน (ยกเลิกรูปแบบ)
tr -d '\n' < formatted.txt > single-line.txt

# 5. ตรวจสอบ: ความยาว Base64 + จำนวนบรรทัด
wc -c encoded.txt | awk '{print "จำนวนตัวอักษร:", $1}'
wc -l formatted.txt | awk '{print "จำนวนบรรทัด:", $1}'

# 6. รวมกับ openssl เพื่อเข้ารหัส base64 + จัดรูปแบบอย่างสมบูรณ์
echo "Hello ชาวโลก" | openssl base64 -A | fold -w 76 > hello.b64.txt
cat hello.b64.txt

คำถามที่พบบ่อย

การจัดรูปแบบจะเปลี่ยนเนื้อหาจริงของ Base64 หรือไม่?

ไม่เปลี่ยน การจัดรูปแบบแทรกเฉพาะอักขระขึ้นบรรทัดและช่องว่างเยื้องในระดับการแสดงผล ไม่เปลี่ยนแปลงการเข้ารหัสเอง เมื่อลบอักขระว่างทั้งหมดจากเนื้อหาที่จัดรูปแบบแล้ว จะสามารถกู้คืนเป็น Base64 บรรทัดเดียวดั้งเดิมได้ ตัวถอดรหัส Base64 ทั้งหมด (atob ดั้งเดิมของเบราว์เซอร์ / Node.js Buffer / Python base64) จะละเว้นอักขระว่างโดยอัตโนมัติ ดังนั้นผลลัพธ์ที่จัดรูปแบบสามารถนำไปถอดรหัสได้โดยตรง

ความแตกต่างระหว่างการจัดรูปแบบ Base64 และ MIME Base64 คืออะไร?

MIME Base64 ขึ้นบรรทัดใหม่ตามความกว้าง 76 ตัวอักษรของ RFC 2045 อย่างเข้มงวด ซึ่งเป็นมาตรฐานการส่งไฟล์แนบอีเมล การจัดรูปแบบของเครื่องมือนี้มีความยืดหยุ่นมากขึ้น อนุญาตให้กำหนดความกว้าง 64/76/80/100 ตัวอักษรเอง + การเยื้อง 0/2/4 ช่องว่าง เหมาะกับความต้องการแสดงผลต่างๆ เช่น เอกสาร ภาพหน้าจอ มากขึ้น เลือกความกว้าง 76 ตัวอักษรเพื่อจำลองการขึ้นบรรทัด MIME

เหมาะสำหรับการดูบันทึกและบันทึกตั๋วงานหรือไม่?

เหมาะอย่างยิ่ง สตริง Base64 ยาวมักล้นทำให้เกิดการเลื่อนแนวนอนในระบบตั๋วงาน (Jira / Zendesk) เครื่องมือแชท (Slack / Teams) หรือเอกสาร Markdown หลังจากจัดรูปแบบแล้ว การแสดงผลหลายบรรทัดจะชัดเจนอ่านง่าย สามารถวางลงในไฟล์แนบตั๋วงานหรือหน้าต่างแชทโดยตรง

หลังจากจัดรูปแบบแล้วสามารถนำไปถอดรหัสโดยตรงได้หรือไม่?

ได้ ตัวถอดรหัส Base64 หลักทั้งหมดจะละเว้นการขึ้นบรรทัดและช่องว่างโดยอัตโนมัติ หากพบปัญหา (เช่น OpenSSL รุ่นเก่า) สามารถคลิกปุ่ม「กู้คืน」เพื่อลบการขึ้นบรรทัดก่อนถอดรหัส

เหตุใดจึงมีความกว้างตัวอักษรหลายแบบ 64 / 76 / 80 / 100?

64 ตัวอักษรเหมาะสำหรับเอกสารที่กระชับ (เช่น เทอร์มินัล CLI ตาราง Markdown); 76 ตัวอักษรเป็นมาตรฐานอีเมล MIME; 80 ตัวอักษรเป็นความกว้างเทอร์มินัลแบบดั้งเดิม; 100 ตัวอักษรเหมาะสำหรับตัวแก้ไขหน้าจอกว้างและเอกสารสมัยใหม่ แต่ละความกว้างมีสถานการณ์การใช้งานที่เหมาะสมที่สุด

การเยื้องมีประโยชน์อย่างไร?

การเยื้อง (0/2/4 ช่องว่าง) ช่วยให้ Base64 จัดตำแหน่งได้สอดคล้องกันในบล็อกโค้ดหรือ Markdown: 0 ช่องว่างเหมาะสำหรับข้อความธรรมดา, 2 ช่องว่างเหมาะสำหรับรูปแบบโค้ด JS/Python, 4 ช่องว่างเหมาะสำหรับบล็อกโค้ดที่ซ้อนกันใน Markdown

การจัดรูปแบบจะเพิ่มจำนวนตัวอักษรของ Base64 หรือไม่?

จะเพิ่มขึ้นประมาณ 1-3% (อักขระขึ้นบรรทัด + ช่องว่างเยื้อง) แต่ไม่ส่งผลต่อผลลัพธ์การถอดรหัส หากการส่งมีความไวต่อขนาด (เช่น พารามิเตอร์ URL) แนะนำให้ใช้ฟังก์ชัน「กู้คืน」เพื่อกลับเป็นบรรทัดเดียวก่อน

รองรับ UTF-8 / ภาษาไทยหรือไม่?

เครื่องมือนี้ไม่ได้ประมวลผลชุดตัวอักษรโดยตรง——จัดรูปแบบเฉพาะสตริง Base64 เองเท่านั้น หาก Base64 มีภาษาไทย (เช่น Base64 ที่เข้ารหัสหลังจากเข้ารหัส UTF-8) การจัดรูปแบบจะไม่ส่งผลต่อความถูกต้องของการเข้ารหัส

เหมาะสำหรับการจัดรูปแบบไฟล์ขนาดใหญ่หรือไม่?

รองรับ เครื่องมือจัดรูปแบบแบบเรียลไทม์ เบราว์เซอร์สามารถจัดการสตริง Base64 ขนาดไม่เกิน 1MB ได้อย่างไม่มีปัญหา เกิน 10MB อาจทำให้อินเทอร์เฟซค้าง แนะนำให้จัดรูปแบบเป็นส่วนๆ

หลังจากจัดรูปแบบแล้วขนาดใหญ่ขึ้น สามารถบีบอัดได้หรือไม่?

สิ่งที่เพิ่มขึ้นจากการจัดรูปแบบเป็นเพียงการขึ้นบรรทัดและการเยื้อง ซึ่งเป็นมิตรกับอัลกอริทึมการบีบอัด สามารถใช้ gzip / Brotli บีบอัด หรือใช้เครื่องมือ Base64 Stats เพื่อดูค่าที่เพิ่มขึ้นโดยละเอียด

การแก้ไขปัญหา

ตัวอักษร Base64 บางตัวหายไปหลังจากจัดรูปแบบ

อาจเป็นเพราะ Base64 ต้นทางมีตัวอักษรผิดกฎหมาย (เช่น อักขระขึ้นบรรทัดไม่ได้รับการประมวลผลอย่างถูกต้อง) ใช้เครื่องมือ Base64 Clean ทำความสะอาดก่อนแล้วจึงจัดรูปแบบ

ผลลัพธ์ที่จัดรูปแบบไม่สอดคล้องกับไบต์ดั้งเดิม

สิ่งนี้เป็นไปไม่ได้——การจัดรูปแบบแทรกเฉพาะอักขระว่าง ไม่แก้ไขเนื้อหาไบต์ หากพบว่าไม่สอดคล้อง แสดงว่า Base64 ต้นทางได้รับการประมวลผลอย่างผิดพลาดแล้ว (เช่น การจัดรูปแบบซ้ำทำให้แทรกช่องว่างซ้ำ)

อินเทอร์เฟซค้างหลังจากจัดรูปแบบสตริงยาว

สตริง Base64 ที่เกิน 10MB อาจทำให้เบราว์เซอร์ค้าง แนะนำ: ①ประมวลผลเป็นส่วนๆ; ②ใช้ base64-clean ลบช่องว่างส่วนเกินก่อน; ③ลดความกว้าง (เช่น 64 ตัวอักษร) เพื่อลดภาระการแสดงผลแต่ละบรรทัด

อภิธานศัพท์

การจัดรูปแบบ Base64: การแบ่งสตริง Base64 ออกเป็นหลายบรรทัดตามความกว้างที่กำหนดในระดับการแสดงผล ส่งผลต่อการนำเสนอภาพเท่านั้น ไม่เปลี่ยนแปลงการเข้ารหัสเอง
MIME Base64: รูปแบบ Base64 ที่ขึ้นบรรทัดใหม่ทุก 76 ตัวอักษรตามที่กำหนดใน RFC 2045 ใช้สำหรับการส่งไฟล์แนบอีเมลเป็นหลัก
ความกว้างตัวอักษร (line length): จำนวนตัวอักษร Base64 ที่แสดงในแต่ละบรรทัด ค่าที่ใช้กันทั่วไป: 64 (กระชับ), 76 (มาตรฐาน MIME), 80 (การพิมพ์มาตรฐาน), 100 (หน้าจอกว้าง)
การเยื้อง (indent): จำนวนช่องว่างที่จุดเริ่มต้นของแต่ละบรรทัด ค่าทั่วไป: 0 (ไม่เยื้อง), 2 (รูปแบบโค้ด), 4 (บล็อกโค้ด Markdown)
อักขระว่าง (whitespace): ช่องว่าง แท็บ อักขระขึ้นบรรทัด ฯลฯ ที่อาจมีอยู่ในสตริง Base64 การจัดรูปแบบจะลบอักขระเหล่านี้ก่อน แล้วจึงแทรกใหม่ตามความกว้างที่กำหนด
การยกเลิกรูปแบบ (unformat): การกู้คืน Base64 ที่จัดรูปแบบแล้ว (หลายบรรทัด + เยื้อง) กลับเป็นรูปแบบบรรทัดเดียวไม่มีช่องว่าง เพื่อใช้สำหรับถอดรหัสหรือส่ง

ตารางเปรียบเทียบความกว้างตัวอักษร 4 แบบ

ความกว้างตัวอักษรที่แตกต่างกันเหมาะกับสถานการณ์การแสดงผลที่แตกต่างกัน สามารถเลือกตามสภาพแวดล้อมเป้าหมาย

ความกว้างตัวอักษร	สถานการณ์ทั่วไป	มาตรฐานที่เกี่ยวข้อง	ตัวอย่าง
`64 ตัวอักษร`	เทอร์มินัล CLI, ตาราง Markdown	การแสดงผลที่กระชับ	หน้าจอเล็ก / ความหนาแน่นสูง
`76 ตัวอักษร`	การส่งไฟล์แนบอีเมล	RFC 2045 MIME	อีเมล / SMTP
`80 ตัวอักษร`	การพิมพ์เทอร์มินัลแบบดั้งเดิม	เทอร์มินัล Unix ดั้งเดิม	การพิมพ์เอกสาร
`100 ตัวอักษร`	ตัวแก้ไขสมัยใหม่ / หน้าจอกว้าง	ข้อกำหนด UI สมัยใหม่	IDE / เอกสาร

ตารางเปรียบเทียบรูปแบบการเยื้อง 3 แบบ

รูปแบบการเยื้องที่แตกต่างกันสอดคล้องกับมาตรฐานโค้ดที่แตกต่างกัน เลือกตามความคุ้นเคยของทีม/โครงการ

การเยื้อง	รูปแบบโค้ด	ตัวอย่าง (บรรทัดแรกของ Base64)
`0 ช่องว่าง`	ไม่เยื้อง (ข้อความธรรมดา)	QUJD...
`2 ช่องว่าง`	มาตรฐาน JS / Python	QUJD...
`4 ช่องว่าง`	การซ้อน Markdown / มาตรฐาน Java	QUJD...