Générateur NanoID

Qu'est-ce que NanoID ?

NanoID est un générateur d'identifiants aléatoires tiny, rapide et URL-safe. Par défaut, il produit des chaînes de 21 caractères en utilisant un alphabet de 64 caractères (A-Za-z0-9_-), fournissant environ 126 bits d'entropie — comparable aux 122 bits d'UUID v4 mais dans une chaîne plus courte.

NanoID n'intègre pas d'horodatage ni de données structurées. Chaque identifiant est purement aléatoire, généré à partir du générateur de nombres aléatoires cryptographiquement sécurisé du système d'exploitation (crypto.getRandomValues() dans les navigateurs, crypto.randomBytes() dans Node.js).

NanoID vs UUID v4

NanoID et UUID v4 sont tous deux des générateurs d'identifiants aléatoires soutenus par un CSPRNG. Ils diffèrent dans le format, la longueur et le support de l'écosystème :

Choisissez UUID v4 quand l'interopérabilité avec des systèmes externes est importante — bases de données avec colonnes UUID natives, API attendant le format UUID ou infrastructure de journalisation qui analyse les UUID. Choisissez NanoID quand vous voulez des identifiants plus courts et contrôlez toute la pile.

Probabilité de collision par taille

La probabilité de collision de NanoID dépend de la longueur de l'identifiant et du taux de génération. Le tableau suivant utilise l'alphabet de 64 caractères par défaut :

La taille par défaut de 21 caractères est choisie pour correspondre à la résistance aux collisions d'UUID v4 (~126 bits) tout en étant 41% plus court. Pour la plupart des applications, 21 caractères est le bon choix.

Alphabets personnalisés

L'alphabet de NanoID est entièrement personnalisable. La bibliothèque accepte n'importe quelle chaîne de caractères uniques comme alphabet et génère des identifiants en utilisant uniquement ces caractères :

Important : utilisez nanoid/non-secure uniquement pour les applications non sensibles à la sécurité (ex. identifiants d'éléments UI). Pour tout identifiant qui doit être impossible à deviner, utilisez toujours l'import sécurisé par défaut.

Comment NanoID génère l'aléatoire

NanoID utilise le générateur de nombres pseudo-aléatoires cryptographiquement sécurisé (CSPRNG) du système d'exploitation. Dans les navigateurs c'est crypto.getRandomValues() ; dans Node.js c'est crypto.randomFillSync(). C'est la même source d'entropie utilisée pour les clés de session TLS — bien plus forte que Math.random().

Échantillonnage par rejet (éviter le biais modulo)

Une approche naïve pour générer des caractères aléatoires serait : prendre un octet aléatoire (0-255) et calculer octet % tailleAlphabet. Cela introduit un biais modulo — certains caractères apparaissent légèrement plus souvent que d'autres quand la taille de l'alphabet ne divise pas 256 uniformément.

NanoID élimine ce biais en utilisant l<strong>échantillonnage par rejet</strong> :

1. Déterminer le plus petit masque puissance-de-deux qui couvre la taille de l'alphabet (ex. pour un alphabet de 64 chars, le masque est 63 = 0b00111111)
2. Générer des octets aléatoires et appliquer le masque : octet & masque
3. Si la valeur masquée est dans la plage de l'alphabet, l'utiliser. Sinon, rejeter et réessayer.

Cela signifie que certains octets aléatoires sont rejetés, mais le résultat est une distribution parfaitement uniforme sur l'alphabet — aucun caractère n'est plus probable qu'un autre.

// Pure browser — no npm package needed
function generateNanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = crypto.getRandomValues(new Uint8Array(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) {
        id += alphabet[idx]
        if (id.length === size) break
      }
    }
  }
  return id
}

const URL_SAFE = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
generateNanoid(URL_SAFE, 21)  // → "V1StGXR8_Z5jdHi6B-myT"

Support d'environnement

Exemples de code

JavaScript / TypeScript

// npm i nanoid
import { nanoid } from 'nanoid'
nanoid()          // → "V1StGXR8_Z5jdHi6B-myT" (21 chars, URL-safe)
nanoid(8)         // → "Uakgb_J5" (custom size)

// Custom alphabet
import { customAlphabet } from 'nanoid'
const hexId  = customAlphabet('0123456789abcdef', 16)
hexId()       // → "4f3a1b8c9d2e0f7a"

const numId  = customAlphabet('0123456789', 8)
numId()       // → "30812894"

Navigateur (CDN)

NanoID peut être utilisé directement dans le navigateur via un import CDN. Aucune étape de build requise pour un prototypage rapide.

// Pure browser — no npm package needed
function generateNanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = crypto.getRandomValues(new Uint8Array(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) {
        id += alphabet[idx]
        if (id.length === size) break
      }
    }
  }
  return id
}

const URL_SAFE = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
generateNanoid(URL_SAFE, 21)  // → "V1StGXR8_Z5jdHi6B-myT"

Python

# pip install nanoid
from nanoid import generate

generate()              # → "V1StGXR8_Z5jdHi6B-myT"
generate(size=8)        # → "Uakgb_J5"
generate('0123456789abcdef', 16)  # custom alphabet + size

Node.js (CommonJS)

// Node.js — stdlib only, no npm needed
const { randomFillSync } = require('crypto')

function nanoid(alphabet, size) {
  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
  const step = Math.ceil((1.6 * mask * size) / alphabet.length)
  let id = ''
  while (id.length < size) {
    const bytes = randomFillSync(Buffer.alloc(step))
    for (const byte of bytes) {
      const idx = byte & mask
      if (idx < alphabet.length) { id += alphabet[idx]; if (id.length === size) break }
    }
  }
  return id
}

Foire Aux Questions