> générateur de nombres aléatoires <
// Générez des entiers et décimaux cryptographiquement aléatoires — ou utilisez une graine pour des exécutions reproductibles
Aléatoire cryptographique
Utilise par défaut crypto.getRandomValues() avec échantillonnage par rejet afin que chaque entier de votre plage soit également probable — aucun biais de modulo.
Mode reproductible avec graine
Fournissez n'importe quelle chaîne de graine pour passer à un PRNG mulberry32 déterministe. Même graine, mêmes nombres — parfait pour les tests et les simulations.
Mode sans doublons
Générez des entiers uniques via un échantillonnage de type Fisher-Yates. Idéal pour les tirages de loterie, les tombolas ou l'échantillonnage sans remise.
Contrôle de la précision décimale
Passez en mode décimal et choisissez 1 à 10 décimales. Les nombres sont uniformément répartis sur [min, max) et arrondis à la précision choisie.
// À PROPOS DE LA GÉNÉRATION DE NOMBRES ALÉATOIRES
Fonctionnement:
Lorsque le champ de graine est vide, cet outil appelle crypto.getRandomValues(new Uint32Array(1)), un CSPRNG (PRNG cryptographiquement sûr) alimenté par le pool d'entropie de votre système d'exploitation. Pour mapper un entier non signé de 32 bits sur une plage arbitraire [min, max] sans biais de modulo, le générateur utilise l'échantillonnage par rejet : tout tirage supérieur au plus grand multiple de la plage qui tient dans 2^32 est rejeté et retiré. Lorsque vous fournissez une graine, la chaîne est hachée avec cyrb53 en un entier de 32 bits puis transmise à mulberry32, un PRNG rapide de 32 bits avec une période de 2^32 — déterministe et reproductible. Le mode décimal met à l'échelle un échantillon uniforme [0,1) vers [min, max), puis le formate avec toFixed(places).
Exemple:
min=1, max=100, count=5, seed="hello" -> 39, 98, 64, 12, 71 (toujours)
Normes et références:
- >Web Crypto API (W3C) — contrat
crypto.getRandomValues()pour les CSPRNG - >RFC 4086 — Randomness Requirements for Security
- >mulberry32 — PRNG 32 bits de Tommy Ettinger, domaine public
- >cyrb53 — hachage de chaîne rapide 53 bits pour le seeding (bryc, domaine public)
Cas d'usage courants:
- >Tirages de loterie et tombolas avec des sélections uniques prouvables
- >Échantillonnage aléatoire sans remise pour les sondages et audits
- >Simulations de Monte-Carlo et expériences statistiques
- >Répartition de tests A/B avec affectations reproductibles par graine
- >Mécaniques de jeu : substituts de dés, tables de butin, graines de niveau
- >Données de test QA et génération d'entrées de fuzzing
- >Choix des gagnants, des juges ou du premier intervenant en réunion
- >Génération de données synthétiques pour prototypes et démos
Outils connexes:
- >Générateur d'UUID — identifiants v4 aléatoires lorsque vous avez besoin d'un ID unique plutôt que d'un nombre
- >Générateur de mots de passe — chaînes cryptographiquement aléatoires avec contrôle du jeu de caractères
- >Générateur BIP39 — phrases mnémoniques de graine aléatoires pour portefeuilles crypto
- >randompickerwheel.app — interface de roue tournante quand vous voulez un sélecteur aléatoire visuel pour un public en direct ou une salle de classe
// EXEMPLES DE SORTIES
Tirage de loterie — 6 nombres uniques de 1 à 49
min=1, max=49, count=6, no-duplicates=on, sort=ascending
output:
7, 13, 22, 28, 35, 41
Substitut de dés — dix lancers de d20 (doublons autorisés)
min=1, max=20, count=10, no-duplicates=off, sort=none
output:
14, 3, 20, 11, 7, 14, 2, 19, 8, 11
Échantillonnage décimal — 5 flottants dans [0, 1) avec 4 décimales
type=decimal, min=0, max=1, count=5, places=4
output:
0.4172, 0.8635, 0.0291, 0.5508, 0.7723
Reproductible avec graine — la même graine produit la même séquence
min=1, max=100, count=5, seed="hello" (exécuter deux fois)
output:
Exécution 1 : 39, 98, 64, 12, 71 / Exécution 2 : 39, 98, 64, 12, 71
Répartition — 100 sélections A/B pondérées via modulo entier
min=0, max=99, count=100, seed="experiment-42", sort=ascending
output:
0, 1, 3, 4, 7, 9, 12, ... 95, 97, 98, 99 (déterministe)
// IMPLÉMENTEZ-LE VOUS-MÊME
Si vous préférez intégrer l'algorithme directement dans votre propre projet, voici les trois primitives sur lesquelles cet outil est construit. Ensemble, elles couvrent les entiers cryptographiques non biaisés, les flux déterministes avec graine et la transformation d'une chaîne de graine arbitraire en état de PRNG 32 bits. Toutes du domaine public ou équivalent MIT.
Entier cryptographiquement sûr dans [min, max] (sans biais de modulo)
function secureRandomInt(min, max) {
const range = max - min + 1;
const buf = new Uint32Array(1);
const max32 = 0xFFFFFFFF;
const limit = Math.floor((max32 + 1) / range) * range;
let v;
do {
crypto.getRandomValues(buf);
v = buf[0];
} while (v >= limit);
return min + (v % range);
}mulberry32 — PRNG déterministe avec graine (état 32 bits, période ~2^32)
function mulberry32(seed) {
let a = seed >>> 0;
return function () {
a = (a + 0x6D2B79F5) | 0;
let t = a;
t = Math.imul(t ^ (t >>> 15), t | 1);
t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
// usage: const rng = mulberry32(0xC0FFEE);
// rng(); // 0.6743..., reproducible across runscyrb53 — hachage rapide chaîne-vers-32bits (pour seeder mulberry32)
function cyrb53(str, seed) {
seed = seed || 0;
let h1 = 0xdeadbeef ^ seed;
let h2 = 0x41c6ce57 ^ seed;
for (let i = 0; i < str.length; i++) {
const ch = str.charCodeAt(i);
h1 = Math.imul(h1 ^ ch, 2654435761);
h2 = Math.imul(h2 ^ ch, 1597334677);
}
h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
Math.imul(h2 ^ (h2 >>> 13), 3266489909);
h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
Math.imul(h1 ^ (h1 >>> 13), 3266489909);
return (h1 >>> 0);
}
// const rng = mulberry32(cyrb53('my-seed-string'));// PIÈGES COURANTS
> Biais de modulo
Un naïf Math.floor(Math.random() * range) répartit les bits de poids fort de manière inégale lorsque la plage n'est pas une puissance de deux — certaines sorties tombent légèrement plus souvent que d'autres. Utilisez l'échantillonnage par rejet (le snippet ci-dessus) pour rejeter les tirages hors plage et garder une distribution uniforme.
> Math.random() n'est pas cryptographiquement sûr
Math.random() dans V8/Spidermonkey utilise xorshift128+, qui est rapide mais prévisible : un attaquant qui observe quelques sorties peut récupérer l'état interne et prévoir les valeurs futures. Pour les jetons, les sels, les tirages de loterie où l'équité est critique, ou tout ce qui intéresse un adversaire, utilisez toujours crypto.getRandomValues().
> Les PRNG avec graine sont déterministes — ne les utilisez jamais pour la sécurité
Mulberry32 et ses semblables sont conçus pour se répéter. C'est exactement ce que vous voulez pour les tests, les simulations et la répartition — et exactement ce que vous ne voulez pas pour les jetons de réinitialisation de mot de passe ou les ID de session. Si vous vous retrouvez à transmettre une graine à quoi que ce soit destiné à l'utilisateur ou proche de l'authentification, revenez immédiatement au CSPRNG.
> Le rejet de doublons à nombre élevé épuise la capacité
Demander k entiers uniques dans une plage de taille n où k approche de n se transforme en problème du collectionneur de coupons : les derniers tirages deviennent exponentiellement coûteux. Cet outil plafonne à 10 000 et utilise un échantillonnage partiel de Fisher-Yates afin que la capacité soit exacte, mais une boucle while naïve avec seen.has(x) se bloquera silencieusement quand k > n. Vérifiez toujours la capacité en amont.
>> questions fréquentes
Q : Ce générateur de nombres aléatoires est-il cryptographiquement sûr ?
R : Oui, par défaut. Lorsque vous laissez le champ GRAINE vide, l'outil utilise crypto.getRandomValues(), le CSPRNG de la Web Crypto API, qui sous Linux/macOS lit depuis /dev/urandom et sous Windows depuis BCryptGenRandom. Nous appliquons aussi l'échantillonnage par rejet afin que le mappage d'un entier de 32 bits vers votre plage personnalisée soit non biaisé. La sortie convient aux tâches proches de la sécurité comme la génération de jetons, le choix de sels ou l'organisation de loteries équitables. Notez que fournir une graine bascule vers un PRNG déterministe (mulberry32), qui n'est pas cryptographiquement sûr — utilisez-le uniquement quand la reproductibilité importe plus que le secret.
Q : Quelle est la différence entre le mode avec graine et sans graine ?
R : Le mode sans graine (par défaut) utilise le CSPRNG de votre navigateur et produit des nombres frais et imprévisibles à chaque clic — le même appel ne renverra jamais deux fois la même séquence. Le mode avec graine hache la chaîne de graine en un entier de 32 bits avec cyrb53 et la transmet à mulberry32, un PRNG déterministe. Une graine identique avec des réglages identiques produit toujours la séquence identique, ce qui est précieux pour les expériences reproductibles, le débogage de code stochastique, le partage de fixtures de test ou la répartition de tests A/B où chaque utilisateur doit toujours atterrir dans le même groupe.
Q : Comment fonctionne l'option sans doublons ?
R : Pour les entiers, l'option sans doublons tire de la plage [min..max] à l'aide d'un mélange partiel inspiré de Fisher-Yates qui fournit les k premiers éléments sans jamais se répéter. Nous utilisons une carte d'échange creuse pour que l'usage mémoire reste en O(count) plutôt qu'en O(range), ce qui signifie qu'un tirage de 10 nombres uniques de 1 à 1 000 000 est aussi peu coûteux que 10 de 1 à 100. Si vous demandez plus de nombres uniques que la plage ne peut en fournir (par ex. 20 entiers uniques dans 1–10), l'outil signale une erreur de capacité claire au lieu de boucler indéfiniment.
Q : Puis-je générer des nombres aléatoires décimaux (à virgule flottante) ?
R : Oui. Réglez le bouton TYPE sur Décimal et choisissez une précision entre 1 et 10 décimales. Le générateur tire un flottant uniforme dans [0, 1), le met à l'échelle dans [min, max), puis l'arrondit avec toFixed(places) et le reconvertit en nombre. Notez que max est exclusif en mode décimal (un effet de bord de la définition de l'uniformité en virgule flottante). Pour la plupart des usages statistiques, 4 à 6 décimales suffisent largement ; dix décimales approchent la limite de la double précision IEEE 754 pour les petites plages typiques.
Q : Y a-t-il un nombre maximal ?
R : Le nombre est plafonné à 10 000 valeurs par clic. Cela garde la page réactive sur les téléphones et évite les comportements limites des navigateurs autour de zones de texte extrêmement grandes. Si vous avez besoin de millions de valeurs, exécutez plusieurs lots avec des graines différentes et concaténez la sortie, ou copiez l'algorithme dans un script Node — le même couple mulberry32 / cyrb53 fonctionne aussi côté serveur. Pour des raisons d'expérience utilisateur, le tri, la copie et le téléchargement se font tous côté client, donc 10 000 est un plafond raisonnable qui se termine néanmoins en bien moins d'une milliseconde sur un portable moderne.
Q : Mes données sont-elles téléversées quelque part ?
R : Non. Chaque opération s'exécute dans votre navigateur en JavaScript pur : génération de nombres, tri, statistiques, copie dans le presse-papiers et téléchargement du fichier .txt. Aucune requête n'est envoyée à nos serveurs quand vous cliquez sur GENERATE, COPY ou DOWNLOAD — vous pouvez le vérifier avec l'onglet Réseau de votre navigateur. Nous ne consignons ni graines, ni plages, ni sorties. La page est du HTML statique servi en HTTPS depuis un CDN, donc rien de votre entrée ne nous est jamais observable. Cela rend l'outil sûr pour des fixtures de test confidentielles, des graines de loterie internes ou tout ce que vous préférez garder hors des serveurs tiers.
Q : Puis-je éviter les doublons en générant des nombres décimaux ?
R : Oui, la case sans doublons s'applique aussi aux décimaux via une boucle de réessai au mieux. Comme deux flottants échantillonnés indépendamment ne se heurtent presque jamais au niveau des bits, les doublons sont rares sauf si votre plage est minuscule par rapport à la précision (par ex. min=0, max=1, places=2 n'a que 100 valeurs distinctes). Si la boucle ne trouve pas assez de valeurs uniques en un nombre raisonnable de tentatives, l'outil signale une erreur de capacité afin que vous puissiez élargir la plage ou augmenter la précision. Pour des décimaux strictement garantis uniques, préférez le mode entier et divisez le résultat vous-même.
Q : Quand utiliser une roue tournante plutôt qu'une liste de nombres ?
R : Une liste de nombres convient le mieux aux tâches par lots : tirer 50 billets de loterie, générer des données de test ou alimenter une simulation. Une roue tournante est préférable quand une personne choisit un élément devant un public et que vous voulez le suspense et l'effet visuel — choix de noms en classe, cadeaux en livestream, rotation des corvées des enfants, réunions de décision. Si c'est votre cas d'usage, voyez randompickerwheel.app, qui propose une interface de roue tournante interactive conçue pour ce moment précis. Les deux outils puisent dans la même primitive CSPRNG — la différence est la présentation, pas l'équité.