UUID Code Examples

<?php
require 'vendor/autoload.php';

use Ramsey\Uuid\Uuid;

// Generate UUID v4 (random)
$uuid4 = Uuid::uuid4();
echo $uuid4->toString();  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

// Generate UUID v7 (timestamp-ordered, recommended for databases)
$uuid7 = Uuid::uuid7();
echo $uuid7->toString();  // Example: 018e5e1a-7b2c-7d4f-9a3e-8c7f6e5d4c3b

// Generate UUID v5 (namespaced)
$namespace = Uuid::NAMESPACE_DNS;
$name = 'example.com';
$uuid5 = Uuid::uuid5($namespace, $name);
echo $uuid5->toString();  // Always same: cfbff0d1-9375-5685-968c-48ce8b15ae17

// Parse and validate UUID
$uuidString = '3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f';
if (Uuid::isValid($uuidString)) {
    $uuid = Uuid::fromString($uuidString);
    echo $uuid->getVersion();  // Outputs: 4
}

// Modern browsers and Node.js 15.6+ (native API)
const uuid = crypto.randomUUID();
console.log(uuid);  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

// Using uuid npm package (install: npm install uuid)
import { v4 as uuidv4, v5 as uuidv5, v7 as uuidv7 } from 'uuid';

// UUID v4 (random)
const uuid4 = uuidv4();
console.log(uuid4);  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

// UUID v7 (timestamp-ordered)
const uuid7 = uuidv7();
console.log(uuid7);  // Example: 018e5e1a-7b2c-7d4f-9a3e-8c7f6e5d4c3b

// UUID v5 (namespaced)
const NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; // DNS namespace
const name = 'example.com';
const uuid5 = uuidv5(name, NAMESPACE);
console.log(uuid5);  // Always same: cfbff0d1-9375-5685-968c-48ce8b15ae17

// Validate UUID
import { validate, version } from 'uuid';
if (validate(uuid4)) {
    console.log('Version:', version(uuid4));  // Outputs: 4
}

import uuid

# UUID v4 (random)
uuid4 = uuid.uuid4()
print(uuid4)  # Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f
print(str(uuid4))  # String representation

# UUID v1 (timestamp + MAC address)
uuid1 = uuid.uuid1()
print(uuid1)  # Example: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

# UUID v5 (namespaced)
namespace = uuid.NAMESPACE_DNS
name = 'example.com'
uuid5 = uuid.uuid5(namespace, name)
print(uuid5)  # Always same: cfbff0d1-9375-5685-968c-48ce8b15ae17

# Parse and validate UUID
uuid_string = '3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f'
parsed_uuid = uuid.UUID(uuid_string)
print(parsed_uuid.version)  # Outputs: 4
print(parsed_uuid.hex)  # Hex without dashes: 3d6f9e647d8a4c3e8f2b1a4e5c6d7e8f

# Generate multiple UUIDs
uuids = [str(uuid.uuid4()) for _ in range(5)]
print(uuids)

import java.util.UUID;
import java.nio.charset.StandardCharsets;
import java.nio.ByteBuffer;

public class UuidExample {
    public static void main(String[] args) {
        // UUID v4 (random)
        UUID uuid4 = UUID.randomUUID();
        System.out.println(uuid4);  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

        // UUID v3 (namespaced with MD5)
        UUID uuid3 = generateUuidV3("example.com");
        System.out.println(uuid3);  // Always same: 9073926b-929f-31c2-abc9-fad77ae3e8eb

        // Parse UUID from string
        String uuidString = "3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f";
        UUID parsed = UUID.fromString(uuidString);
        System.out.println(parsed.version());  // Outputs: 4

        // Generate multiple UUIDs
        for (int i = 0; i < 5; i++) {
            System.out.println(UUID.randomUUID());
        }
    }

    // Helper method for UUID v3 generation
    private static UUID generateUuidV3(String name) {
        // A v3 UUID is the MD5 of the namespace UUID's 16 bytes followed by the name
        UUID namespaceDns = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8");
        byte[] nameBytes = name.getBytes(StandardCharsets.UTF_8);
        ByteBuffer buffer = ByteBuffer.allocate(16 + nameBytes.length);
        buffer.putLong(namespaceDns.getMostSignificantBits());
        buffer.putLong(namespaceDns.getLeastSignificantBits());
        buffer.put(nameBytes);
        // nameUUIDFromBytes applies MD5 and sets the version (3) and variant bits itself
        return UUID.nameUUIDFromBytes(buffer.array());
    }
}

using System;
using System.Collections.Generic;

class UuidExample
{
    static void Main()
    {
        // Generate new GUID (UUID v4)
        Guid guid = Guid.NewGuid();
        Console.WriteLine(guid);  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

        // Format variations
        Console.WriteLine(guid.ToString());           // Default: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f
        Console.WriteLine(guid.ToString("N"));        // No dashes: 3d6f9e647d8a4c3e8f2b1a4e5c6d7e8f
        Console.WriteLine(guid.ToString("D"));        // With dashes (default)
        Console.WriteLine(guid.ToString("B"));        // Braces: {3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f}
        Console.WriteLine(guid.ToString("P"));        // Parentheses: (3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f)

        // Parse GUID from string
        string guidString = "3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f";
        if (Guid.TryParse(guidString, out Guid parsed))
        {
            Console.WriteLine($"Parsed: {parsed}");
        }

        // Generate multiple GUIDs
        var guids = new List<Guid>();
        for (int i = 0; i < 5; i++)
        {
            guids.Add(Guid.NewGuid());
        }

        // Empty GUID
        Guid empty = Guid.Empty;  // 00000000-0000-0000-0000-000000000000
        Console.WriteLine($"Empty: {empty}");
    }
}

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <iostream>
#include <string>

int main() {
    // UUID v4 (random) using Boost
    boost::uuids::random_generator gen;
    boost::uuids::uuid uuid = gen();

    std::cout << uuid << std::endl;  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

    // Convert to string
    std::string uuid_str = boost::uuids::to_string(uuid);
    std::cout << uuid_str << std::endl;

    // Generate multiple UUIDs
    for (int i = 0; i < 5; ++i) {
        std::cout << gen() << std::endl;
    }

    // UUID v5 (namespaced)
    boost::uuids::name_generator_sha1 name_gen(boost::uuids::ns::dns());
    boost::uuids::uuid uuid5 = name_gen("example.com");
    std::cout << uuid5 << std::endl;  // Always same

    // Parse UUID from string
    std::string uuid_string = "3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f";
    boost::uuids::string_generator string_gen;
    boost::uuids::uuid parsed = string_gen(uuid_string);
    std::cout << parsed << std::endl;

    return 0;
}

// Compile: g++ -std=c++11 uuid_example.cpp

require 'securerandom'

# UUID v4 (random)
uuid = SecureRandom.uuid
puts uuid  # Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

# Generate multiple UUIDs
5.times do
  puts SecureRandom.uuid
end

# Using UUIDTools gem for more features (gem install uuidtools)
require 'uuidtools'

# UUID v4
uuid4 = UUIDTools::UUID.random_create
puts uuid4.to_s  # Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

# UUID v5 (namespaced)
namespace = UUIDTools::UUID_DNS_NAMESPACE
name = 'example.com'
uuid5 = UUIDTools::UUID.sha1_create(namespace, name)
puts uuid5.to_s  # Always same: cfbff0d1-9375-5685-968c-48ce8b15ae17

# Parse UUID from string
uuid_string = '3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f'
parsed = UUIDTools::UUID.parse(uuid_string)
puts parsed.valid?  # Outputs: true

# In Rails models (ActiveRecord)
# class User < ApplicationRecord
#   before_create :generate_uuid
#
#   private
#   def generate_uuid
#     self.id = SecureRandom.uuid
#   end
# end

package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    // UUID v4 (random)
    uuid4 := uuid.New()
    fmt.Println(uuid4.String())  // Example: 3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f

    // UUID v7 (timestamp-ordered, best for databases)
    uuid7, err := uuid.NewV7()
    if err != nil {
        panic(err)
    }
    fmt.Println(uuid7.String())  // Example: 018e5e1a-7b2c-7d4f-9a3e-8c7f6e5d4c3b

    // UUID v5 (namespaced)
    namespace := uuid.NameSpaceDNS
    name := "example.com"
    uuid5 := uuid.NewSHA1(namespace, []byte(name))
    fmt.Println(uuid5.String())  // Always same: cfbff0d1-9375-5685-968c-48ce8b15ae17

    // Parse UUID from string
    uuidString := "3d6f9e64-7d8a-4c3e-8f2b-1a4e5c6d7e8f"
    parsed, err := uuid.Parse(uuidString)
    if err != nil {
        fmt.Println("Invalid UUID")
    }
    fmt.Println("Version:", parsed.Version())  // Outputs: 4

    // Generate multiple UUIDs
    for i := 0; i < 5; i++ {
        fmt.Println(uuid.New())
    }

    // Nil UUID
    nilUUID := uuid.Nil
    fmt.Println(nilUUID)  // 00000000-0000-0000-0000-000000000000
}

// Install: go get github.com/google/uuid