Existe um método para gerar um UUID com a linguagem go

Eu tenho um código parecido com este:

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)

Ele retorna uma string com comprimento de 32, mas não acho que seja um UUID válido. Se for um UUID real, por que é um UUID e qual é o propósito do código que modifica o valor de u[8]e u[6].

Existe uma maneira melhor de gerar UUIDs?

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

Essas linhas prendem os valores dos bytes 6 e 8 a um intervalo específico. rand.Readretorna bytes aleatórios no intervalo 0-255, que nem todos são valores válidos para um UUID. Pelo que eu posso dizer, isso deve ser feito para todos os valores na fatia.

Se você estiver no Linux, você pode alternativamente chamar /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)
}

O que produz:

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

Você pode gerar UUIDs usando a biblioteca go-uuid . Isso pode ser instalado com:

go get github.com/nu7hatch/gouuid

Você pode gerar UUIDs aleatórios (versão 4) com:

import "github.com/nu7hatch/gouuid"

...

u, err := uuid.NewV4()

O UUIDtipo retornado é uma matriz de 16 bytes, para que você possa recuperar o valor binário facilmente. Ele também fornece a representação de string hexadecimal padrão por meio de seu String()método.

O código que você tem também parece que gerará um UUID de versão 4 válido: a manipulação bit a bit que você executa no final define os campos de versão e variante do UUID para identificá-lo corretamente como versão 4 . Isso é feito para distinguir UUIDs aleatórios daqueles gerados por outros algoritmos (por exemplo, UUIDs da versão 1 com base em seu endereço MAC e hora).

A go-uuidbiblioteca NÃO é compatível com RFC4122. Os bits variantes não estão definidos corretamente. Houve várias tentativas de membros da comunidade para consertar isso, mas as solicitações pull para a correção não estão sendo aceitas.

Você pode gerar UUIDs usando a biblioteca Go uuid que reescrevi com base na go-uuidbiblioteca. Existem várias correções e melhorias. Isso pode ser instalado com:

go get github.com/twinj/uuid

Você pode gerar UUIDs aleatórios (versão 4) com:

import "github.com/twinj/uuid"

u := uuid.NewV4()

O tipo de UUID retornado é uma interface e o tipo subjacente é uma matriz.

A biblioteca também gera UUIDs v1 e gera corretamente UUIDs v3 e 5. Existem vários novos métodos para ajudar na impressão e formatação e também novos métodos gerais para criar UUIDs com base nos dados existentes.

"crypto / rand" é um pacote multiplataforma para geração aleatória de 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
}

Há uma implementação oficial do Google: https://github.com/google/uuid

Gerar um UUID versão 4 funciona assim:

package main

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

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

Experimente aqui: https://play.golang.org/p/6YPi1djUMj9

gofrs / uuid é o substituto de satori / go.uuid , que é o pacote UUID com mais estrela para Go . Suporta UUID versões 1-5 e é compatível com RFC 4122 e DCE 1.1.

import "github.com/gofrs/uuid"

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

Da postagem de Russ Cox :

Não há biblioteca oficial. Ignorando a verificação de erros, parece que funcionaria bem:

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

Nota: Na versão original, pré Go 1, a primeira linha era:

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

Aqui, ele compila e executa, /dev/urandomretorna apenas todos os zeros no playground. Deve funcionar bem localmente.

No mesmo tópico existem alguns outros métodos / referências / pacotes encontrados.

Como parte da especificação do uuid, se você gerar um uuid aleatoriamente, ele deverá conter um "4" como o 13º caractere e um "8", "9", "a" ou "b" no 17º ( fonte ).

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

O pacote gorand tem um método UUID que retorna um UUID Versão 4 (gerado aleatoriamente) em sua representação de string canônica ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") e é compatível com RFC 4122.

Ele também usa o pacote crypto / rand para garantir a geração mais criptograficamente segura de UUIDs em todas as plataformas suportadas pelo Go.

import "github.com/leonelquinteros/gorand"

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

    println(uuid)
} 

No Linux, você pode ler em /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))
}

Sem dependências externas!

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

Para Windows, fiz recentemente o seguinte:

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

Esta biblioteca é nosso padrão para geração e análise de uuid:

https://github.com/pborman/uuid