มีวิธีการสร้าง UUID ด้วยภาษา go

ฉันมีรหัสที่มีลักษณะดังนี้:

u := make([]byte, 16)
_, err := rand.Read(u)
if err != nil {
    return
}

u[8] = (u[8] | 0x80) & 0xBF // what does this do?
u[6] = (u[6] | 0x40) & 0x4F // what does this do?

return hex.EncodeToString(u)

มันส่งคืนสตริงที่มีความยาว 32 แต่ฉันไม่คิดว่ามันเป็น UUID ที่ถูกต้อง หากเป็น UUID จริงเหตุใดจึงเป็น UUID และอะไรคือวัตถุประสงค์ของรหัสที่แก้ไขค่าของu[8]และu[6].

มีวิธีที่ดีกว่าในการสร้าง UUID หรือไม่?

u[8] = (u[8] | 0x80) & 0xBF // what's the purpose ?
u[6] = (u[6] | 0x40) & 0x4F // what's the purpose ?

เส้นเหล่านี้จะยึดค่าของไบต์ 6 และ 8 ไว้ที่ช่วงเฉพาะ rand.Readส่งคืนไบต์แบบสุ่มในช่วง0-255ซึ่งไม่ใช่ค่าที่ถูกต้องทั้งหมดสำหรับ UUID เท่าที่ฉันบอกได้ควรทำสิ่งนี้สำหรับค่าทั้งหมดในชิ้นส่วน

หากคุณใช้ linux คุณสามารถโทร/usr/bin/uuidgen.

package main

import (
    "fmt"
    "log"
    "os/exec"
)

func main() {
    out, err := exec.Command("uuidgen").Output()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s", out)
}

ซึ่งให้ผลตอบแทน:

$ go run uuid.go 
dc9076e9-2fda-4019-bd2c-900a8284b9c4

คุณสามารถสร้าง UUID โดยใช้ไลบรารีgo-uuid สามารถติดตั้งได้ด้วย:

go get github.com/nu7hatch/gouuid

คุณสามารถสร้าง UUID แบบสุ่ม (เวอร์ชัน 4) ด้วย:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

UUIDประเภทที่ส่งคืนคืออาร์เรย์ 16 ไบต์ดังนั้นคุณจึงสามารถดึงค่าไบนารีได้อย่างง่ายดาย นอกจากนี้ยังมีการแสดงสตริงฐานสิบหกมาตรฐานด้วยString()วิธีการ

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

go-uuidห้องสมุดไม่ RFC4122 สอดคล้อง ตั้งค่าบิตตัวแปรไม่ถูกต้อง มีความพยายามหลายครั้งโดยสมาชิกชุมชนในการแก้ไขปัญหานี้ แต่ไม่ยอมรับคำขอดึงสำหรับการแก้ไข

คุณสามารถสร้าง UUID โดยใช้ไลบรารี Go uuid ที่ฉันเขียนใหม่ตามgo-uuidไลบรารี มีการแก้ไขและปรับปรุงหลายประการ สามารถติดตั้งได้ด้วย:

go get github.com/twinj/uuid

คุณสามารถสร้าง UUID แบบสุ่ม (เวอร์ชัน 4) ด้วย:

import "github.com/twinj/uuid"

u := uuid.NewV4()

ประเภท UUID ที่ส่งคืนคืออินเทอร์เฟซและประเภทพื้นฐานคืออาร์เรย์

ไลบรารียังสร้าง v1 UUID และสร้าง v3 และ 5 UUIDs อย่างถูกต้อง มีวิธีการใหม่ ๆ มากมายที่จะช่วยในการพิมพ์และการจัดรูปแบบและวิธีการทั่วไปใหม่ ๆ ในการสร้าง UUID โดยอิงจากข้อมูลที่มีอยู่

"crypto / rand" คือ pkg ข้ามแพลตฟอร์มสำหรับการกำเนิดไบต์แบบสุ่ม

package main

import (
    "crypto/rand"
    "fmt"
)

// Note - NOT RFC4122 compliant
func pseudo_uuid() (uuid string) {

    b := make([]byte, 16)
    _, err := rand.Read(b)
    if err != nil {
        fmt.Println("Error: ", err)
        return
    }

    uuid = fmt.Sprintf("%X-%X-%X-%X-%X", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

    return
}

มีการนำไปใช้อย่างเป็นทางการโดย Google: https://github.com/google/uuid

การสร้าง UUID เวอร์ชัน 4 จะทำงานดังนี้:

package main

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

func main() {
    id := uuid.New()
    fmt.Println(id.String())
}

ลองดูที่นี่: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuidจะเปลี่ยนสำหรับริ / go.uuidซึ่งเป็นแพคเกจ UUID ติดดาวมากที่สุดสำหรับการไป รองรับ UUID เวอร์ชัน 1-5 และเป็นไปตามข้อกำหนด RFC 4122 และ DCE 1.1

import "github.com/gofrs/uuid"

// Create a Version 4 UUID, panicking on error
u := uuid.Must(uuid.NewV4())

จากโพสต์ของ Russ Cox :

ไม่มีห้องสมุดอย่างเป็นทางการ การละเว้นการตรวจสอบข้อผิดพลาดดูเหมือนว่าจะใช้ได้ดี:

f, _ := os.Open("/dev/urandom")
b := make([]byte, 16)
f.Read(b)
f.Close()
uuid := fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])

หมายเหตุ: ในเวอร์ชันดั้งเดิมก่อน Go 1 เวอร์ชันแรกคือ:

f, _ := os.Open("/dev/urandom", os.O_RDONLY, 0)

ที่นี่รวบรวมและดำเนินการ/dev/urandomส่งกลับเฉพาะศูนย์ทั้งหมดในสนามเด็กเล่น ควรทำงานได้ดีในพื้นที่

ในเธรดเดียวกันมีวิธีการ / การอ้างอิง / แพ็คเกจอื่น ๆ ที่พบ

ในฐานะที่เป็นส่วนหนึ่งของข้อมูลจำเพาะ uuid หากคุณสร้าง uuid จากการสุ่มต้องมี "4" เป็นอักขระที่ 13 และ "8", "9", "a" หรือ "b" ในลำดับที่ 17 ( แหล่งที่มา )

// this makes sure that the 13th character is "4"
u[6] = (u[6] | 0x40) & 0x4F
// this makes sure that the 17th is "8", "9", "a", or "b"
u[8] = (u[8] | 0x80) & 0xBF 

gorandแพคเกจมีวิธี UUID ที่ส่งกลับรุ่นที่ 4 (ที่สร้างแบบสุ่ม) UUID ในการเป็นตัวแทนสตริงที่ยอมรับ ( "XXXXXXXXXXXX-XXXXXXXX-XXXXXXXXXXXX") และมัน RFC 4122 ที่สอดคล้องกับ

นอกจากนี้ยังใช้แพ็คเกจการเข้ารหัสลับ / แรนด์เพื่อให้แน่ใจว่าการสร้าง UUID ที่ปลอดภัยที่สุดในทุกแพลตฟอร์มที่ Go รองรับ

import "github.com/leonelquinteros/gorand"

func main() {
    uuid, err := gorand.UUID()
    if err != nil {
        panic(err.Error())
    }

    println(uuid)
} 

บน Linux คุณสามารถอ่านได้จาก/proc/sys/kernel/random/uuid:

package main

import "io/ioutil"
import "fmt"

func main() {
    u, _ := ioutil.ReadFile("/proc/sys/kernel/random/uuid")
    fmt.Println(string(u))
}

ไม่มีการพึ่งพาภายนอก!

$ go run uuid.go 
3ee995e3-0c96-4e30-ac1e-f7f04fd03e44

สำหรับ Windows ฉันเพิ่งทำสิ่งนี้:

// +build windows

package main

import (
    "syscall"
    "unsafe"
)

var (
    modrpcrt4 = syscall.NewLazyDLL("rpcrt4.dll")
    procUuidCreate = modrpcrt4.NewProc("UuidCreate")
)

const (
    RPC_S_OK = 0
)

func NewUuid() ([]byte, error) {
    var uuid [16]byte
    rc, _, e := syscall.Syscall(procUuidCreate.Addr(), 1,
             uintptr(unsafe.Pointer(&uuid[0])), 0, 0)
    if int(rc) != RPC_S_OK {
        if e != 0 {
            return nil, error(e)
        } else {
            return nil, syscall.EINVAL
        }
    }
    return uuid[:], nil
}

ไลบรารีนี้เป็นมาตรฐานสำหรับการสร้าง uuid และการแยกวิเคราะห์:

https://github.com/pborman/uuid