Existe-t-il une méthode pour générer un UUID avec le langage Go ?

Question

J'ai un code qui ressemble à ceci :

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)

Il renvoie une chaîne de caractères d'une longueur de 32, mais je ne pense pas qu'il s'agisse d'un UUID valide. S'il s'agit d'un vrai UUID, pourquoi est-ce un UUID, et à quoi sert le code qui modifie la valeur de u[8] y u[6] ?

Existe-t-il une meilleure façon de générer des UUID ?

Answer 1

Vous pouvez générer des UUID à l'aide de la fonction go-uuid bibliothèque. Elle peut être installée avec :

go get github.com/nu7hatch/gouuid

Vous pouvez générer des UUIDs aléatoires (version 4) avec :

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

Les personnes renvoyées UUID est un tableau de 16 octets, ce qui permet de récupérer facilement la valeur binaire. Il fournit également la représentation standard de la chaîne hexadécimale par l'intermédiaire de sa fonction String() méthode.

Le code que vous avez semble également générer un UUID version 4 valide : la manipulation bit à bit que vous effectuez à la fin définit correctement les champs version et variante de l'UUID. l'identifier comme étant la version 4 . Cela permet de distinguer les UUID aléatoires de ceux générés par d'autres algorithmes (par exemple, les UUID de la version 1 basés sur votre adresse MAC et l'heure).

Answer 2

En go-uuid n'est pas conforme à la norme RFC4122. Les bits de variante ne sont pas définis correctement. Les membres de la communauté ont tenté à plusieurs reprises de corriger ce problème, mais les pull requests pour la correction ne sont pas acceptées.

Vous pouvez générer des UUID en utilisant la bibliothèque Go uuid que j'ai réécrite en me basant sur la bibliothèque go-uuid bibliothèque. Plusieurs corrections et améliorations ont été apportées. Il peut être installé avec :

go get github.com/twinj/uuid

Vous pouvez générer des UUIDs aléatoires (version 4) avec :

import "github.com/twinj/uuid"

u := uuid.NewV4()

Le type d'UUID renvoyé est une interface et le type sous-jacent est un tableau.

La bibliothèque génère également les UUIDs v1 et génère correctement les UUIDs v3 et 5. Il existe plusieurs nouvelles méthodes pour faciliter l'impression et le formatage, ainsi que de nouvelles méthodes générales pour créer des UUID à partir de données existantes.

Answer 3

"crypto/rand" est un pkg multiplateforme pour la génération d'octets aléatoires.

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
}

Answer 4

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

Ces lignes limitent les valeurs des octets 6 et 8 à une plage spécifique. rand.Read renvoie des octets aléatoires dans l'intervalle 0-255 qui ne sont pas toutes des valeurs valides pour un UUID. D'après ce que j'ai pu constater, cela devrait être fait pour toutes les valeurs de la tranche.

Si vous êtes sous linux, vous pouvez également appeler /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)
}

Ce qui donne :

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

Answer 5

Extrait de l'article de Russ Cox poste :

Il n'existe pas de bibliothèque officielle. Ignorer la vérification des erreurs, cela semble fonctionner correctement :

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

Note : Dans la version originale, antérieure à Go 1, la première ligne était :

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

Ici qu'il compile et exécute, seulement /dev/urandom renvoie tous les zéros du terrain de jeu. Cela devrait fonctionner correctement au niveau local.

Dans le même fil de discussion, d'autres méthodes/références/paquets ont été trouvés.