ตัวสร้าง UUID

สร้าง UUID ในเบราว์เซอร์ของคุณ: v4 แบบสุ่ม, v7 เรียงตามเวลา หรือ v5 ที่มีความแน่นอน สูงสุด 1000 รายการพร้อมกัน และจะไม่มีข้อมูลใดออกจากอุปกรณ์ของคุณ

กดสร้างเพื่อสุ่มเลือก
เวอร์ชัน
ตัวเลือกขั้นสูง

คุณต้องการตัวระบุที่ไม่ซ้ำซ้อนกับสิ่งที่คนอื่นสร้างขึ้นบนเครื่องคอมพิวเตอร์ที่คุณไม่เคยรู้จักและไม่ต้องขออนุญาตจากใครเลยใช่ไหม นั่นคืองานที่ UUID ทำ มันคือตัวเลข 128 บิต ซึ่งเขียนเป็นตัวอักษร 36 ตัวในรูปแบบ 8-4-4-4-12 ที่คุ้นเคย และการออกแบบทั้งหมดของมันก็เพื่อให้สองตัวนั้นไม่มีทางเหมือนกันเลย แม้ว่าจะไม่มีระบบใดๆ คอยประสานงานว่าใครจะได้ตัวไหนไปก็ตาม ตัวสร้างนี้สามารถทำสิ่งเหล่านี้ได้ฟรีในเบราว์เซอร์ของคุณ: เลือกเวอร์ชันใน 'เวอร์ชัน' ระบุจำนวนที่คุณต้องการใน 'จำนวนรายการที่เลือก' แล้วกด 'สร้างผลลัพธ์' หน้าเว็บจะเปิดขึ้นมาพร้อมกับ v4 เพียงตัวเดียว ซึ่งเป็นเวอร์ชันที่โปรเจกต์ส่วนใหญ่ต้องการ ดังนั้นตัวระบุแรกของคุณจึงอยู่ห่างออกไปเพียงแค่คลิกเดียว

ตัวระบุทุกตัวถูกสร้างขึ้นโดยเบราว์เซอร์ของคุณผ่าน Web Crypto API เวอร์ชัน 4 จะใช้ crypto.randomUUID() ในจุดที่เบราว์เซอร์รองรับ และจะใช้ crypto.getRandomValues() ในกรณีอื่น — ซึ่งเป็นแหล่งที่มาของการสุ่มที่แข็งแกร่งในทางวิทยาการเข้ารหัสลับ แทนที่จะใช้ฟังก์ชันสุ่มเทียมของ JavaScript อย่าง Math.random() ส่วนเวอร์ชัน 7 จะวางไทม์สแตมป์ขนาด 48 บิตแบบมิลลิวินาทีไว้ด้านหน้า ตามด้วยตัวนับขนาด 12 บิตที่จะเพิ่มค่าขึ้นภายในมิลลิวินาทีเดียวกันนั้น จากนั้นตามด้วยบิตสุ่มอีก 62 บิต ซึ่งนี่คือวิธีการเรียงลำดับตามที่ระบุไว้ใน RFC 9562 ตัวนับนี้นี่เองที่เป็นเหตุผลว่าทำไมการสร้างเป็นชุดละหนึ่งพันตัวจึงออกมาเรียงตามลำดับแทนที่จะสลับกัน เวอร์ชัน 1 จะรวมไทม์สแตมป์เข้ากับตัวระบุโหนดแบบสุ่มที่มีการตั้งค่าบิตมัลติคาสต์ ดังนั้นมันจึงไม่นำที่อยู่การ์ดเครือข่ายของคุณติดไปด้วยเหมือนอย่างที่เคยทำในการใช้งานดั้งเดิมยุค 1990 เวอร์ชัน 3 และ 5 ไม่ได้มีการสุ่มเลย: พวกมันจะแฮชเนมสเปซเข้ากับชื่อ โดยใช้ MD5 และ SHA-1 ตามลำดับ และการแฮชเหล่านั้นก็เกิดขึ้นบนอุปกรณ์ของคุณด้วยเช่นกัน ไม่มีการส่งข้อมูลใดๆ ไปยังเซิร์ฟเวอร์ ไม่มีการเก็บล็อกประวัติ และเมื่อหน้าเว็บโหลดเสร็จสมบูรณ์แล้ว มันก็จะยังคงทำงานต่อไปได้แม้จะตัดการเชื่อมต่ออินเทอร์เน็ตก็ตาม

'เวอร์ชัน' คือฟิลด์ที่กำหนดทุกสิ่งทุกอย่าง เวอร์ชัน 4 คือบิตสุ่ม 122 บิตที่ไม่มีโครงสร้างใดๆ — เป็นค่าเริ่มต้น และเป็นคำตอบที่ถูกต้องเมื่อตัวระบุนั้นต้องการเพียงแค่ความไม่ซ้ำกัน เวอร์ชัน 7 ยังคงรักษาบิตสุ่มไว้ 62 บิต แต่นำหน้าด้วยเวลาที่มันถูกสร้างขึ้น ดังนั้นเมื่อสร้างเป็นชุด พวกมันจะถูกเรียงลำดับตามเวลาที่ถูกสร้างขึ้น นี่คือสิ่งที่ทำให้มันเป็นเวอร์ชันที่ควรเลือกใช้เมื่อตัวระบุนั้นจะถูกนำไปใช้เป็นคีย์ของฐานข้อมูล เวอร์ชัน 1 คือรูปแบบดั้งเดิมที่อิงตามเวลา ซึ่งเก็บไว้ที่นี่สำหรับระบบที่ยังคงต้องการใช้มันอยู่ เวอร์ชัน 3 และ 5 เป็นคู่ที่แตกต่าง: พวกมันมีความแน่นอน (deterministic) ซึ่งหมายความว่าอินพุตเดียวกันจะสร้างตัวระบุเดียวกันเสมอ และพวกมันจะรับฟิลด์เพิ่มเติมอีกสองช่อง — 'เนมสเปซ' ซึ่งเป็นหนึ่งในพื้นที่มาตรฐานอย่าง DNS, URL, OID และ X.500 หรือใช้แบบ 'กำหนดเอง' ของคุณเอง และ 'ชื่อ' ซึ่งเป็นสตริงที่กำลังถูกระบุ เมื่อคุณป้อนเนมสเปซ URL และ https://example.com/a ให้กับ v5 คุณก็จะได้ UUID ตัวเดียวกันทั้งในวันนี้ พรุ่งนี้ และบนเครื่องคอมพิวเตอร์ของคนอื่นด้วย ด้วยเหตุนี้ 'จำนวนรายการที่เลือก' จึงหายไปเมื่อถูกเลือกเป็น v3 หรือ v5: เนื่องจากการคัดลอกค่าที่มีความแน่นอนหนึ่งค่าจำนวนหนึ่งพันชุด ก็จะเป็นเพียงแค่ค่าที่มีความแน่นอนค่าเดียวจำนวนหนึ่งพันชุดเท่านั้น สำหรับเวอร์ชันอื่น ๆ ทุกเวอร์ชัน 'จำนวนรายการที่เลือก' จะรันตั้งแต่ 1 ถึง 1000

สวิตช์สี่ตัวจะเปลี่ยนรูปร่างของผลลัพธ์โดยไม่เปลี่ยนบิต 128 บิตที่อยู่ด้านล่าง 'ตัวพิมพ์ใหญ่' จะพิมพ์ตัวเลขฐานสิบหกเป็นตัวพิมพ์ใหญ่ 'ไม่มีขีดกลาง' จะให้รูปแบบ 32 ตัวอักษรแบบกะทัดรัดซึ่งคอลัมน์และชื่อไฟล์บางระบบต้องการ และ 'วงเล็บปีกกา' จะหุ้มค่าไว้ใน { } — ซึ่งเป็นรูปแบบที่ Windows และโลกของ .NET เรียกว่า GUID ภายใต้ 'ตัวเลือกขั้นสูง' ตัวเลือก urn:uuid: จะเพิ่มคำนำหน้าซึ่งทำให้มันกลายเป็น URN อย่างเป็นทางการ; มันจะปิด 'วงเล็บปีกกา' และ 'ไม่มีขีดกลาง' ขณะที่มันถูกเปิดใช้งาน เนื่องจากมาตรฐานอนุญาตให้มีรูปแบบ URN เพียงรูปแบบเดียวเท่านั้นและมันเป็นรูปแบบดั้งเดิมที่มีขีดกลาง 'รูปแบบการคัดลอก' จะเป็นตัวตัดสินใจว่าชุดข้อมูลจะถูกนำมาต่อกันอย่างไรเมื่อคุณนำมันไปใช้: หนึ่งรายการต่อบรรทัด คั่นด้วยเครื่องหมายจุลภาค หรือแต่ละค่าอยู่ในเครื่องหมายคำพูดพร้อมกับมีเครื่องหมายจุลภาคต่อท้าย ซึ่งสามารถนำไปวางในอาร์เรย์ในโค้ดได้โดยตรง ภายใต้ผลลัพธ์จะมีบรรทัดที่รายงานการสุ่มในหน่วยบิต — 122 สำหรับ v4, 62 สำหรับ v7 — และสำหรับ v7 จะแสดงไทม์สแตมป์ที่เข้ารหัสอยู่ในตัวระบุแรกของชุด เพื่อให้สามารถมองเห็นเวลาที่อยู่ภายในค่าได้แทนที่จะเป็นเพียงแค่ความหมายโดยนัย 'คัดลอกทั้งหมด' และ 'บันทึกลงไฟล์' ทั้งคู่จะเคารพ 'รูปแบบการคัดลอก' ที่ตั้งไว้ 'ประวัติ' จะเก็บ 10 ชุดล่าสุดของคุณไว้ในเบราว์เซอร์ของคุณเอง: คลิกหนึ่งรายการเพื่อนำกลับมา คัดลอกหรือลบเพียงรายการเดียว หรือจะล้างทั้งหมดก็ได้ 'ล้าง' จะทำให้ผลลัพธ์ว่างเปล่าแต่ยังคงการตั้งค่าของคุณไว้เหมือนเดิม และหลังจากที่ตัวระบุเกิน 50 รายการไปแล้ว รายการนั้นจะกลายเป็นบล็อกเดียวที่สามารถเลื่อนดูได้แทนที่จะเป็นห้าสิบบรรทัด

สิ่งที่ส่งผลกระทบมากที่สุดบนหน้านี้คือความแตกต่างระหว่าง v4 และ v7 ในฐานะคีย์หลัก (primary key) และมันไม่ใช่เรื่องของความชอบส่วนตัว ดัชนีฐานข้อมูล (Database indexes) คือโครงสร้างต้นไม้ที่ถูกเก็บไว้ในลำดับที่เรียงกัน และคีย์ใหม่ที่เข้ามาอยู่ในลำดับนั้นจะเป็นตัวตัดสินว่าการแทรกข้อมูลจะต้องใช้การทำงานมากน้อยเพียงใด คีย์ v4 เป็นแบบสุ่ม ดังนั้นการแทรกข้อมูลที่ต่อเนื่องกันจึงไปตกอยู่ในมุมที่ไม่เกี่ยวข้องกันเลยของดัชนี: หน้ากระดาษที่เต็มแล้วจะถูกแบ่งย่อยออกไป (page split) ส่วนของโครงสร้างต้นไม้ที่ฐานข้อมูลเก็บไว้ในหน่วยความจำแทบจะไม่ได้เป็นส่วนที่การแทรกครั้งถัดไปต้องการเลย และผลลัพธ์คือดัชนีจะมีขนาดใหญ่ขึ้นและมีการแตกกระจายมากเกินกว่าที่แถวข้อมูลที่มันชี้ไปนั้นจะเหมาะสม คีย์ v7 นำหน้าด้วยมิลลิวินาทีปัจจุบัน ดังนั้นการแทรกข้อมูลที่ต่อเนื่องกันจึงไปตกอยู่ข้างๆ กันที่ขอบด้านขวาของโครงสร้างต้นไม้ ซึ่งเป็นรูปแบบเดียวกับที่เลขจำนวนเต็มที่เพิ่มค่าอัตโนมัติสร้างขึ้น และเป็นรูปแบบที่โครงสร้างดัชนีถูกสร้างขึ้นมาเพื่อรองรับสิ่งนี้ นั่นคือการแลกเปลี่ยนทั้งหมด: v7 มอบพฤติกรรมการแทรกข้อมูลของคีย์แบบเรียงลำดับให้กับคุณ ในขณะที่ยังคงรักษาคุณสมบัติที่ทำให้คุณเลือกใช้ UUID ตั้งแต่แรก นั่นคือใครก็ตามสามารถสร้างมันขึ้นมาได้โดยไม่ต้องไปถามเซิร์ฟเวอร์ สิ่งที่ต้องแลกมาก็คือตอนนี้สามารถอ่านเวลาที่สร้างได้จากภายในตัวระบุ และเรื่องนั้นจะมีความสำคัญหรือไม่ก็เป็นคำถามที่เกี่ยวกับข้อมูลของคุณ ไม่ใช่เกี่ยวกับรูปแบบ

ไม่มีอะไรที่จะตรวจสอบความไม่ซ้ำกันของ UUID ได้เลย ขนาดของมันคือสิ่งรับประกัน ไม่มีรีจิสทรี ไม่มีการไปกลับของเซิร์ฟเวอร์ ไม่มีการค้นหา — ตัวสร้างจะผลิตตัวเลขออกมาแล้วส่งมอบให้ และเหตุผลที่สองตัวนั้นจะไม่ชนกันก็เป็นเพียงเพราะว่ามีค่า v4 ที่เป็นไปได้ทั้งหมด 2^122 ค่า หรือประมาณ 5.3 อันเดซิลเลียน ปัญหาทฤษฎีบทวันเกิด (birthday problem) เป็นวิธีที่ซื่อสัตย์ในการประเมินขนาดของมัน: คุณจะต้องมีตัวระบุประมาณ 2.7 ควินทิลเลียน ก่อนที่จะมีโอกาส 50% ที่สองตัวใดๆ จะตรงกัน ซึ่งก็คือการสร้าง UUID ใหม่หนึ่งพันล้านตัวทุกๆ วินาทีเป็นเวลา 86 ปี มันคุ้มค่าที่จะระบุให้ชัดเจนว่าสิ่งนั้นให้สัญญาและไม่ได้ให้สัญญาอะไร มันเป็นการรับประกันทางสถิติ ไม่ใช่ทางเลขคณิต และมันจะคงอยู่ตราบเท่าที่การสุ่มที่อยู่ด้านล่างนั้นเป็นของจริงเท่านั้น — ตัวสร้างที่มีการตั้งค่า seed มาไม่ดี หรือเครื่องเสมือนที่ถูกโคลนมาพร้อมกับ entropy pool ของมัน จะทำลายการรับประกันนี้ในแบบที่รูปแบบไม่สามารถตรวจจับได้ เวอร์ชัน 7 ทำให้คำถามนี้แคบลงไปอีก: ภายในมิลลิวินาทีเดียวกันตัวสร้างตัวเดียวจะไม่สามารถซ้ำกับตัวมันเองได้เลย เนื่องจากการทำงานของตัวนับนั้นเป็นการเพิ่มขึ้นตามลำดับแทนที่จะเป็นการทอยลูกเต๋า และสำหรับตัวสร้างที่เป็นอิสระต่อกัน บิตสุ่ม 62 บิตก็จะเป็นตัวจัดการหน้าที่นั้นเอง

UUID เป็นตัวระบุ ไม่ใช่รหัสผ่าน เวอร์ชัน 4 นั้นไม่สามารถคาดเดาได้ และนั่นทำให้ผู้คนเผลอไปปฏิบัติกับมันราวกับว่าเป็นความลับ — เช่นเป็นลิงก์สำหรับรีเซ็ตรหัสผ่าน URL ที่เดาไม่ได้ โทเค็นเซสชัน หรือคีย์ API ความไม่สามารถคาดเดาได้นั้นเป็นเรื่องจริง แต่ความลับเป็นคุณสมบัติของวิธีการจัดการกับค่านั้น และตัวระบุถูกออกแบบมาให้ถูกจัดการอย่างไม่ระมัดระวัง: พวกมันอยู่ใน URL ซึ่งจะไปปรากฏในประวัติเบราว์เซอร์ ล็อกของเซิร์ฟเวอร์ ส่วนหัวของ referrer และเครื่องมือวิเคราะห์ และถูกวางลงในข้อความแชท เวอร์ชันอื่นๆ นั้นถือว่าเป็นตัวเลือกที่แย่ยิ่งกว่า เวอร์ชัน 1 และเวอร์ชัน 7 ต่างก็เข้ารหัสเวลาที่สร้างไว้ ดังนั้นใครก็ตามที่ถือมันไว้ก็จะรู้ได้คร่าวๆ ว่ามันถูกสร้างขึ้นเมื่อใด และสามารถตีกรอบพื้นที่ของสิ่งอื่นๆ ที่ถูกสร้างขึ้นมาพร้อมๆ กันได้ เวอร์ชัน 3 และ 5 ถูกตั้งใจทำให้มีความแน่นอน: UUID v5 ของที่อยู่อีเมลไม่ใช่ความลับที่ถูกแฮช แต่มันคือค่าที่ใครก็ตามที่มีที่อยู่เดียวกันสามารถคำนวณออกมาได้ในเสี้ยววินาที จงใช้ UUID เพื่อตั้งชื่อสิ่งใดสิ่งหนึ่ง และให้ใช้ตัวสร้างรหัสผ่าน หรือโทเค็นจากไลบรารีที่สร้างขึ้นมาสำหรับความลับโดยเฉพาะ เมื่อค่านั้นจำเป็นต้องถูกปกปิดไว้ไม่ให้ใครรู้

ทำไมจึงควรเลือกใช้ตัวสร้าง UUID นี้?

UUID ปรากฏตัวขึ้นที่ใดก็ตามที่มีบางสิ่งต้องได้รับการตั้งชื่อก่อนที่สิ่งใดจะสามารถยืนยันได้ว่าชื่อนั้นยังว่างอยู่ โค้ดของแอปพลิเคชันจะสร้างมันขึ้นมาสำหรับแถวข้อมูลที่กำลังจะแทรก เพื่อให้ออบเจ็กต์นั้นมีตัวตนก่อนที่มันจะไปถึงฐานข้อมูล และไคลเอนต์สามารถอ้างอิงถึงมันได้ในขณะที่การเขียนข้อมูลยังดำเนินการอยู่ ระบบแบบกระจายศูนย์ยิ่งต้องพึ่งพามันมากขึ้นไปอีก: บริการหลายตัวที่กำลังเขียนข้อมูลลงในตารางเดียวกัน ไคลเอนต์บนมือถือที่กำลังสร้างบันทึกขณะที่ออฟไลน์อยู่บนเครื่องบิน คิวที่ต้องจดจำข้อความที่มันประมวลผลไปแล้ว — ทั้งหมดนี้ไม่สามารถรอคิวเพื่อใช้งานตัวนับที่ใช้ร่วมกันได้ เวอร์ชัน 5 ครอบคลุมความต้องการที่แตกต่างออกไป นั่นคือตัวระบุที่เสถียรซึ่งได้มาจากสิ่งที่คุณมีอยู่แล้ว: เอกสารเดียวกัน URL เดียวกัน หรือบัญชีเดียวกัน จะแมปไปยัง UUID เดียวกันเสมอ ดังนั้นการอิมพอร์ตจึงสามารถทำงานได้สองครั้งโดยไม่ทำให้เกิดข้อมูลซ้ำซ้อน ส่วนในที่อื่นๆ พวกมันเป็นเพียงรูปแบบที่ระบบต้องการเท่านั้น — ตัวระบุความสัมพันธ์ที่ร้อยเรียงผ่านล็อกและข้อมูลการติดตาม ชื่อไฟล์ที่จะไม่ชนกันเมื่อการอัปโหลดจากผู้ใช้หนึ่งพันคนตกลงมาในที่จัดเก็บเดียวกัน คีย์รีจิสทรีของ Windows ข้อมูลสำหรับการทดสอบ (test fixture) ที่จำเป็นต้องดูเหมือนข้อมูลจริง

มีข้อจำกัดบางประการที่ควรทราบตามความเป็นจริง หนึ่งชุดคือหนึ่งเวอร์ชัน: ค่าใน 'เวอร์ชัน' จะมีผลกับทุกอย่างที่อยู่ในชุดนั้น ดังนั้นการรัน v4 และการรัน v7 จึงถือเป็นสองชุด นี่คือตัวสร้าง ไม่ใช่ตัวตรวจสอบ — การวาง UUID ลงไปเพื่ออ่านเวอร์ชันหรือไทม์สแตมป์กลับคืนมาไม่ใช่สิ่งที่หน้านี้ทำได้ 'บันทึกลงไฟล์' จะเขียนเป็นไฟล์ข้อความธรรมดาแทนที่จะเป็น CSV หรือ JSON เวอร์ชัน 7 จะเปิดเผยอย่างชัดเจนว่ามันถูกสร้างขึ้นเมื่อใด จนถึงระดับมิลลิวินาที ซึ่งนี่คือการแลกเปลี่ยนที่เกิดขึ้นจริงและไม่ใช่ข้อบกพร่อง และเวอร์ชัน 1 ก็ปล่อยเวลาออกมาในลักษณะเดียวกัน; หากนั่นเป็นปัญหากับข้อมูลของคุณ เวอร์ชัน 4 คือเวอร์ชันเดียวที่จะไม่บอกอะไรกับใครเลย ค่าพิเศษสองค่าจากมาตรฐานไม่ได้เป็นเวอร์ชัน ดังนั้นจึงไม่มีเป็นตัวเลือกใน 'เวอร์ชัน' แต่คุณสามารถคัดลอกพวกมันจากที่นี่ได้: UUID ที่เป็นศูนย์ (nil UUID) 00000000-0000-0000-0000-000000000000 และ UUID สูงสุด (max UUID) ffffffff-ffff-ffff-ffff-ffffffffffff ทุกอย่างบนหน้านี้เป็นไปตาม RFC 9562 ซึ่งเป็นข้อกำหนดที่มาแทนที่ RFC 4122 ในปี 2024 ดังนั้นผลลัพธ์จึงได้รับการยอมรับจากไลบรารี ฐานข้อมูล หรือ API ใดๆ ก็ตามที่จัดการกับ UUID ภายใต้ข้อจำกัดเหล่านั้น การรับประกันถือว่ามีความแข็งแกร่ง: ตัวระบุทุกตัวถูกสร้างขึ้นตามมาตรฐาน จากการสุ่มที่ปลอดภัยทางวิทยาการเข้ารหัสลับ บนเครื่องของคุณเอง และไม่มีใครเคยเห็นมันมาก่อน

FAQ

ฉันจะสร้าง UUID ได้อย่างไร?

เลือกเวอร์ชันใน 'เวอร์ชัน' ตั้งค่าจำนวนที่คุณต้องการใน 'จำนวนรายการที่เลือก' แล้วกด 'สร้างผลลัพธ์' หน้าเว็บจะเปิดขึ้นมาด้วยตัวระบุเวอร์ชัน 4 เพียงตัวเดียว ซึ่งเป็นสิ่งที่โปรเจกต์ส่วนใหญ่ต้องการ ดังนั้น UUID ทั่วไปจึงอยู่ห่างออกไปเพียงคลิกเดียว ค่าแต่ละค่าจะปรากฏพร้อมกับปุ่มคัดลอกของมันเอง และ 'คัดลอกทั้งหมด' จะรับชุดข้อมูลทั้งหมดไปในคราวเดียว

ความแตกต่างระหว่าง UUID v4 และ v7 คืออะไร?

เวอร์ชัน 4 คือบิตสุ่ม 122 บิตที่ไม่มีโครงสร้างใดๆ เลย ดังนั้นสองตัวจึงไม่มีความเกี่ยวข้องกัน เวอร์ชัน 7 ใช้บิตแรก 48 บิตสำหรับมิลลิวินาทีที่มันถูกสร้างขึ้น เพิ่มตัวนับและบิตสุ่มอีก 62 บิต ด้วยเหตุนี้จึงสามารถเรียงลำดับได้: ชุดข้อมูลจะออกมาตามลำดับที่มันถูกสร้างขึ้น ใช้ v4 เมื่อตัวระบุต้องการเพียงแค่ความไม่ซ้ำกัน และใช้ v7 เมื่อมันจะกลายเป็นคีย์ของฐานข้อมูลด้วย

ฉันควรใช้ UUID เวอร์ชันไหน?

ใช้เวอร์ชัน 4 เว้นแต่ว่าคุณจะมีเหตุผลให้เลือกเวอร์ชันอื่น เลือกเวอร์ชัน 7 หากตัวระบุนั้นจะกลายเป็นคีย์หลักและประสิทธิภาพในการแทรกข้อมูลเป็นสิ่งสำคัญ เลือกเวอร์ชัน 5 หากคุณต้องการให้อินพุตเดิมสร้างตัวระบุเดิมออกมาเสมอ และเลือกเวอร์ชัน 1 ในกรณีที่ระบบที่คุณต้องติดต่อด้วยร้องขอมาเป็นการเฉพาะเท่านั้น เวอร์ชัน 3 ก็คือเวอร์ชัน 5 ที่ใช้ MD5 แทน SHA-1 และมีไว้เพื่อความเข้ากันได้

UUID ที่สร้างขึ้นนั้นเป็นการสุ่มและปลอดภัยจริงๆ หรือไม่?

การสุ่มนั้นมีความปลอดภัยทางวิทยาการเข้ารหัสลับ: มันมาจาก Web Crypto API ในเบราว์เซอร์ของคุณ ผ่านทาง crypto.randomUUID() หรือ crypto.getRandomValues() ไม่ใช่จาก Math.random() ความปลอดภัยในแง่ที่ไม่สามารถคาดเดาได้เป็นคำถามที่ต่างจากความปลอดภัยในแง่ของความลับ — UUID คือตัวระบุ และไม่ควรนำมาใช้เป็นรหัสผ่าน โทเค็นเซสชัน หรือคีย์ API

ฉันสามารถสร้าง UUID จำนวนมากๆ ในครั้งเดียวได้ไหม?

ได้ สูงสุด 1000 รายการในครั้งเดียว ตั้งค่า 'จำนวนรายการที่เลือก' แล้วกด 'สร้างผลลัพธ์'; หลังจากค่าที่ห้าสิบ ผลลัพธ์จะกลายเป็นบล็อกเดียวที่สามารถเลื่อนดูได้แทนที่จะเป็นรายการบรรทัดยาวๆ 'คัดลอกทั้งหมด' และ 'บันทึกลงไฟล์' จะรับชุดข้อมูลทั้งหมด นำมาต่อกันในรูปแบบที่ 'รูปแบบการคัดลอก' กำหนด — หนึ่งรายการต่อบรรทัด คั่นด้วยเครื่องหมายจุลภาค หรือใส่ในเครื่องหมายคำพูดเพื่อนำไปวางในอาร์เรย์

ทำไม v3 และ v5 จึงให้ UUID เหมือนเดิมทุกครั้ง?

เพราะนั่นคือสิ่งที่มันถูกสร้างมาเพื่อเป็นอย่างนั้น เวอร์ชัน 3 และ 5 มีความแน่นอน: มันจะแฮชเนมสเปซและชื่อที่คุณมอบให้ ดังนั้นอินพุตที่เหมือนกันจะสร้างตัวระบุที่เหมือนกันเสมอ ไม่ว่าบนเครื่องใดหรือในภาษาใดก็ตาม มันมีประโยชน์สำหรับการได้มาซึ่งตัวระบุที่เสถียรจากสิ่งที่คุณมีอยู่แล้ว และนั่นเป็นเหตุผลว่าทำไม 'จำนวนรายการที่เลือก' จึงถูกซ่อนไว้เมื่อคุณเลือกเวอร์ชันเหล่านี้

เนมสเปซและชื่อคืออะไร และฉันควรเลือกเนมสเปซไหน?

มันคืออินพุตสองตัวที่นำมาคำนวณเป็น UUID เวอร์ชัน 3 หรือเวอร์ชัน 5 'เนมสเปซ' เป็นตัวบอกว่าชื่อนั้นเป็นสิ่งประเภทใด — DNS สำหรับชื่อโฮสต์, URL สำหรับที่อยู่, OID และ X.500 สำหรับสคีมาไดเรกทอรีเหล่านั้น หรือ 'กำหนดเอง' หากคุณต้องการจัดหา UUID ของเนมสเปซของคุณเอง ซึ่งมักจะเป็นตัวเลือกทั่วไปภายในแอปพลิเคชัน 'ชื่อ' คือสตริงนั้นๆ เนมสเปซที่ต่างกันจะให้ผลลัพธ์ที่แตกต่างกันอย่างสิ้นเชิงสำหรับชื่อเดียวกัน ซึ่งเป็นเหตุผลว่าทำไมถึงต้องมีมัน

ทำไม UUID v7 จึงดีกว่า v4 สำหรับการใช้เป็นคีย์หลักของฐานข้อมูล?

เนื่องจากตำแหน่งที่ค่าไปตกอยู่ในดัชนี ดัชนีจะถูกเก็บรักษาไว้ในลำดับที่เรียงกัน และคีย์ v4 แบบสุ่มสามารถตกที่ใดก็ได้ในนั้น ดังนั้นการแทรกข้อมูลจะทำให้เกิดการแบ่งย่อยของหน้า (page split) กระจายไปทั่วโครงสร้างต้นไม้ และส่วนที่เก็บไว้ในหน่วยความจำแทบจะไม่ได้เป็นส่วนที่ต้องการในครั้งต่อไปเลย คีย์ v7 เริ่มต้นด้วยมิลลิวินาทีปัจจุบัน ดังนั้นการแทรกข้อมูลที่ต่อเนื่องกันจึงไปตกอยู่รวมกันที่ส่วนท้ายของดัชนี ซึ่งเป็นพฤติกรรมเดียวกับคีย์ที่เรียงตามลำดับ — ในขณะที่ยังคงยอมให้ระบบใดๆ สร้างตัวระบุได้โดยไม่ต้องไปร้องขอตัวนับส่วนกลาง

UUID สองตัวจะมีโอกาสเหมือนกันได้ไหม?

ในทางทฤษฎีคือได้ แต่ในทางปฏิบัติคือไม่ได้ และมันคุ้มค่าที่จะรู้ว่าเพราะอะไร ไม่มีอะไรตรวจสอบความไม่ซ้ำกัน: มีค่าเวอร์ชัน 4 ที่เป็นไปได้ทั้งหมด 2^122 ค่า หรือประมาณ 5.3 อันเดซิลเลียน และคุณจะต้องมีค่าเหล่านี้ประมาณ 2.7 ควินทิลเลียนตัว — พันล้านตัวต่อวินาทีเป็นเวลา 86 ปี — ก่อนที่จะมีโอกาส 50% ที่จะเกิดการชนกันเพียงครั้งเดียว การรับประกันนี้เป็นทางสถิติมากกว่าแบบสัมบูรณ์ และมันขึ้นอยู่กับการสุ่มที่เป็นของจริง ซึ่งนี่คือเหตุผลที่ตัวสร้างนี้เลือกใช้ Web Crypto API แทนที่จะเป็นฟังก์ชันสุ่มเทียมธรรมดา

ฉันสามารถใช้ UUID เป็นรหัสผ่าน คีย์ API หรือโทเค็นเซสชันได้หรือไม่?

ไม่ได้ และนี่คือความผิดพลาดที่ก่อให้เกิดความเสียหายมากที่สุด UUID เวอร์ชัน 4 นั้นไม่สามารถคาดเดาได้ แต่ตัวระบุนั้นถูกจัดการเสมือนว่ามันเป็นสาธารณะ: พวกมันจะไปอยู่ใน URL ประวัติเบราว์เซอร์ ล็อกเซิร์ฟเวอร์ ส่วนหัวของ referrer และเครื่องมือวิเคราะห์ เวอร์ชัน 1 และ 7 ยังเปิดเผยด้วยว่ามันถูกสร้างขึ้นเมื่อใด และเวอร์ชัน 3 และ 5 ก็สามารถถูกคำนวณใหม่ได้โดยใครก็ตามที่รู้อินพุต สำหรับสิ่งที่ต้องเก็บเป็นความลับ ให้ใช้ตัวสร้างรหัสผ่านหรือโทเค็นจากไลบรารีที่สร้างขึ้นสำหรับความลับโดยเฉพาะ

UUID v7 เปิดเผยว่าถูกสร้างขึ้นเมื่อไหร่ใช่ไหม?

ใช่ ไปจนถึงระดับมิลลิวินาที และนั่นเป็นสิ่งที่จงใจออกแบบมา ไม่ใช่ความผิดพลาด — ไทม์สแตมป์คือสิ่งที่ทำให้ v7 สามารถเรียงลำดับได้ บรรทัดใต้ผลลัพธ์จะแสดงให้คุณเห็นเวลาที่ถูกเข้ารหัสอยู่ในค่าแรกของชุด เพื่อที่คุณจะได้มองเห็นอย่างชัดเจนว่ามีอะไรเปิดเผยออกมาบ้าง เวอร์ชัน 1 ก็พาไทม์สแตมป์ไปด้วยเช่นกัน หากเวลาในการสร้างเป็นสิ่งที่คุณไม่ต้องการเปิดเผย เวอร์ชัน 4 คือเวอร์ชันที่ไม่มีเวลาอยู่เลย

UUID v1 เปิดเผย MAC address ของฉันหรือไม่?

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

ตัวพิมพ์ใหญ่, ไม่มีขีดกลาง, วงเล็บปีกกา และ urn:uuid: ทำให้เกิดการเปลี่ยนแปลงอะไรบ้าง?

เป็นแค่การนำเสนอเท่านั้น — 128 บิตที่อยู่ข้างใต้จะเหมือนกันในทุกรูปแบบ 'ตัวพิมพ์ใหญ่' จะพิมพ์ตัวเลขฐานสิบหกเป็นตัวพิมพ์ใหญ่ 'ไม่มีขีดกลาง' จะให้เวอร์ชันที่มี 32 ตัวอักษรแบบกะทัดรัด 'วงเล็บปีกกา' จะหุ้มค่าไว้ใน { } ตามวิธีที่ Windows และ .NET เขียน GUID และ urn:uuid: จะเพิ่มคำนำหน้าซึ่งทำให้มันกลายเป็น URN อย่างเป็นทางการ urn:uuid: จะปิดตัวเลือกอีกสองอันเมื่อมันถูกเปิดใช้งาน เนื่องจากมาตรฐานกำหนดรูปแบบ URN ไว้เพียงรูปแบบเดียว และเป็นรูปแบบดั้งเดิมที่มีขีดกลาง