מחולל UUID – צור מזהים ייחודיים (v1-v7) אונליין בחינם

מה זה UUID?

UUID (מזהה ייחודי אוניברסלי) הוא מזהה בן 128 סיביות המשמש במערכות מחשב לזיהוי ייחודי של מידע. UUID מתוקנן לפי RFC 4122, ובזכות האנטרופיה העצומה שלו, הוא מבטיח הסתברות אפסית כמעט להתנגשות – כלומר, שני UUIDs שנוצרו באופן עצמאי יהיו כמעט בוודאות ייחודיים.

ל-UUID פורמט סטנדרטי: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, כאשר כל x הוא ספרה הקסדצימלית (0-9, a-f), M מציין את גרסת ה-UUID ו-N מציין את הווריאציה.

גרסאות UUID

UUID v1 (חותמת זמן + כתובת MAC)

UUID v1 מבוסס על חותמת הזמן הנוכחית וערך אקראי (בדפדפן, במקום כתובת MAC). הוא משתמש במרווחי 100 ננו-שניות מה-15 באוקטובר 1582 (לוח השנה הגרגוריאני).

שימושים:

• מצבים בהם נדרש מיון כרונולוגי של UUID
• ניפוי באגים ורישום (UUID מכיל מידע על זמן היצירה)
• מערכות מבוזרות עם סנכרון זמן

דוגמה: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

יתרונות:

• ניתן למיין UUIDs כרונולוגית לפי זמן היצירה
• שימושי לביקורת וניפוי באגים
• מכיל מידע על חותמת זמן

חסרונות:

• סיכון אבטחתי פוטנציאלי – מכיל חותמת זמן
• בדפדפן אינו מכיל כתובת MAC אמיתית (מוחלף בערך אקראי)
• לוקליזציה ירודה של DB (חותמת הזמן נמצאת בביטים הנמוכים)

UUID v3 (גיבוב MD5)

UUID v3 נוצר באמצעות גיבוב MD5 של מרחב שמות UUID ושם. דטרמיניסטי – אותו מרחב שמות + שם תמיד ייצורו את אותו ה-UUID.

שימושים:

• המרת כתובות URL, שמות DNS או מזהים אחרים ל-UUID
• מצבים בהם נדרש UUID שניתן לשחזר
• מיפוי בין מערכות זיהוי שונות

דוגמה: a3bb189e-8bf9-3888-9912-ace4e6543002

יתרונות:

• דטרמיניסטי (אותה קלט = אותה פלט)
• אידיאלי להמרת מזהים ידועים
• אין התנגשות עבור קלטים שונים

חסרונות:

• MD5 הוא אלגוריתם מיושן (העדף v5)
• דורש מרחב שמות ושם
• לא ניתן לשחזר את הקלט המקורי

UUID v4 (אקראי) - מומלץ

גרסת ה-UUID הנפוצה ביותר. UUID v4 נוצר באופן אקראי לחלוטין באמצעות מחולל מספרים אקראיים מאובטח קריפטוגרפית (crypto.getRandomValues()).

שימושים:

• מפתחות ראשיים של מסדי נתונים
• מזהי סשן (session IDs)
• שמות קבצים ייחודיים
• אסימוני API
• מטרות כלליות בהן נדרש מזהה ייחודי מובטח

דוגמה: f47ac10b-58cc-4372-a567-0e02b2c3d479

יתרונות:

• אנטרופיה ואבטחה מקסימלית
• אין תלות בזמן או בפרמטרים מערכתיים
• יישום פשוט ביותר

הסתברות להתנגשות: בעת יצירת מיליארד UUIDs בשנייה למשך 100 שנה, הסיכוי להתנגשות הוא כ-0.00000006%.

UUID v5 (גיבוב SHA-1)

UUID v5 זהה ל-v3, אך משתמש ב-SHA-1 במקום MD5. חלופה מודרנית ובטוחה יותר ל-v3.

שימושים:

• כמו v3, אך עם אבטחה טובה יותר
• מועדף על פני v3 עבור פרויקטים חדשים
• יצירת UUID מכתובות URL, שמות DNS, OID, X.500 DN

דוגמה: 886313e1-3b8a-5372-9b90-0c9aee199e5d

יתרונות:

• דטרמיניסטי
• SHA-1 חזק יותר מ-MD5
• מתאים למיפוי בין מערכות

חסרונות:

• SHA-1 נחשב גם הוא למיושן (אך עדיין בטוח יותר מ-MD5)
• דורש מרחב שמות ושם

UUID v6 (חותמת זמן מסודרת)

UUID v6 היא גרסה משופרת של v1 עם ביטי זמן מסודרים מחדש לאינדוקס DB טוב יותר. עוצב כדי לפתור בעיות לוקליזציה במסדי נתונים.

שימושים:

• מפתחות ראשיים של מסדי נתונים עם מיון לפי זמן
• מערכות הדורשות גם מיון כרונולוגי וגם ביצועי DB
• חלופה מודרנית יותר ל-v1

דוגמה: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

יתרונות:

• לוקליזציה טובה יותר של DB מאשר v1 (חותמת זמן בביטים הגבוהים)
• מיון כרונולוגי
• תואם לתקן UUID

חסרונות:

• פחות בשימוש מ-v1/v4
• עדיין מכיל מידע על זמן (סיכון אבטחתי)

UUID v7 (חותמת זמן יוניקס)

UUID v7 משתמש בחותמת זמן יוניקס (אלפיות שנייה מ-1970) + ביטים אקראיים. גרסת ה-UUID החדשה ביותר עם לוקליזציה DB הטובה ביותר.

שימושים:

• מפתחות ראשיים מודרניים של מסדי נתונים
• מערכות הדורשות ביצועים + מיון לפי זמן
• החלפה ל-v1/v6 בפרויקטים חדשים

דוגמה: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

יתרונות:

• לוקליזציה DB הטובה ביותר מבין כל הגרסאות
• חותמת זמן יוניקס היא סטנדרטית
• משלב יתרונות של אקראיות ומיון לפי זמן

חסרונות:

• מפרט חדש יחסית (RFC 4122bis)
• נתמך פחות במערכות מורשת (legacy)

באיזו גרסת UUID להשתמש?

מדריך החלטה

האם אתה זקוק לאבטחה ואקראיות מרביות? ← השתמש ב-UUID v4 (הבחירה הנפוצה ביותר)

האם אתה זקוק למיון לפי זמן וביצועי DB? ← השתמש ב-UUID v7 (מודרני) או UUID v6 (סטנדרטי)

האם אתה זקוק ל-UUID שניתן לשחזר ממזהים קיימים? ← השתמש ב-UUID v5 (SHA-1) או UUID v3 (MD5, מורשת)

האם אתה זקוק לחותמת זמן ולתיעוד ביקורת (audit trail)? ← השתמש ב-UUID v1 (מורשת, ביצועי DB גרועים יותר)

מסדי נתונים

לפרויקטים חדשים: UUID v7 או v4

• v7 אידיאלי למיון לפי זמן + ביצועים
• v4 לאקראיות מרבית ללא מידע על זמן

למערכות מורשת (legacy): UUID v1 או v6

• ל-v6 יש לוקליזציה DB טובה יותר מאשר v1
• v1 נתמך באופן נרחב

יתרונות UUID כמפתח ראשי:

• ייחודיות גלובלית – ניתן לחבר נתונים ממסדי נתונים שונים ללא התנגשות
• אבטחה – בניגוד למזהים סדרתיים (1, 2, 3…) לא ניתן לנחש ערכים עתידיים
• מערכות מבוזרות – ניתן ליצור UUIDs באופן עצמאי במספר שרתים ללא צורך בתיאום
• מיזוג מסדי נתונים – בעת מיזוג שני מסדי נתונים לא נוצרות התנגשויות

חסרונות:

• גודל גדול יותר (16 בתים לעומת 4-8 בתים למספר שלם)
• אינדוקס איטי יותר בחלק ממסדי הנתונים (השתמש ב-v6/v7 לביצועים טובים יותר)
• פחות קריא לבני אדם

API ושירותי אינטרנט

• REST API – מזהים ייחודיים למשאבים (resources)
• GraphQL – מזהים גלובליים לצמתים (nodes)
• Webhooky – מעקב אחר בקשות ותגובות
• אסימונים – מזהי סשן (Session IDs), אסימוני ריענון (refresh tokens)

קבצים ואחסון

• שמות קבצים – מניעת התנגשויות בעת העלאה
• S3/אחסון ענן – נתיבים ייחודיים לאובייקטים
• מפתחות מטמון – מזהים במערכות מטמון

יישומי Frontend

• רכיבי React/Vue – מפתחות ייחודיים לרשימות
• מזהים זמניים – מזהים לפני שמירה במסד הנתונים
• אחסון מקומי – מפתחות לנתונים מאוחסנים
• יישומי Offline-first – יצירת מזהים ללא חיבור לשרת

תכונות מתקדמות של המחולל

יצירת UUID עם זמן מותאם אישית

עבור גרסאות מבוססות זמן (v1, v6, v7), ניתן לבחור כל חותמת זמן באמצעות בורר תאריך ושעה. זה שימושי עבור:

בדיקות:

• סימולציה של UUIDs שנוצרו בעבר
• בדיקת מיון לפי זמן במסדי נתונים
• שחזור UUIDs לניפוי באגים

העברת נתונים:

• יצירת UUIDs עם חותמות זמן היסטוריות
• מילוי חוזר של נתונים עם ערכי חותמת זמן נכונים
• ייבוא נתונים מתקופות זמן שונות

ביקורת ותאימות:

• שחזור UUIDs לפי זמן יצירת הרשומה
• יצירה רטרואקטיבית של מזהים

דוגמה לשימוש:

1. בחר גרסה v1, v6 או v7
2. הגדר תאריך ושעה באמצעות בורר התאריך והשעה
3. צור UUID עם חותמת הזמן המותאמת אישית שלך

UUID מבוסס גיבוב (v3, v5)

עבור UUID דטרמיניסטי, ניתן להשתמש בגרסאות v3 (MD5) או v5 (SHA-1):

כיצד להשתמש:

1. בחר מרחב שמות לפי סוג המזהה שלך
2. הזן את השם/הערך
3. צור UUID

דוגמאות:

תכונות חשובות:

• ✅ דטרמיניסטי: אותה קלט = תמיד אותו UUID
• ✅ ניתן לשחזור: ניתן ליצור מחדש את ה-UUID בכל עת
• ✅ עקבי: אותו UUID על פני מערכות שונות
• ❌ לא ניתן לפענוח: לא ניתן לשחזר את השם המקורי מה-UUID
• ℹ️ UUID יחיד: עבור v3/v5 נוצר תמיד רק UUID אחד (אותה קלט = אותה פלט)

שימוש מעשי:

// דוגמה: המרת URL ל-UUID v5
Namespace: URL
Název: https://example.com/api/users/123
Výsledek: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// אותו קלט = תמיד אותו UUID
Namespace: DNS
Název: google.com
Výsledek: vždy stejné UUID pro google.com

כיצד להשתמש ב-UUID בבטחה?

אבטחה קריפטוגרפית

המחולל שלנו משתמש ב-crypto.getRandomValues(), שהוא מחולל מספרים אקראיים מאובטח קריפטוגרפית. בניגוד ל-Math.random(), שהוא צפוי ואינו מתאים למטרות אבטחה, crypto.getRandomValues() מספק אנטרופיה אמיתית המתאימה ל:

• יצירת אסימוני אבטחה
• מזהי סשן (Session IDs)
• מפתחות API
• יישומים קריפטוגרפיים

השוואת גרסאות UUID

UUID מול מזהים אחרים

הטמעה בשפות שונות

JavaScript/TypeScript

// UUID v4 - הדרך הקלה ביותר (דפדפנים מודרניים)
const uuid = crypto.randomUUID();

// UUID v4 - הטמעה ידנית
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - מומלץ למסדי נתונים
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}

Python

import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Output: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())

Java

import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();

PHP

// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

C#

using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();

שיטות עבודה מומלצות

שמירת UUID במסד נתונים

PostgreSQL:

CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

MySQL 8.0+:

CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

— טיפ: ב-MySQL, שמור UUID כ-BINARY(16) במקום CHAR(36) לחיסכון במקום ואינדוקס מהיר יותר.

אימות UUID

function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}

המרת UUID

// הסרת מקפים
const compact = uuid.replace(/-/g, '');

// הוספת מקפים בחזרה
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}

פתרון בעיות (Troubleshooting)

UUID v3/v5 אינו פועל

בעיה: לאחר בחירת v3 או v5, שום דבר לא נוצר

פתרון:

1. ✅ ודא שמילאת את השדה “שם” - הוא חובה!
2. ✅ בחר את מרחב השמות הנכון לפי סוג הקלט שלך
3. ✅ דוגמאות לקלטים תקפים:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • כל טקסט: moje-aplikace-v1

טיפ: נסה תחילה ערך פשוט כמו test ומרחב שמות DNS.

ל-UUID מבוסס זמן (v1, v6, v7) יש זמן מוזר

בעיה: ל-UUID שנוצר יש חותמת זמן בלתי צפויה

פתרון:

1. ✅ בדוק את בורר התאריך והשעה - האם הזמן מוגדר נכון?
2. ✅ בורר התאריך והשעה משתמש באזור הזמן המקומי שלך
3. ✅ השאר את בורר התאריך והשעה ריק עבור השעה הנוכחית

לא ניתן להעתיק את ה-UUID

בעיה: כפתור “העתק הכל” אינו פועל

פתרון:

1. ✅ ודא שיצרת UUIDs (שאינם ריקים)
2. ✅ דפדפנים מסוימים דורשים HTTPS עבור Clipboard API
3. ✅ לחלופין, בחר את הטקסט בשדה הטקסט והעתק ידנית (Ctrl+C)

שאלות נפוצות (FAQ)

חלופות ל-UUID

ULID (מזהה ייחודי אוניברסלי שניתן למיון לקסיקוגרפית)

• מזהה 128 סיביות (כמו UUID)
• ניתן למיון לקסיקוגרפית לפי זמן יצירה
• ייצוג קומפקטי יותר (26 תווים במקום 36)
• קידוד base32 ללא תלות באותיות רישיות/קטנות

דוגמה: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• גודל קטן יותר מ-UUID (21 תווים כברירת מחדל)
• ידידותי ל-URL (ללא תווים מיוחדים)
• יצירה מהירה יותר
• אורך ואלפבית הניתנים להגדרה

דוגמה: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (טוויטר)

• מזהה 64 סיביות (קטן מ-UUID)
• ניתן למיון לפי זמן
• מכיל מזהה עובד (worker ID) ומספר סידורי
• דורש תצורה מרכזית

דוגמה: 1234567890123456789

ביצועים ואופטימיזציה

מהירות יצירה

המחולל שלנו יכול ליצור:

• 1 UUID: < 1 אלפית שנייה
• 100 UUIDs: ~10-20 אלפיות שנייה
• 1000 UUIDs: ~100-200 אלפיות שנייה

טיפים לביצועים

1. יצירת אצווה (Batch) – אם אתה זקוק ל-UUIDs רבים, צור אותם בבת אחת במקום אחד אחד
2. אחסון ב-DB – אינדקס עמודות UUID לחיפוש מהיר
3. דחיסה – שמור UUID בצורה בינארית (16 בתים) במקום מחרוזת (36 בתים)
4. Caching – במקרים מסוימים ניתן ליצור מראש UUIDs ולשמור אותם במטמון

למפתחים

מבנה UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 סיביות של נתונים אקראיים (node)
|        |    |    └────── 16 סיביות של נתונים אקראיים עם וריאציה (clock_seq)
|        |    └─────────── 12 סיביות של נתונים אקראיים + 4 סיביות של גרסה (time_hi_and_version)
|        └──────────────── 16 סיביות של נתונים אקראיים (time_mid)
└───────────────────────── 32 סיביות של נתונים אקראיים (time_low)

• גרסה (4 סיביות): תמיד 0100 (בינארי) = 4 (הקסדצימלי)
• וריאציה (2-3 סיביות): תמיד 10 (בינארי) עבור RFC 4122

בדיקת UUID

// בדיקת Jest
describe('UUID Generator', () => {
  test('generates valid UUID v4', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('generates unique UUIDs', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

היבטי אבטחה

מה לא לעשות עם UUID

❌ אל תשתמש ב-UUID v1 עבור יישומים רגישים – הוא מכיל חותמת זמן, מה שיכול להוות סיכון אבטחתי

❌ אל תשתמש ב-Math.random() ליצירת UUID – הוא אינו מאובטח קריפטוגרפית

❌ אל תסתמך על UUID לאימות (authorization) – ניתן לנחש UUID (גם אם בהסתברות קטנה ביותר)

❌ אל תשמור UUID בקובצי Cookie ללא הצפנה – השתמש בקובצי Cookie חתומים או JWT

מה כן לעשות

✅ השתמש ב-UUID v4 ברוב המקרים – אנטרופיה ואבטחה הגבוהות ביותר

✅ שלב UUID עם אמצעי אבטחה נוספים – עבור ניהול סשנים, השתמש ב-HTTPS, קובצי Cookie מסוג HttpOnly, ותאריך תפוגה קצר

✅ אמת UUID בשרת – בדוק תמיד את פורמט וגרסת ה-UUID

✅ השתמש במקורות אקראיות מאובטחים קריפטוגרפית – crypto.getRandomValues() בדפדפן, /dev/urandom בלינוקס

עובדות מעניינות

• מספר ה-UUID v4 האפשריים: 2^122 ≈ 5.3 × 10^36 (340 undecilion)
• התנגשות נדרשת: כדי להגיע לסיכוי של 50% להתנגשות, עליך ליצור 2.71 × 10^18 UUIDs (2.71 קווינטיליון)
• גודל כל ה-UUIDs האפשריים: אם נשמור כל UUID כ-16 בתים, כל המרחב יתפוס 85 זטאבייט (85 מיליארד טרה-בייט)
• מקור: UUID תוקנן כחלק מ-DCE (Distributed Computing Environment) בשנת 1990