> slumptalsgenerator <
// Generera kryptografiskt slumpmässiga heltal och decimaltal — eller seed:a den för reproducerbara körningar
Kryptografisk slumpmässighet
Använder som standard crypto.getRandomValues() med rejection sampling, så att varje heltal i ditt intervall är lika sannolikt — ingen modulo-bias.
Reproducerbart seedat läge
Ange valfri seed-sträng för att växla till en deterministisk mulberry32-PRNG. Samma seed, samma tal — perfekt för tester och simuleringar.
Läge utan dubbletter
Generera unika heltal via sampling i Fisher-Yates-stil. Utmärkt för lotteridragningar, utlottningar eller sampling utan återläggning.
Styrning av decimalprecision
Växla till decimalläge och välj 1-10 decimaler. Talen är likformigt fördelade över [min, max) och avrundade till den valda precisionen.
// OM GENERERING AV SLUMPTAL
Så fungerar det:
När seed-fältet är tomt anropar det här verktyget crypto.getRandomValues(new Uint32Array(1)), en CSPRNG (kryptografiskt säker PRNG) som matas av operativsystemets entropipool. För att avbilda ett 32-bitars heltal utan tecken på ett godtyckligt [min, max]-intervall utan modulo-bias använder generatorn rejection sampling: varje dragning över den största multipeln av intervallet som ryms i 2^32 förkastas och dras om. När du anger ett seed hashas strängen med cyrb53 till ett 32-bitars heltal och matas in i mulberry32, en snabb 32-bitars PRNG med en period på 2^32 — deterministisk och reproducerbar. Decimalläget skalar ett likformigt [0,1)-stickprov till [min, max) och formaterar sedan med toFixed(places).
Exempel:
min=1, max=100, count=5, seed="hello" -> 39, 98, 64, 12, 71 (alltid)
Standarder och referenser:
- >Web Crypto API (W3C) —
crypto.getRandomValues()-kontrakt för CSPRNG:er - >RFC 4086 — Randomness Requirements for Security
- >mulberry32 — 32-bitars PRNG av Tommy Ettinger, public domain
- >cyrb53 — snabb 53-bitars sträng-hash för seedning (bryc, public domain)
Vanliga användningsområden:
- >Lotteri- och utlottningsdragningar med bevisbart unika val
- >Slumpmässig sampling utan återläggning för enkäter och revisioner
- >Monte Carlo-simuleringar och statistiska experiment
- >A/B-test-bucketing med reproducerbara seedade tilldelningar
- >Spelmekanik: tärningsersättare, loot-tabeller, nivå-seeds
- >QA-testdata och generering av fuzzing-indata
- >Att välja vinnare, jurymedlemmar eller första talare på möten
- >Generering av syntetiska data för prototyper och demos
Relaterade verktyg:
- >UUID-generator — slumpmässiga v4-identifierare när du behöver ett unikt ID i stället för ett tal
- >Lösenordsgenerator — kryptografiskt slumpmässiga strängar med styrning av teckenuppsättningen
- >BIP39-generator — slumpmässiga mnemoniska seed-fraser för kryptoplånböcker
- >randompickerwheel.app — lyckohjulsgränssnitt när du vill ha en visuell slumpväljare för en livepublik eller ett klassrum
// EXEMPELUTDATA
Lotteridragning — 6 unika tal från 1-49
min=1, max=49, count=6, no-duplicates=on, sort=ascending
output:
7, 13, 22, 28, 35, 41
Tärningsersättare — tio d20-kast (dubbletter tillåtna)
min=1, max=20, count=10, no-duplicates=off, sort=none
output:
14, 3, 20, 11, 7, 14, 2, 19, 8, 11
Decimalsampling — 5 flyttal i [0, 1) med 4 decimaler
type=decimal, min=0, max=1, count=5, places=4
output:
0.4172, 0.8635, 0.0291, 0.5508, 0.7723
Seedad reproducerbar — samma seed ger samma sekvens
min=1, max=100, count=5, seed="hello" (kör två gånger)
output:
Körning 1: 39, 98, 64, 12, 71 / Körning 2: 39, 98, 64, 12, 71
Bucketing — 100 viktade A/B-val via heltals-modulo
min=0, max=99, count=100, seed="experiment-42", sort=ascending
output:
0, 1, 3, 4, 7, 9, 12, ... 95, 97, 98, 99 (deterministisk)
// IMPLEMENTERA DET SJÄLV
Om du hellre vill lägga in algoritmen direkt i ditt eget projekt hittar du här de tre primitiver som det här verktyget bygger på. Tillsammans täcker de obiased kryptografiska heltal, deterministiska seedade strömmar och omvandlingen av en godtycklig sträng-seed till ett 32-bitars PRNG-tillstånd. Alla är public domain eller MIT-likvärdiga.
Kryptografiskt säkert heltal i [min, max] (ingen modulo-bias)
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 — deterministisk seedad PRNG (32-bitars tillstånd, ~2^32 period)
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 — snabb sträng-till-32bit-hash (använd för att seeda 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'));// VANLIGA FALLGROPAR
> Modulo-bias
Ett naivt Math.floor(Math.random() * range) fördelar de höga bitarna ojämnt när intervallet inte är en tvåpotens — vissa utdata hamnar något oftare än andra. Använd rejection sampling (kodsnutten ovan) för att förkasta dragningar utanför intervallet och hålla fördelningen likformig.
> Math.random() är inte kryptografiskt säker
Math.random() använder i V8/Spidermonkey xorshift128+, som är snabb men förutsägbar: en angripare som observerar några utdata kan återskapa det interna tillståndet och förutsäga framtida värden. För tokens, salt, rättvisekritiska lotteridragningar eller något som en motståndare bryr sig om ska du alltid använda crypto.getRandomValues().
> Seedade PRNG:er är deterministiska — använd dem aldrig för säkerhet
Mulberry32 och liknande är utformade för att upprepa sig. Det är precis vad du vill ha för tester, simuleringar och bucketing — och precis vad du inte vill ha för token för lösenordsåterställning eller sessions-ID:n. Om du märker att du matar in ett seed i något användarvänt eller autentiseringsnära, växla omedelbart tillbaka till CSPRNG:n.
> Dublettförkastning vid högt antal tömmer kapaciteten
Att be om k unika heltal från ett intervall av storlek n där k närmar sig n blir ett coupon-collector-problem: de sista dragningarna blir exponentiellt dyra. Det här verktyget begränsar till 10 000 och använder partiell Fisher-Yates-sampling så att kapaciteten är exakt, men en naiv while-loop med seen.has(x) hänger sig tyst när k > n. Kontrollera alltid kapaciteten i förväg.
>> vanliga frågor
F: Är den här slumptalsgeneratorn kryptografiskt säker?
S: Ja, som standard. När du lämnar SEED-fältet tomt använder verktyget crypto.getRandomValues(), Web Crypto API:s CSPRNG, som på Linux/macOS läser från /dev/urandom och på Windows från BCryptGenRandom. Vi tillämpar även rejection sampling så att avbildningen från ett 32-bitars heltal till ditt anpassade intervall är obiased. Utdatan lämpar sig för säkerhetsnära uppgifter som att generera tokens, välja salt eller hålla rättvisa lotterier. Observera att om du anger ett seed växlar det till en deterministisk PRNG (mulberry32), som inte är kryptografiskt säker — använd den endast när reproducerbarhet är viktigare än sekretess.
F: Vad är skillnaden mellan seedat och oseedat läge?
S: Oseedat läge (standard) använder din webbläsares CSPRNG och producerar nya, oförutsägbara tal vid varje klick — samma anrop kommer aldrig att returnera samma sekvens två gånger. Seedat läge hashar seed-strängen till ett 32-bitars heltal med cyrb53 och matar in det i mulberry32, en deterministisk PRNG. Identiskt seed plus identiska inställningar ger alltid den identiska sekvensen, vilket är ovärderligt för reproducerbara experiment, felsökning av stokastisk kod, delning av test-fixturer eller A/B-test-bucketing där varje användare alltid måste hamna i samma bucket.
F: Hur fungerar alternativet utan dubbletter?
S: För heltal drar utan-dubbletter från intervallet [min..max] med en partiell blandning inspirerad av Fisher-Yates som ger de första k elementen utan att någonsin upprepa. Vi använder en gles bytesmappning så att minnesanvändningen förblir O(count) snarare än O(range), vilket innebär att en dragning av 10 unika tal från 1 till 1 000 000 är lika billig som 10 från 1 till 100. Om du ber om fler unika tal än intervallet kan leverera (t.ex. 20 unika heltal i 1-10) rapporterar verktyget ett tydligt kapacitetsfel i stället för att loopa i all evighet.
F: Kan jag generera slumpmässiga decimaltal (flyttal)?
S: Ja. Ställ in TYP-knappen på Decimaltal och välj en precision mellan 1 och 10 decimaler. Generatorn drar ett likformigt flyttal i [0, 1), skalar det till [min, max), avrundar sedan med toFixed(places) och tolkar tillbaka till ett tal. Observera att max är exklusiv i decimalläge (en bieffekt av hur flyttalslikformighet definieras). För de flesta statistiska användningar räcker 4-6 decimaler gott och väl; tio decimaler närmar sig gränsen för IEEE 754-dubbelprecision för typiska små intervall.
F: Finns det ett maximalt antal?
S: Antalet är begränsat till 10 000 tal per klick. Det håller sidan responsiv på telefoner och undviker gränsfallsbeteende i webbläsare kring extremt stora textområden. Om du behöver miljontals värden, kör flera batchar med olika seeds och slå ihop utdatan, eller kopiera algoritmen till ett Node-skript — samma mulberry32-/cyrb53-par fungerar även på serversidan. Av UX-skäl sker sortering, kopiering och nedladdning allt på klientsidan, så 10k är ett rimligt tak som ändå blir klart på långt under en millisekund på en modern bärbar dator.
F: Laddas mina data upp någonstans?
S: Nej. Varje operation körs i din webbläsare som vanlig JavaScript: talgenerering, sortering, statistik, kopiering till urklipp och nedladdning av .txt-filen. Ingen förfrågan skickas till våra servrar när du klickar på GENERATE, COPY eller DOWNLOAD — du kan verifiera det med webbläsarens Nätverk-flik. Vi loggar inte seeds, intervall eller utdata. Sidan är statisk HTML som levereras över HTTPS från ett CDN, så ingenting om din indata är någonsin observerbart för oss. Det gör verktyget säkert för konfidentiella test-fixturer, interna lotteri-seeds eller allt annat du hellre håller borta från tredjepartsservrar.
F: Kan jag undvika dubbletter när jag genererar decimaltal?
S: Ja, kryssrutan utan dubbletter gäller även för decimaltal via en best-effort-omförsöksloop. Eftersom två oberoende dragna flyttal nästan aldrig kolliderar på bitnivå är dubbletter sällsynta såvida inte ditt intervall är litet i förhållande till precisionen (t.ex. har min=0, max=1, places=2 bara 100 distinkta värden). Om loopen inte kan hitta tillräckligt många unika värden inom ett rimligt antal försök rapporterar verktyget ett kapacitetsfel så att du kan utöka intervallet eller öka precisionen. För strikt garanterat unika decimaltal är det bättre att använda heltalsläge och dividera resultatet själv.
F: När bör jag använda ett lyckohjul i stället för en tallista?
S: En tallista är bäst för batchuppgifter: att dra 50 lotter, generera testdata eller mata en simulering. Ett lyckohjul är bättre när en person väljer ett objekt inför en publik och du vill ha spänningen och den visuella behållningen — namnval i klassrum, livestream-utlottningar, barns sysslorotationer, beslutsmöten. Om det är ditt användningsfall, se randompickerwheel.app, som erbjuder ett interaktivt lyckohjulsgränssnitt byggt för just det ögonblicket. Båda verktygen drar från samma CSPRNG-primitiv — skillnaden är presentationen, inte rättvisan.