Gibt es eine Methode zum Generieren einer UUID mit go-Sprache?

Ich habe Code, der so aussieht:

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)

Es gibt einen String mit einer Länge von 32 zurück, aber ich denke nicht, dass es eine gültige UUID ist. Wenn es eine echte UUID ist, warum ist es ein UUID, und was ist der Zweck des Codes, ändert sich der Wert von u[8]und u[6].

Gibt es eine bessere Möglichkeit, UUIDs zu generieren?

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

Diese Zeilen klemmen die Werte von Byte 6 und 8 auf einen bestimmten Bereich. rand.ReadGibt zufällige Bytes im Bereich zurück 0-255, die nicht alle gültigen Werte für eine UUID sind. Soweit ich das beurteilen kann, sollte dies jedoch für alle Werte im Slice erfolgen.

Wenn Sie unter Linux arbeiten, können Sie alternativ anrufen /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)
}

Welche Ausbeuten:

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

Sie können UUIDs mithilfe der go-uuid- Bibliothek generieren . Dies kann installiert werden mit:

go get github.com/nu7hatch/gouuid

Sie können zufällige (Version 4) UUIDs generieren mit:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

Der zurückgegebene UUIDTyp ist ein 16-Byte-Array, sodass Sie den Binärwert einfach abrufen können. Über seine String()Methode wird auch die Standarddarstellung für Hex-Zeichenfolgen bereitgestellt.

Der Code, den Sie haben, sieht auch so aus, als würde er auch eine gültige UUID der Version 4 generieren: Die bitweise Manipulation, die Sie am Ende ausführen, setzt die Versions- und Variantenfelder der UUID, um sie korrekt als Version 4 zu identifizieren . Dies geschieht, um zufällige UUIDs von solchen zu unterscheiden, die über andere Algorithmen generiert wurden (z. B. UUIDs der Version 1 basierend auf Ihrer MAC-Adresse und Zeit).

Die go-uuidBibliothek ist NICHT RFC4122-kompatibel. Die Variantenbits sind nicht richtig gesetzt. Es gab mehrere Versuche von Community-Mitgliedern, dieses Problem zu beheben, aber Pull-Anforderungen für das Problem werden nicht akzeptiert.

Sie können UUIDs mithilfe der Go-Uuid-Bibliothek generieren, die ich basierend auf der go-uuidBibliothek neu geschrieben habe. Es gibt verschiedene Korrekturen und Verbesserungen. Dies kann installiert werden mit:

go get github.com/twinj/uuid

Sie können zufällige (Version 4) UUIDs generieren mit:

import "github.com/twinj/uuid"

u := uuid.NewV4()

Der zurückgegebene UUID-Typ ist eine Schnittstelle und der zugrunde liegende Typ ist ein Array.

Die Bibliothek generiert auch v1-UUIDs und generiert korrekt v3- und 5-UUIDs. Es gibt verschiedene neue Methoden zum Drucken und Formatieren sowie neue allgemeine Methoden zum Erstellen von UUIDs basierend auf vorhandenen Daten.

"crypto / rand" ist ein plattformübergreifendes Paket für die Erzeugung zufälliger Bytes

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
}

Es gibt eine offizielle Implementierung von Google: https://github.com/google/uuid

Das Generieren einer UUID der Version 4 funktioniert folgendermaßen:

package main

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

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

Probieren Sie es hier aus: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuid ist der Ersatz für satori / go.uuid , das mit den meisten Sternen ausgezeichnete UUID-Paket für Go . Es unterstützt die UUID-Versionen 1-5 und ist RFC 4122- und DCE 1.1-kompatibel.

import "github.com/gofrs/uuid"

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

Aus Russ Cox ' Beitrag :

Es gibt keine offizielle Bibliothek. Wenn Sie die Fehlerprüfung ignorieren, scheint dies gut zu funktionieren:

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:])

Hinweis: In der ursprünglichen Version vor Go 1 lautete die erste Zeile:

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

Hier wird kompiliert und ausgeführt, es werden nur /dev/urandomalle Nullen auf dem Spielplatz zurückgegeben. Sollte vor Ort gut funktionieren.

Im selben Thread wurden einige andere Methoden / Referenzen / Pakete gefunden.

Wenn Sie als Teil der UUID-Spezifikation eine UUID aus einem Zufallsprinzip generieren, muss diese eine "4" als 13. Zeichen und eine "8", "9", "a" oder "b" im 17. ( Quelle ) enthalten.

// 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 

Der Gorand Paket verfügt über eine UUID-Methode, die eine (zufällig generierte) UUID der Version 4 in ihrer kanonischen Zeichenfolgendarstellung ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") zurückgibt und RFC 4122-kompatibel ist.

Außerdem wird das Crypto / Rand-Paket verwendet, um die kryptografisch sicherste Generierung von UUIDs auf allen von Go unterstützten Plattformen sicherzustellen.

import "github.com/leonelquinteros/gorand"

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

    println(uuid)
} 

Unter Linux können Sie lesen von /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))
}

Keine externen Abhängigkeiten!

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

Für Windows habe ich kürzlich Folgendes getan:

// +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
}

Diese Bibliothek ist unser Standard für die Generierung und Analyse von Benutzeroberflächen:

https://github.com/pborman/uuid