uuid
v11.0.3
Para a criação de UUIDs RFC9562 (formalmente RFC4122)
uuidObservação
w> uuid@11 já está disponível: Consulte o CHANGELOG para obter detalhes. DR:
@types/uuid de suas dependências)options arg são interpretadas para v1() , v6() e v7() . Ver detalhesUint8Array s. (Pode afetar os chamadores de parse() , stringify() ou que passam um argumento option#buf para v1() - v7() .) 1. Instale
npm install uuid2. Crie um UUID
Sintaxe ESM (deve usar exportações nomeadas):
import { v4 as uuidv4 } from 'uuid' ;
uuidv4 ( ) ; // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'... ComumJS:
const { v4 : uuidv4 } = require ( 'uuid' ) ;
uuidv4 ( ) ; // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'Para UUIDs de carimbo de data e hora, UUIDs de namespace e outras opções, continue lendo ...
uuid.NIL | A string UUID nula (todos zeros) | Novo em [email protected] |
uuid.MAX | A string UUID máxima (todas) | Novo em [email protected] |
uuid.parse() | Converter string UUID em array de bytes | Novo em [email protected] |
uuid.stringify() | Converter matriz de bytes em string UUID | Novo em [email protected] |
uuid.v1() | Crie um UUID da versão 1 (carimbo de data/hora) | |
uuid.v1ToV6() | Crie um UUID da versão 6 a partir de um UUID da versão 1 | Novidade em uuid@10 |
uuid.v3() | Crie um UUID da versão 3 (namespace com MD5) | |
uuid.v4() | Crie um UUID da versão 4 (aleatório) | |
uuid.v5() | Crie um UUID da versão 5 (namespace com SHA-1) | |
uuid.v6() | Crie um UUID da versão 6 (carimbo de data/hora, reordenado) | Novidade em uuid@10 |
uuid.v6ToV1() | Crie um UUID da versão 1 a partir de um UUID da versão 6 | Novidade em uuid@10 |
uuid.v7() | Crie um UUID da versão 7 (baseado em tempo do Unix Epoch) | Novidade em uuid@10 |
uuid.v8() | "Deixado intencionalmente em branco" | |
uuid.validate() | Teste uma string para ver se é um UUID válido | Novo em [email protected] |
uuid.version() | Detectar versão RFC de um UUID | Novo em [email protected] |
A string UUID nula (todos zeros).
Exemplo:
import { NIL as NIL_UUID } from 'uuid' ;
NIL_UUID ; // ⇨ '00000000-0000-0000-0000-000000000000'A string UUID máxima (todas).
Exemplo:
import { MAX as MAX_UUID } from 'uuid' ;
MAX_UUID ; // ⇨ 'ffffffff-ffff-ffff-ffff-ffffffffffff'Converter string UUID em array de bytes
str | Uma String UUID válida |
| retorna | Uint8Array[16] |
| lança | TypeError se str não for um UUID válido |
Observação
A ordem dos valores nas matrizes de bytes usadas por parse() e stringify() segue a ordem esquerda ↠ direita dos pares hexadecimais nas strings UUID. Conforme mostrado no exemplo abaixo.
Exemplo:
import { parse as uuidParse } from 'uuid' ;
// Parse a UUID
uuidParse ( '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b' ) ; // ⇨
// Uint8Array(16) [
// 110, 192, 189, 127, 17,
// 192, 67, 218, 151, 94,
// 42, 138, 217, 235, 174,
// 11
// ]Converter matriz de bytes em string UUID
arr | Coleção semelhante Array de 16 valores (começando em offset ) entre 0-255. |
[ offset = 0] | Índice inicial de Number no array |
| retorna | String |
| lança | TypeError se uma string UUID válida não puder ser gerada |
Observação
A ordem dos valores nas matrizes de bytes usadas por parse() e stringify() segue a ordem esquerda ↠ direita dos pares hexadecimais nas strings UUID. Conforme mostrado no exemplo abaixo.
Exemplo:
import { stringify as uuidStringify } from 'uuid' ;
const uuidBytes = Uint8Array . of (
0x6e ,
0xc0 ,
0xbd ,
0x7f ,
0x11 ,
0xc0 ,
0x43 ,
0xda ,
0x97 ,
0x5e ,
0x2a ,
0x8a ,
0xd9 ,
0xeb ,
0xae ,
0x0b
) ;
uuidStringify ( uuidBytes ) ; // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'Crie um UUID RFC versão 1 (carimbo de data/hora)
[ options ] | Object com uma ou mais das seguintes propriedades: |
[ options.node = (random) ] | Campo "nó" RFC como uma Array[6] de valores de bytes (conforme 4.1.6) |
[ options.clockseq = (random) ] | RFC "sequência de relógio" como um Number entre 0 - 0x3fff |
[ options.msecs = (current time) ] | Campo RFC "timestamp" ( Number de milissegundos, época unix) |
[ options.nsecs = 0 ] | Campo RFC "timestamp" ( Number de nanossegundos a serem adicionados a msecs , deve ser de 0 a 10.000) |
[ options.random = (random) ] | Array de 16 bytes aleatórios (0-255) usados para gerar outros campos, acima |
[ options.rng ] | Alternativa para options.random , uma Function que retorna um Array de 16 bytes aleatórios (0-255) |
[ buffer ] | Array | Buffer Se especificado, uuid será escrito aqui em formato de byte, começando no offset |
[ offset = 0] | Índice Number para começar a escrever bytes UUID no buffer |
| retorna | String UUID se nenhum buffer for especificado, caso contrário retorna buffer |
| lança | Error se mais de 10 milhões de UUIDs/s forem solicitados |
Observação
O ID do nó padrão (os últimos 12 dígitos no UUID) é gerado uma vez, aleatoriamente, na inicialização do processo e permanece inalterado durante o processo.
Observação
options.random e options.rng só são significativos na primeira chamada para v1() , onde podem ser passados para inicializar o node interno e os campos clockseq .
Exemplo:
import { v1 as uuidv1 } from 'uuid' ;
uuidv1 ( ) ; // ⇨ '2c5ea4c0-4067-11e9-9bdd-2b0d7b3dcb6d' Exemplo usando options :
import { v1 as uuidv1 } from 'uuid' ;
const options = {
node : Uint8Array . of ( 0x01 , 0x23 , 0x45 , 0x67 , 0x89 , 0xab ) ,
clockseq : 0x1234 ,
msecs : new Date ( '2011-11-01' ) . getTime ( ) ,
nsecs : 5678 ,
} ;
uuidv1 ( options ) ; // ⇨ '710b962e-041c-11e1-9234-0123456789ab'Converta um UUID da versão 1 para a versão 6
import { v1ToV6 } from 'uuid' ;
v1ToV6 ( '92f62d9e-22c4-11ef-97e9-325096b39f47' ) ; // ⇨ '1ef22c49-2f62-6d9e-97e9-325096b39f47'Crie um UUID RFC versão 3 (namespace com MD5)
API é idêntica a v5() , mas usa "v3".
Importante
De acordo com a RFC, " Se a compatibilidade com versões anteriores não for um problema, o SHA-1 [versão 5] é o preferido ."
Crie um UUID RFC versão 4 (aleatório)
[ options ] | Object com uma ou mais das seguintes propriedades: |
[ options.random ] | Array de 16 bytes aleatórios (0-255) |
[ options.rng ] | Alternativa para options.random , uma Function que retorna um Array de 16 bytes aleatórios (0-255) |
[ buffer ] | Array | Buffer Se especificado, uuid será escrito aqui em formato de byte, começando no offset |
[ offset = 0] | Índice Number para começar a escrever bytes UUID no buffer |
| retorna | String UUID se nenhum buffer for especificado, caso contrário retorna buffer |
Exemplo:
import { v4 as uuidv4 } from 'uuid' ;
uuidv4 ( ) ; // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d' Exemplo usando valores random predefinidos:
import { v4 as uuidv4 } from 'uuid' ;
const v4options = {
random : Uint8Array . of (
0x10 ,
0x91 ,
0x56 ,
0xbe ,
0xc4 ,
0xfb ,
0xc1 ,
0xea ,
0x71 ,
0xb4 ,
0xef ,
0xe1 ,
0x67 ,
0x1c ,
0x58 ,
0x36
) ,
} ;
uuidv4 ( v4options ) ; // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'Crie um UUID RFC versão 5 (namespace com SHA-1)
name | String | Array |
namespace | String | Array[16] UUID do namespace |
[ buffer ] | Array | Buffer Se especificado, uuid será escrito aqui em formato de byte, começando no offset |
[ offset = 0] | Índice Number para começar a escrever bytes UUID no buffer |
| retorna | String UUID se nenhum buffer for especificado, caso contrário retorna buffer |
Observação
Os namespaces RFC DNS e URL estão disponíveis como v5.DNS e v5.URL .
Exemplo com namespace personalizado:
import { v5 as uuidv5 } from 'uuid' ;
// Define a custom namespace. Readers, create your own using something like
// https://www.uuidgenerator.net/
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341' ;
uuidv5 ( 'Hello, World!' , MY_NAMESPACE ) ; // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681' Exemplo com namespace URL RFC:
import { v5 as uuidv5 } from 'uuid' ;
uuidv5 ( 'https://www.w3.org/' , uuidv5 . URL ) ; // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'Crie um UUID RFC versão 6 (carimbo de data e hora, reordenado)
Este método usa os mesmos argumentos que uuid.v1().
import { v6 as uuidv6 } from 'uuid' ;
uuidv6 ( ) ; // ⇨ '1e940672-c5ea-64c0-9b5d-ab8dfbbd4bed' Exemplo usando options :
import { v6 as uuidv6 } from 'uuid' ;
const options = {
node : [ 0x01 , 0x23 , 0x45 , 0x67 , 0x89 , 0xab ] ,
clockseq : 0x1234 ,
msecs : new Date ( '2011-11-01' ) . getTime ( ) ,
nsecs : 5678 ,
} ;
uuidv6 ( options ) ; // ⇨ '1e1041c7-10b9-662e-9234-0123456789ab'Converta um UUID da versão 6 para a versão 1
import { v6ToV1 } from 'uuid' ;
v6ToV1 ( '1ef22c49-2f62-6d9e-97e9-325096b39f47' ) ; // ⇨ '92f62d9e-22c4-11ef-97e9-325096b39f47'Crie um UUID RFC versão 7 (aleatório)
[ options ] | Object com uma ou mais das seguintes propriedades: |
[ options.msecs = (current time) ] | Campo RFC "timestamp" ( Number de milissegundos, época unix) |
[ options.random = (random) ] | Array de 16 bytes aleatórios (0-255) usados para gerar outros campos, acima |
[ options.rng ] | Alternativa para options.random , uma Function que retorna um Array de 16 bytes aleatórios (0-255) |
[ options.seq = (random) ] | Number de sequência de 32 bits entre 0 - 0xffffffff. Isso pode ser fornecido para ajudar a garantir a exclusividade dos UUIDs gerados no mesmo intervalo de milissegundos. Padrão = valor aleatório. |
[ buffer ] | Array | Buffer Se especificado, uuid será escrito aqui em formato de byte, começando no offset |
[ offset = 0] | Índice Number para começar a escrever bytes UUID no buffer |
| retorna | String UUID se nenhum buffer for especificado, caso contrário retorna buffer |
Exemplo:
import { v7 as uuidv7 } from 'uuid' ;
uuidv7 ( ) ; // ⇨ '01695553-c90c-705a-b56d-778dfbbd4bed'"Deixado intencionalmente em branco"
Observação
Os UUIDs da versão 8 (experimentais) são "para casos de uso experimentais ou específicos do fornecedor". A RFC não define um algoritmo de criação para eles, por isso este pacote não oferece um método v8() . Os métodos validate() e version() funcionam com tais UUIDs, entretanto.
Teste uma string para ver se é um UUID válido
str | String para validar |
| retorna | true se a string for um UUID válido, false caso contrário |
Exemplo:
import { validate as uuidValidate } from 'uuid' ;
uuidValidate ( 'not a UUID' ) ; // ⇨ false
uuidValidate ( '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b' ) ; // ⇨ true Usando validate e version juntas, é possível fazer a validação por versão, por exemplo, validar apenas para UUIds v4.
import { version as uuidVersion } from 'uuid' ;
import { validate as uuidValidate } from 'uuid' ;
function uuidValidateV4 ( uuid ) {
return uuidValidate ( uuid ) && uuidVersion ( uuid ) === 4 ;
}
const v1Uuid = 'd9428888-122b-11e1-b85c-61cd3cbb3210' ;
const v4Uuid = '109156be-c4fb-41ea-b1b4-efe1671c5836' ;
uuidValidateV4 ( v4Uuid ) ; // ⇨ true
uuidValidateV4 ( v1Uuid ) ; // ⇨ falseDetectar versão RFC de um UUID
str | Uma String UUID válida |
| retorna | Number A versão RFC do UUID |
| lança | TypeError se str não for um UUID válido |
Exemplo:
import { version as uuidVersion } from 'uuid' ;
uuidVersion ( '45637ec4-c85f-11ea-87d0-0242ac130003' ) ; // ⇨ 1
uuidVersion ( '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b' ) ; // ⇨ 4 Observação
Este método retorna 0 para o UUID NIL e 15 para o UUID MAX .
UUIDs podem ser gerados a partir da linha de comando usando uuid .
$ npx uuid
ddeb27fb-d9a0-4624-be4d-4615062daed4 O padrão é gerar UUIDS versão 4, porém as outras versões são suportadas. Digite uuid --help para obter detalhes:
$ npx uuid --help
Usage:
uuid
uuid v1
uuid v3 < name > < namespace uuid >
uuid v4
uuid v5 < name > < namespace uuid >
uuid v7
uuid --help
Note: < namespace uuid > may be " URL " or " DNS " to use the corresponding UUIDs
defined by RFC9562options Tratamento para UUIDs de carimbo de data/hora Antes de uuid@11 , era possível que o estado options interferisse no estado interno usado para garantir a exclusividade dos UUIDs baseados em carimbo de data / hora (os métodos v1() , v6() e v7() ). Começando com uuid@11 , esse problema foi resolvido usando a presença do argumento options como um sinalizador para selecionar entre dois comportamentos possíveis:
options : o estado interno é utilizado para melhorar a exclusividade do UUID.options : O estado interno NÃO é usado e, em vez disso, os padrões apropriados são aplicados conforme necessário. Navegadores : as compilações uuid são testadas na versão mais recente do desktop Chrome, Safari, Firefox e Edge. Espera-se que as versões móveis desses mesmos navegadores funcionem, mas ainda não foram testadas.
Nó : compilações uuid são testadas em relação ao nó (versões LTS), mais um anterior. Por exemplo, node@18 está no modo de manutenção e node@22 é a versão LTS atual. Então uuid suporta node@16 - node@22 .
Typescript : versões TS lançadas nos últimos dois anos são suportadas. fonte
react-native-get-random-valuesuuid . Como uuid também pode aparecer como uma dependência transitiva de algumas outras importações, é mais seguro importar apenas react-native-get-random-values como a primeira coisa no seu ponto de entrada: import 'react-native-get-random-values' ;
import { v4 as uuidv4 } from 'uuid' ;Markdown gerado a partir de README_js.md por
