เครื่องมือตรวจสอบความถูกต้อง UUID

ตรวจสอบความถูกต้องของ UUID รายการเดียวหรือแบบกลุ่มตามมาตรฐาน RFC 9562 บนเบราว์เซอร์ เช็คไวยากรณ์ บิต Variant และแยกแยะเวอร์ชัน v1-v8, Nil หรือ Max.

ไม่ต้องอัปโหลดไม่ต้องลงทะเบียนผลลัพธ์ทันที
RFC 9562 เคร่งครัด + ตัวกรองรุ่นวินิจฉัยทีละบรรทัดแบบชุดรายงานตรวจสอบ JSON & CSV
ตรวจสอบ UUID
ระบบออฟไลน์พร้อมใช้งานพื้นที่ทำงานบนเบราว์เซอร์ส่วนตัว 100% • ไม่มีการอัปโหลดลงคลาวด์
ส่วนตัว 100% • ไม่อัปโหลดไฟล์ขึ้นเซิร์ฟเวอร์

ทำไมต้องใช้ เครื่องมือตรวจสอบความถูกต้อง UUID ฟรีของ Utiliome?

ออกแบบมาเพื่อความเป็นส่วนตัวสูงสุด ทำงานได้ทันที ไม่มีสะดุด ไม่ต้องสมัครสมาชิก ไม่ต้องเสียเงิน และไม่ต้องลงทะเบียน

รองรับทุกเวอร์ชันตามมาตรฐาน RFC 9562 อย่างครบถ้วน

ตรวจสอบตัวระบุยุคใหม่อย่าง UUIDv6, UUIDv7 และ UUIDv8 ไปพร้อมกับคีย์ v1 ถึง v5 แบบดั้งเดิม รวมถึงค่าคงที่พิเศษ Nil (ศูนย์ทั้งหมด) และ Max (หนึ่งทั้งหมด) ที่ Regex มาตรฐาน RFC 4122 รุ่นเก่ามักปฏิเสธ

จำแนกประเภทและกรองข้อมูลทีละบรรทัดแบบกลุ่ม (Bulk)

ประมวลผลสตริงหลายพันบรรทัดได้ในครั้งเดียว พร้อมติดป้ายกำกับแต่ละแถวด้วยเวอร์ชันที่ตรวจพบ บิตนำหน้า Variant และสาเหตุข้อผิดพลาดทางไวยากรณ์ที่ชัดเจน ก่อนส่งออกเฉพาะชุดข้อมูลที่ถูกต้อง

ตรวจสอบบิต Variant และไวยากรณ์มาตรฐานอย่างเคร่งครัด

ยืนยันโครงสร้างเลขฐานสิบหก 36 ตัวอักษรในรูปแบบ 8-4-4-4-12 ที่แม่นยำ และแยกแยะบิต Variant มาตรฐาน RFC 9562 (10xx) ออกจาก Microsoft COM/GUID รุ่นเก่า (110x), NCS (0xxx) และข้อความที่ไม่ใช่เลขฐานสิบหก

ประมวลผลแบบกลุ่มในเบราว์เซอร์ 100% ปลอดภัยไร้การอัปโหลด

ทำงานด้านการตรวจสอบไวยากรณ์ การแปลงเป็นตัวพิมพ์เล็กมาตรฐาน และการกรองข้อมูลทั้งหมดภายในแท็บเบราว์เซอร์ของคุณ โดยไม่มีการอัปโหลดไฟล์ดัมพ์ฐานข้อมูล รหัสลูกค้า หรือบันทึก Log ไปยังเซิร์ฟเวอร์ภายนอก

Utiliome เปรียบเทียบกับทางเลือกคลาวด์แบบเดิม

เปรียบเทียบขีดความสามารถของเอนจิน WebAssembly ภายในเครื่อง กับเครื่องมือคลาวด์แบบเก่า

ฟีเจอร์ Utiliome (ประมวลผลในเบราว์เซอร์) เครื่องมือแปลงไฟล์บนคลาวด์แบบเดิม
รองรับทุกเวอร์ชันตามมาตรฐาน RFC 9562 อย่างครบถ้วน ตรวจสอบตัวระบุยุคใหม่อย่าง UUIDv6, UUIDv7 และ UUIDv8 ไปพร้อมกับคีย์ v1 ถึง v5 แบบดั้งเดิม รวมถึงค่าคงที่พิเศษ Nil (ศูนย์ทั้งหมด) และ Max (หนึ่งทั้งหมด) ที่ Regex มาตรฐาน RFC 4122 รุ่นเก่ามักปฏิเสธ ตัวเลือกจำกัดและไม่มีการปรับแต่งขั้นสูง
จำแนกประเภทและกรองข้อมูลทีละบรรทัดแบบกลุ่ม (Bulk) ประมวลผลสตริงหลายพันบรรทัดได้ในครั้งเดียว พร้อมติดป้ายกำกับแต่ละแถวด้วยเวอร์ชันที่ตรวจพบ บิตนำหน้า Variant และสาเหตุข้อผิดพลาดทางไวยากรณ์ที่ชัดเจน ก่อนส่งออกเฉพาะชุดข้อมูลที่ถูกต้อง ต้องใช้โปรแกรมเสริมหรือแก้ไขด้วยตนเอง
ความเป็นส่วนตัวและการประมวลผล ประมวลผลในเบราว์เซอร์ 100% (ไม่อัปโหลดขึ้นเซิร์ฟเวอร์) อัปโหลดข้อมูลไปยังเซิร์ฟเวอร์คลาวด์ภายนอก
ราคาและการสมัครสมาชิก ฟรี 100% ตลอดชีพโดยไม่ต้องสมัครสมาชิก บังคับสมัครสมาชิกหรือต้องจ่ายค่าบริการรายเดือน
วิธีใช้งาน

วิธีใช้งาน เครื่องมือตรวจสอบความถูกต้อง UUID ใน 3 ขั้นตอนง่ายๆ

ไม่ต้องติดตั้งโปรแกรม ทุกอย่างทำงานได้โดยตรงผ่านเว็บเบราว์เซอร์ของคุณ

1

วางรายการ UUID ที่ต้องการตรวจสอบหรืออัปโหลดไฟล์

ป้อน UUID เดี่ยว วางข้อมูลหลายบรรทัดจาก Log ของแอปพลิเคชันหรือไฟล์ส่งออก SQL หรือลากไฟล์ข้อความและ CSV จากเครื่องของคุณลงในเครื่องมือตรวจสอบ

2

ตรวจสอบไวยากรณ์ เวอร์ชัน และ Variant รายบรรทัด

ดูสรุปผลการประมวลผลที่แสดงจำนวนบรรทัดที่ถูกต้องและไม่ถูกต้อง การจำแนกเวอร์ชันในแต่ละแถว (v1 ถึง v8, Nil, Max) พร้อมคำวินิจฉัยข้อผิดพลาดที่ชัดเจนสำหรับบรรทัดที่ไม่ผ่านเกณฑ์

3

กรองและส่งออกรายการ UUID ที่สะอาดพร้อมใช้งาน

กรองผลลัพธ์เพื่อเลือกเฉพาะตัวระบุที่ถูกต้องตามเกณฑ์ RFC 9562 หรือเลือกเฉพาะเวอร์ชัน UUID ที่ต้องการ จากนั้นคัดลอกหรือดาวน์โหลดรายการที่แปลงเป็นตัวพิมพ์เล็กมาตรฐานแล้วไปใช้งาน

ตัวอย่างการตรวจสอบ UUID แบบกลุ่ม: รายการข้อมูลขาเข้าและรายงานผลการวินิจฉัย

คำตอบโดยย่อ: เมื่อตรวจสอบรายการตัวระบุแบบหลายบรรทัด ระบบจะตัดช่องว่างส่วนเกินในแต่ละแถวแล้วนำไปเทียบกับโครงสร้างเลขฐานสิบหก 36 ตัวอักษรรูปแบบ 8-4-4-4-12 มาตรฐาน โดยตรวจสอบค่าคงที่พิเศษ Nil และ Max ก่อน จากนั้นจึงทดสอบว่าหลักที่ 13 ระบุเวอร์ชัน 1-8 และหลักที่ 17 ขึ้นต้นด้วยบิต Variant 10xx ตามมาตรฐาน RFC 9562

ไปป์ไลน์ประมวลผลข้อมูล (Data Pipelines) และระบบรับข้อมูลผ่าน API มักต้องเจอกับรูปแบบตัวระบุที่ปะปนกัน—ตั้งแตาคีย์ UUIDv7 สมัยใหม่, รหัส GUID ตัวพิมพ์ใหญ่แบบเก่า, ค่าคงที่สำหรับทำเครื่องหมายขอบเขต (Sentinel Constants) ไปจนถึงโทเค็นที่ไม่ใช่ UUID เช่น ULID ด้านล่างนี้คือตัวอย่างข้อมูลจริง 7 บรรทัดที่แสดงให้เห็นว่าการตรวจสอบตามมาตรฐาน RFC 9562 จำแนกแต่ละกรณีอย่างไร

ตัวอย่างข้อมูลขาเข้าแบบหลายบรรทัด

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
550e8400-e29b-91d4-a716-446655440000
550e8400-e29b-41d4-c716-446655440000
01ARZ3NDEKTSV4RRFFQ69G5FAV

รายงานผลการจำแนกรายบรรทัด

[
  {
    "line": 1,
    "input": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
    "valid": true,
    "classification": "UUIDv7",
    "variant": "RFC 9562 (10xx)",
    "normalized": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f"
  },
  {
    "line": 2,
    "input": "550e8400-e29b-41d4-a716-446655440000",
    "valid": true,
    "classification": "UUIDv4",
    "variant": "RFC 9562 (10xx)",
    "normalized": "550e8400-e29b-41d4-a716-446655440000"
  },
  {
    "line": 3,
    "input": "00000000-0000-0000-0000-000000000000",
    "valid": true,
    "classification": "Nil UUID (RFC 9562 Section 5.9)",
    "variant": "Nil (all zeros)",
    "normalized": "00000000-0000-0000-0000-000000000000"
  },
  {
    "line": 4,
    "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF",
    "valid": true,
    "classification": "Max UUID (RFC 9562 Section 5.10)",
    "variant": "Max (all ones)",
    "normalized": "ffffffff-ffff-ffff-ffff-ffffffffffff"
  },
  {
    "line": 5,
    "input": "550e8400-e29b-91d4-a716-446655440000",
    "valid": false,
    "error": "Invalid version nibble '9' at position 15 (expected 1-8, or Nil/Max)"
  },
  {
    "line": 6,
    "input": "550e8400-e29b-41d4-c716-446655440000",
    "valid": false,
    "error": "Non-RFC-9562 variant nibble 'c' (110x Microsoft legacy GUID; expected 8, 9, a, or b)"
  },
  {
    "line": 7,
    "input": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
    "valid": false,
    "error": "Invalid length (26 chars, Crockford Base32 ULID pattern; expected 36-char 8-4-4-4-12 hex)"
  }
]

ข้อมูลที่ผ่านการกรองและแปลงเป็นรูปแบบมาตรฐาน (Canonical Export)

การส่งออกเฉพาะแถวที่ถูกต้องจะแปลงตัวอักษรเลขฐานสิบหกพิมพ์ใหญ่ให้เป็นตัวพิมพ์เล็กมาตรฐานตามข้อกำหนด RFC 9562 หมวดที่ 4:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
ffffffff-ffff-ffff-ffff-ffffffffffff

กฎการตรวจสอบ RFC 9562, กรณีศึกษาขอบเขต Regex และการแปลงเป็นตัวพิมพ์เล็กมาตรฐาน

คำตอบโดยย่อ: ตัวตรวจสอบที่รองรับมาตรฐาน RFC 9562 จะไม่สามารถพึ่งพา Regex รูปแบบ [1-5] ของ RFC 4122 รุ่นเก่าได้อีกต่อไป แต่ต้องยอมรับเวอร์ชัน 1 ถึง 8 คู่กับ Variant [89ab] พร้อมทั้งอนุญาตค่าคงที่ Nil UUID (ศูนย์ทั้งหมด) และ Max UUID (F ทั้งหมด) อย่างชัดเจน รวมถึงแปลงตัวอักษรฐานสิบหกพิมพ์ใหญ่ให้เป็นตัวพิมพ์เล็กก่อนนำไปจัดเก็บในระบบดัชนีสตริง

มาตรฐาน RFC 9562 (พฤษภาคม 2024) ได้ขยายข้อกำหนดของ UUID จากเดิม 5 เวอร์ชันเป็น 8 เวอร์ชัน และกำหนดค่าคงที่ขอบเขตอีกสองรายการอย่างเป็นทางการ ส่งผลให้รูปแบบการตรวจสอบรุ่นเก่าที่ยังฝังอยู่ในไลบรารีตรวจสอบความถูกต้องและ API Gateway จำนวนมากใช้งานไม่ได้กับคีย์ยุคใหม่

ทำไม Regex มาตรฐาน RFC 4122 รุ่นเก่าจึงปฏิเสธคีย์ยุคใหม่

ตัวตรวจสอบที่เขียนขึ้นก่อนปี 2024 มักบังคับค่า [1-5] ที่ตัวอักษรฐานสิบหกหลักที่ 13 และไม่ได้เผื่อค่าคงที่พิเศษไว้ ทำให้ปฏิเสธคีย์ UUIDv6, UUIDv7, UUIDv8, Nil และ Max ที่ถูกต้องไปโดยปริยาย นิพจน์ปรกติ (Regular Expression) ตามมาตรฐาน RFC 9562 แบบไม่สนตัวพิมพ์เล็ก-ใหญ่ที่ครอบคลุมโครงสร้าง 8-4-4-4-12 ทั้งรุ่น v1-v8 รวมถึง Nil และ Max อย่างครบถ้วนคือ:

^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$

เมื่อต้องตรวจสอบข้อมูลขาเข้าที่ไม่น่าเชื่อถือในระบบหลังบ้าน (Backend Runtimes) เช่น Python, Ruby หรือ PCRE แนะนำให้ยึดจุดสิ้นสุดของสตริงด้วย \z (หรือ \Z ในฟังก์ชัน re.fullmatch ของ Python) แทนการใช้ $ เนื่องจาก $ จะจับคู่ตรงตำแหน่งก่อนหน้าอักขระขึ้นบรรทัดใหม่ \n ที่ต่อท้ายมาได้ ซึ่งอาจทำให้ Payload ที่แอบแทรกการขึ้นบรรทัดใหม่หลุดรอดการตรวจสอบสตริงแบบผิวเผินไปได้

ชนิดข้อมูล `uuid` ในฐานข้อมูล เทียบกับ Schema ของแอปพลิเคชันที่เคร่งครัด

สาเหตุหลักอย่างหนึ่งที่ทำให้การนำเข้าข้อมูลในระบบ Production ล้มเหลว คือความไม่ตรงกันระหว่างตัวแปลงข้อมูลที่ยืดหยุ่นของฐานข้อมูล กับตัวตรวจสอบ Schema ที่เข้มงวดของฝั่ง API:

  • ตัวแปลงเลขฐานสิบหก 128 บิตแบบยืดหยุ่น (เช่น ชนิดข้อมูล uuid ใน PostgreSQL): PostgreSQL ยอมรับตัวเลขฐานสิบหก 32 หลักใดๆ ก็ได้ (ไม่ว่าจะมีขีดกลางมาตรฐาน มีวงเล็บปีกกา {...} ครอบ หรือไม่มีขีดกลางเลย) โดยไม่สนใจค่า Nibble ของเวอร์ชัน (0-f) หรือบิตนำหน้า Variant (0xxx, 10xx, 110x, 111x) ดังนั้นรหัส Microsoft COM GUID รุ่นเก่า (Variant แบบ 110x ที่เป็นตัวอักษร c หรือ d ในหลักที่ 17) หรือค่าแฮช MD5 ขนาด 128 บิตทั่วไปที่เก็บในคอลัมน์ uuid จึงสามารถผ่านคำสั่ง SQL INSERT ได้โดยไม่เกิดข้อผิดพลาด
  • ตัวตรวจสอบ RFC 9562 ที่เคร่งครัด (OpenAPI, Zod, ไลบรารี uuid ใน Rust, google/uuid ใน Go): Schema ของ API ที่เข้มงวดจะตรวจสอบรูปแบบตัวอักษร 36 หลักพร้อมขีดกลางตามมาตรฐาน และมักบังคับให้ต้องเป็น Variant 10xx และเวอร์ชัน 1-8 (รวมถึง Nil/Max) การนำข้อมูลที่ส่งออกจาก SQL มาตรวจสอบแบบกลุ่มก่อนส่งต่อไปยังบริการ REST หรือ gRPC ที่เข้มงวด จะช่วยดักจับแถวข้อมูลที่มี Variant นอกมาตรฐาน RFC ได้ตั้งแต่เนิ่นๆ

การปรับรูปแบบตัวพิมพ์เล็กมาตรฐาน (Canonical Case Normalization)

มาตรฐาน RFC 9562 หมวดที่ 4 กำหนดให้ตัวแปลงข้อมูลต้องยอมรับตัวพิมพ์ใหญ่ A-F เป็นข้อมูลขาเข้าได้ แต่ต้องสร้างผลลัพธ์ขาออกเป็นตัวพิมพ์เล็ก a-f เสมอ แม้ว่าชนิดข้อมูลไบนารีขนาด 16 ไบต์โดยตรงของฐานข้อมูล (UUID ใน PostgreSQL, BINARY(16) ใน MySQL) จะตัดปัญหาเรื่องตัวพิมพ์เล็ก-ใหญ่ออกไปโดยอัตโนมัติ แต่ระบบที่จัดเก็บ UUID ในรูปแบบ VARCHAR(36), คีย์ใน Redis, Partition Key ใน DynamoDB หรือแคช JSON จะมองว่า 550E8400-... และ 550e8400-... เป็นคนละสตริงกัน เว้นแต่จะถูกแปลงให้เป็นตัวพิมพ์เล็กเหมือนกันตั้งแต่ขั้นตอนการตรวจสอบ

เปรียบเทียบเครื่องมือตรวจสอบ vs เครื่องมือถอดรหัส vs เครื่องมือสร้าง UUID: ควรเลือกใช้ตัวไหน?

คำตอบโดยย่อ: ใช้เครื่องมือตรวจสอบความถูกต้อง UUID เพื่อเช็คไวยากรณ์ ตรวจสอบความสอดคล้องตามมาตรฐาน RFC 9562 จำแนกเวอร์ชันจากรายการจำนวนมาก และส่งออก ID ที่สะอาด ใช้เครื่องมือวิเคราะห์และถอดรหัส UUID เมื่อต้องการดึงเวลา UTC และฟิลด์ระดับ 128 บิตจากรหัสเฉพาะเจาะจง หรือใช้เครื่องมือสร้าง UUID v4 แบบสุ่มเพื่อสร้างรหัสตัวระบุใหม่ที่ปลอดภัยทางคริปโตกราฟี

เลือกใช้เครื่องมือจัดการ UUID บน Utiliome ให้เหมาะกับงานของคุณ ไม่ว่าจะเป็นการตรวจสอบรายการที่มีอยู่เดิม การเจาะลึกโครงสร้างบิตภายใน หรือการสร้างคีย์ชุดใหม่:

ความสามารถ เครื่องมือตรวจสอบความถูกต้อง UUID (เครื่องมือนี้) เครื่องมือวิเคราะห์และถอดรหัส UUID เครื่องมือสร้าง UUID v4 แบบสุ่ม
วัตถุประสงค์หลัก ตรวจสอบความถูกต้องของ UUID เดี่ยวหรือแบบกลุ่มหลายบรรทัด และกรองรายการที่ผิดรูปแบบออก ถอดรหัสโครงสร้างไบนารี 128 บิต, Node ID และค่าเวลา UTC ที่ฝังอยู่ใน UUID สร้างตัวระบุ UUIDv4 แบบสุ่มที่ปลอดภัยทางคริปโตกราฟี (CSPRNG) จำนวนมาก
การประมวลผลรายการแบบกลุ่ม รองรับ — วางรายการหรืออัปโหลดไฟล์ ดูผลวินิจฉัยรายบรรทัด และส่งออกเฉพาะชุดข้อมูลที่ถูกต้อง ไม่รองรับ — ออกแบบมาเพื่อเจาะลึกโครงสร้างระดับบิตของตัวระบุทีละรายการ ส่งออกคีย์ v4 แบบสุ่มชุดใหม่เท่านั้น ไม่สามารถใช้ตรวจสอบข้อมูลจากภายนอกได้
ความครอบคลุมของเวอร์ชัน จำแนกได้ตั้งแต่ v1 ถึง v8, Nil (0000...) และ Max (ffff...) ถอดรหัสโครงสร้างบิตสำหรับ v1 ถึง v8, Nil และ Max สร้างเฉพาะ UUIDv4 ตามมาตรฐาน RFC 9562 (หากต้องการคีย์ที่เรียงตามเวลา ให้ใช้ เครื่องมือสร้าง UUID v7, v6 และ v1)
การดึงค่าเวลา (Timestamp) ระบุได้ว่าคีย์ใดเป็นแบบอิงเวลา (v1, v6, v7) แต่ไม่ได้ถอดรหัสเป็นวันและเวลาออกมา ดึงค่าวันเวลา UTC รูปแบบ ISO-8601, Unix ms และค่า Gregorian ระดับ 100-ns ได้อย่างแม่นยำ ไม่เกี่ยวข้อง (UUIDv4 ประกอบด้วยบิตสุ่ม 122 บิตและไม่มีข้อมูลเวลาฝังอยู่)

แนวทางการทำงานที่แนะนำสำหรับนักพัฒนา

  • การทำความสะอาดไฟล์ส่งออก CSV, ไฟล์ Log หรือข้อมูลสำหรับย้ายระบบ (Migration Payloads): วางรายการของคุณลงในเครื่องมือนี้เพื่อแยกตัวระบุที่ถูกต้องตามมาตรฐาน RFC 9562 ออกจากสตริงที่เสียหาย, รหัส ULID หรือ GUID รุ่นเก่าที่ไม่อยู่ในเกณฑ์ RFC แล้วส่งออกเป็นรายการตัวพิมพ์เล็กที่สะอาดพร้อมใช้งาน
  • การตรวจสอบเวลาที่สร้างของคีย์แบบอิงเวลา: คัดลอกตัวระบุรุ่น v1, v6 หรือ v7 ที่ถูกต้องไปยัง เครื่องมือวิเคราะห์และถอดรหัส UUID เพื่อดูค่าเวลา UTC ที่สร้าง ลำดับสัญญาณนาฬิกา (Clock Sequence) และฟิลด์ไบนารี 128 บิตที่ฝังอยู่ภายใน
  • การสร้างรหัสตัวระบุชุดใหม่: ใช้ เครื่องมือสร้าง UUID v4 แบบสุ่ม เมื่อต้องการโทเค็นแบบสุ่มที่คาดเดาไม่ได้ หรือใช้ เครื่องมือสร้าง UUID v7, v6 และ v1 เมื่อต้องการสร้าง Primary Key สำหรับฐานข้อมูลที่สามารถเรียงลำดับตามเวลาได้อย่างมีประสิทธิภาพ
คำถามที่พบบ่อย

คำถามที่พบบ่อยและคู่มือทางเทคนิค เครื่องมือตรวจสอบความถูกต้อง UUID

รวมทุกสิ่งที่คุณควรรู้เกี่ยวกับการใช้งาน ตรวจสอบความถูกต้อง uuid ออนไลน์ฟรีของ Utiliome

ค่า Nil (ศูนย์ทั้งหมด) และ Max (F ทั้งหมด) ถือเป็น UUID ที่ถูกต้องตามมาตรฐาน RFC 9562 หรือไม่?

ถูกต้อง มาตรฐาน RFC 9562 หมวดที่ 5.9 กำหนดให้ 00000000-0000-0000-0000-000000000000 เป็น Nil UUID และหมวดที่ 5.10 กำหนดให้ ffffffff-ffff-ffff-ffff-ffffffffffff เป็น Max UUID สำหรับใช้เป็นค่าคงที่บอกขอบเขต (Sentinel Values) และการคิวรีหาขอบเขตบนสุด แม้ว่าค่า Nibble ของเวอร์ชันและ Variant ของทั้งคู่จะอยู่นอกช่วง [1-8] และ [89ab] ก็ตาม

ทำไมรหัส Microsoft GUID จึงบันทึกเข้า PostgreSQL ได้สำเร็จ แต่ไม่ผ่านการตรวจสอบ RFC 9562 ที่เคร่งครัด?

รหัส Microsoft COM/DCOM GUID รุ่นเก่าอาจใช้บิต Variant แบบรองรับย้อนหลัง 110x (ตัวอักษรฐานสิบหกหลักที่ 17 เป็น c หรือ d) แทนที่จะเป็น Variant 10xx ตามมาตรฐาน RFC 9562 (8, 9, a, b) คอลัมน์ชนิด uuid ของ PostgreSQL จะยอมรับค่าเลขฐานสิบหกขนาด 128 บิตใดๆ ก็ได้โดยไม่เช็คบิตเวอร์ชันหรือ Variant ในขณะที่ตัวตรวจสอบ RFC 9562 ที่เคร่งครัดจะแจ้งเตือนทันทีหากพบ Variant ที่ไม่ใช่ 10xx

การใช้ตัวอักษรเลขฐานสิบหกพิมพ์ใหญ่ทำให้ UUID ไม่ถูกต้องหรือไม่?

ไม่ผิดแต่อย่างใด มาตรฐาน RFC 9562 หมวดที่ 4 ระบุว่าตัวอ่านข้อมูลต้องยอมรับทั้งตัวพิมพ์ใหญ่ A-F และตัวพิมพ์เล็ก a-f โดยไม่แยกแยะความต่างเมื่ออ่านค่า UUID แต่กำหนดให้ตัวสร้างและตัวจัดรูปแบบข้อมูลต้องส่งออกเป็นตัวพิมพ์เล็กมาตรฐานเสมอ เพื่อป้องกันไม่ให้ดัชนีสตริงหรือ Hash Map ที่แยกแยะตัวพิมพ์เล็ก-ใหญ่มองว่าเป็นคีย์คนละตัวและจัดเก็บข้อมูลซ้ำซ้อน

ทำไม Regex สำหรับตรวจสอบ UUID รุ่นเก่าจึงปฏิเสธ UUID v7 และ UUID v8?

รูปแบบ Regex ที่เขียนขึ้นตามมาตรฐาน RFC 4122 (ประกาศใช้เมื่อปี 2005) มักระบุค่าตายตัวเป็น [1-5] ในหลักที่ 13 ของเลขฐานสิบหก เพราะก่อนเดือนพฤษภาคม 2024 มีเพียงเวอร์ชัน 1 ถึง 5 เท่านั้น จนกระทั่งมาตรฐาน RFC 9562 ได้ประกาศเพิ่มรุ่น v6 ที่จัดเรียงเวลา Gregorian ใหม่, รุ่น v7 ที่เรียงตามเวลา Unix Epoch, รุ่น v8 แบบกำหนดเอง และค่าคงที่ Max UUID ที่มีบิตเป็นหนึ่งทั้งหมดเข้ามาอย่างเป็นทางการ

รหัส ULID, GUID ที่มีวงเล็บปีกกาครอบ หรือสตริงฐานสิบหก 32 ตัวอักษรแบบไม่มีขีดกลาง ถือเป็น UUID รูปแบบมาตรฐานหรือไม่?

ไม่ถือเป็นรูปแบบข้อความมาตรฐาน (Canonical Textual Form) เนื่องจาก ULID เข้ารหัสข้อมูล 128 บิตด้วยอักขระ Crockford Base32 จำนวน 26 ตัวแทนการใช้เลขฐานสิบหก ส่วนวงเล็บปีกกา {...}, คำนำหน้า urn:uuid: และสตริง 32 ตัวอักษรแบบไม่มีขีดกลางเป็นเพียงรูปแบบห่อหุ้มสำหรับการรับส่งข้อมูลทางเลือกเท่านั้น ไวยากรณ์ UUID มาตรฐานตาม RFC 9562 บังคับว่าต้องมีความยาว 36 ตัวอักษรและจัดรูปแบบเป็นกลุ่มตัวเลขฐานสิบหก 8-4-4-4-12 อย่างเคร่งครัด