sfcode An Online Competing and Development Environment

README

# uuid <a href="https://github.com/uuidjs/uuid/actions?query=workflow%3ACI"><img src="https://github.com/uuidjs/uuid/workflows/CI/badge.svg" alt="CI"/></a> <a href="https://github.com/uuidjs/uuid/actions?query=workflow%3ABrowser"><img src="https://github.com/uuidjs/uuid/workflows/Browser/badge.svg" alt="Browser"/></a>

For the creation of RFC4122 UUIDs

- Complete - Support for RFC4122 version 1, 3, 4, and 5 UUIDs
- Cross-platform - Support for ...
  - CommonJS, ECMAScript Modules and CDN builds
  - Node 8, 10, 12, 14
  - Chrome, Safari, Firefox, Edge, IE 11 browsers
  - Webpack and rollup.js module bundlers
  - React Native
- Secure - Cryptographically-strong random values
- Small - Zero-dependency, small footprint, plays nice with "tree shaking" packagers
- CLI - Includes the `uuid` command line utility

Upgrading from `uuid@3.x`? Your code is probably okay, but check out Upgrading From `uuid@3.x` for details.

## Quickstart

To create a random UUID...

1. Install

npm install uuid

2. Create a UUID (ES6 module syntax)

import { v4 as uuidv4 } from 'uuid';
uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'

... or using CommonJS syntax:

const { v4: uuidv4 } = require('uuid');
uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

For timestamp UUIDs, namespace UUIDs, and other options read on ...

## API Summary

`uuid.NIL` | The nil UUID string (all zeros) | New in `uuid@8.3`
`uuid.parse()` | Convert UUID string to array of bytes | New in `uuid@8.3`
`uuid.stringify()` | Convert array of bytes to UUID string | New in `uuid@8.3`
`uuid.v1()` | Create a version 1 (timestamp) UUID |
`uuid.v3()` | Create a version 3 (namespace w/ MD5) UUID |
`uuid.v4()` | Create a version 4 (random) UUID |
`uuid.v5()` | Create a version 5 (namespace w/ SHA-1) UUID |
`uuid.validate()` | Test a string to see if it is a valid UUID | New in `uuid@8.3`
`uuid.version()` | Detect RFC version of a UUID | New in `uuid@8.3`

## API

### uuid.NIL

The nil UUID string (all zeros).

Example:

import { NIL as NIL_UUID } from 'uuid';
NIL_UUID; // ⇨ '00000000-0000-0000-0000-000000000000'

### uuid.parse(str)

Convert UUID string to array of bytes

`str` | A valid UUID `String`
returns | `Uint8Array[16]`
throws | `TypeError` if `str` is not a valid UUID

Example:

import { parse as uuidParse } from '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
// ]

### uuid.stringify(arr[, offset])

Convert array of bytes to UUID string

`arr` | `Array`-like collection of 16 values (starting from `offset`) between 0-255
[`offset` = 0] | `Number` Starting index in the Array
returns | `String`
throws | `TypeError` if a valid UUID string cannot be generated

Example:

import { stringify as uuidStringify } from 'uuid';
const uuidBytes = [110, 192, 189, 127, 17, 192, 67, 218, 151, 94, 42, 138, 217, 235, 174, 11];
uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'

### uuid.v1([options[, buffer[, offset]]])

Create an RFC version 1 (timestamp) UUID

[`options`] | `Object` with one or more of the following properties:
[`options.node` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6)
[`options.clockseq`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff
[`options.msecs`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch)
[`options.nsecs`] | RFC "timestamp" field (`Number` of nanseconds to add to `msecs`, should be 0-10,000)
[`options.random`] | `Array` of 16 random bytes (0-255)
[`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255)
[`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset`
[`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer`
returns | UUID `String` if no `buffer` is specified, otherwise returns `buffer`
throws | `Error` if more than 10M UUIDs/sec are requested

Note: The default node id (the last 12 digits in the UUID) is generated once, randomly, on process startup, and then remains unchanged for the duration of the process.

Note: `options.random` and `options.rng` are only meaningful on the very first call to `v1()`, where they may be passed to initialize the internal `node` and `clockseq` fields.

Example:

import { v1 as uuidv1 } from 'uuid';
uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-8bad-9b1deb4d3b7d'

Example using `options`:

import { v1 as uuidv1 } from 'uuid';
const v1options = {
node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
clockseq: 0x1234,
msecs: new Date('2011-11-01').getTime(),
nsecs: 5678,
};
uuidv1(v1options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'

### uuid.v3(name, namespace[, buffer[, offset]])

Create an RFC version 3 (namespace w/ MD5) UUID

API is identical to `v5()`, but uses "v3" instead.

&#x26a0;&#xfe0f; Note: Per the RFC, "_If backward compatibility is not an issue, SHA-1 [Version 5] is preferred_."

### uuid.v4([options[, buffer[, offset]]])

Create an RFC version 4 (random) UUID

[`options`] | `Object` with one or more of the following properties:
[`options.random`] | `Array` of 16 random bytes (0-255)
[`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255)
[`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset`
[`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer`
returns | UUID `String` if no `buffer` is specified, otherwise returns `buffer`

Example:

import { v4 as uuidv4 } from 'uuid';
uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

Example using predefined `random` values:

import { v4 as uuidv4 } from 'uuid';
const v4options = {
random: [
0x10,
0x91,
0x56,
0xbe,
0xc4,
0xfb,
0xc1,
0xea,
0x71,
0xb4,
0xef,
0xe1,
0x67,
0x1c,
0x58,
0x36,
],
};
uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'

### uuid.v5(name, namespace[, buffer[, offset]])

Createa an RFC version 5 (namespace w/ SHA-1) UUID

`name` | `String \| Array`
`namespace` | `String \| Array[16]` Namespace UUID
[`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset`
[`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer`
returns | UUID `String` if no `buffer` is specified, otherwise returns `buffer`

Note: The RFC `DNS` and `URL` namespaces are available as `v5.DNS` and `v5.URL`.

Example with custom namespace:

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'

Example with RFC `URL` namespace:

import { v5 as uuidv5 } from 'uuid';
uuidv5('https://www.w3.org/', uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'

### uuid.validate(str)

Test a string to see if it is a valid UUID

`str` | `String` to validate
returns | `true` if string is a valid UUID, `false` otherwise

Example:

import { validate as uuidValidate } from 'uuid';
uuidValidate('not a UUID'); // ⇨ false
uuidValidate('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ true

### uuid.version(str)

Detect RFC version of a UUID

`str` | A valid UUID `String`
returns | `Number` The RFC version of the UUID
throws | `TypeError` if `str` is not a valid UUID

Example:

import { version as uuidVersion } from 'uuid';
uuidVersion('45637ec4-c85f-11ea-87d0-0242ac130003'); // ⇨ 1
uuidVersion('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ 4

## Command Line

UUIDs can be generated from the command line using `uuid`.

$ uuid
ddeb27fb-d9a0-4624-be4d-4615062daed4

The default is to generate version 4 UUIDS, however the other versions are supported. Type `uuid --help` for details:

$ uuid --help
Usage:
uuid
uuid v1
uuid v3 <name> <namespace uuid>
uuid v4
uuid v5 <name> <namespace uuid>
uuid --help
Note: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs
defined by RFC4122

## ECMAScript Modules

This library comes with ECMAScript Modules (ESM) support for Node.js versions that support it (example) as well as bundlers like rollup.js (example) and webpack (example) (targeting both, Node.js and browser environments).

import { v4 as uuidv4 } from 'uuid';
uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'

To run the examples you must first create a dist build of this library in the module root:

npm run build

## CDN Builds

### ECMAScript Modules

To load this module directly into modern browsers that support loading ECMAScript Modules you can make use of jspm:

<script type="module">
import { v4 as uuidv4 } from 'https://jspm.dev/uuid';
console.log(uuidv4()); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
</script>

### UMD

To load this module directly into older browsers you can use the UMD (Universal Module Definition) builds from any of the following CDNs:

**Using UNPKG**:

<script src="https://unpkg.com/uuid@latest/dist/umd/uuidv4.min.js"></script>

**Using jsDelivr**:

<script src="https://cdn.jsdelivr.net/npm/uuid@latest/dist/umd/uuidv4.min.js"></script>

Using cdnjs:

<script src="https://cdnjs.cloudflare.com/ajax/libs/uuid/8.1.0/uuidv4.min.js"></script>

These CDNs all provide the same `uuidv4()` method:

<script>
uuidv4(); // ⇨ '55af1e37-0734-46d8-b070-a1e42e4fc392'
</script>

Methods for the other algorithms (`uuidv1()`, `uuidv3()` and `uuidv5()`) are available from the files `uuidv1.min.js`, `uuidv3.min.js` and `uuidv5.min.js` respectively.

## "getRandomValues() not supported"

This error occurs in environments where the standard `crypto.getRandomValues()` API is not supported. This issue can be resolved by adding an appropriate polyfill:

### React Native

1. Install `react-native-get-random-values`

1. Import it before `uuid`:

import 'react-native-get-random-values';
import { v4 as uuidv4 } from 'uuid';

### Web Workers / Service Workers (Edge <= 18)

In Edge <= 18, Web Crypto is not supported in Web Workers or Service Workers and we are not aware of a polyfill (let us know if you find one, please).

## Upgrading From <tt>uuid@7.x</tt>

### Only Named Exports Supported When Using with Node.js ESM

`uuid@7.x` did not come with native ECMAScript Module (ESM) support for Node.js. Importing it in Node.js ESM consequently imported the CommonJS source with a default export. This library now comes with true Node.js ESM support and only provides named exports.

Instead of doing:

import uuid from 'uuid';
uuid.v4();

you will now have to use the named exports:

import { v4 as uuidv4 } from 'uuid';
uuidv4();

### Deep Requires No Longer Supported

Deep requires like ‘require('uuid/v4’)`[which have been deprecated in`uuid@7.x`](#deep-requires-now-deprecated) are no longer supported.

## Upgrading From <tt>uuid@3.x</tt>

"_Wait... what happened to `uuid@4.x` - `uuid@6.x`?!?_"

In order to avoid confusion with RFC version 4 and version 5 UUIDs, and a possible version 6, releases 4 thru 6 of this module have been skipped.

### Deep Requires Now Deprecated

`uuid@3.x` encouraged the use of deep requires to minimize the bundle size of browser builds:

const uuidv4 = require('uuid/v4'); // <== NOW DEPRECATED!
uuidv4();

As of `uuid@7.x` this library now provides ECMAScript modules builds, which allow packagers like Webpack and Rollup to do "tree-shaking" to remove dead code. Instead, use the `import` syntax:

import { v4 as uuidv4 } from 'uuid';
uuidv4();

... or for CommonJS:

const { v4: uuidv4 } = require('uuid');
uuidv4();

### Default Export Removed

`uuid@3.x` was exporting the Version 4 UUID method as a default export:

const uuid = require('uuid'); // <== REMOVED!

This usage pattern was already discouraged in `uuid@3.x` and has been removed in `uuid@7.x`.

Markdown generated from README_js.md by