Även om ingen dator kan generera riktigt slumpmässiga nummer ger Ruby åtkomst till en metod som kommer att återvända pseudoslumpmässig tal.
Ingen dator kan generera verkligen slumpmässiga siffror rent genom beräkning. Det bästa de kan göra är att generera pseudoslumpmässig siffror, som är en sekvens av siffror som dyka upp slumpmässiga men är inte.
För en mänsklig observatör är dessa siffror verkligen slumpmässiga. Det kommer inte att finnas några korta upprepade sekvenser, och åtminstone för den mänskliga observatören kommer de inte att presentera något tydligt mönster. Men med tillräckligt med tid och motivation, originalet utsäde kan upptäckas, sekvensen återskapas och nästa nummer i sekvensen gissas.
Av denna anledning bör de metoder som diskuteras i denna artikel förmodligen inte användas för att generera siffror som måste vara kryptografiskt säkra.
Pseudorandom-nummergeneratorer måste vara ympades för att producera sekvenser som skiljer sig varje gång ett nytt slumpmässigt antal genereras. Ingen metod är magisk - dessa till synes slumpmässiga siffror genereras med relativt enkla algoritmer och relativt enkla aritmetiker. Genom att se till PRNG startar du den vid en annan punkt varje gång. Om du inte såg det skulle det generera samma antal sekvenser varje gång.
I Ruby, the Kernel # srand metoden kan kallas utan argument. Den väljer ett slumpmässigt antal frön baserat på tid, process-ID och ett sekvensnummer. Helt enkelt genom att ringa srand var som helst i början av ditt program, kommer det att generera en annan serie till synes slumpmässiga nummer varje gång du kör det. Denna metod kallas implicit när programmet startar och fröer PRNG med tid och process-ID (inget sekvensnummer).
När programmet är igång och Kernel # srand antingen implicit eller uttryckligen kallades, the Kernel # rand metod kan kallas. Denna metod, som kallas utan argument, kommer att returnera ett slumpmässigt nummer från 0 till 1. Tidigare skalades detta nummer vanligtvis till det maximala antalet du vill generera och kanske to_i uppmanade den att konvertera den till ett heltal.
Ruby gör det dock lite lättare om du använder Ruby 1.9.x. De Kernel # rand metoden kan ta ett enda argument. Om detta argument är en Numerisk av vilket slag som helst kommer Ruby att generera ett heltal från 0 upp till (och inte med) det numret.
Men vad händer om du vill generera ett nummer från 10 till 15? Vanligtvis skulle du generera ett nummer från 0 till 5 och lägga till det till 10. Ruby gör det dock enklare.
Se till att du är uppmärksam på de två sortimenten. Om du ringde rand (10..15), som skulle generera ett nummer från 10 till 15 Inklusive 15. medan rand (10... 15) (med 3 punkter) skulle generera ett nummer från 10 till 15 inte inklusive 15.
Ibland behöver du en slumpmässig serienummer, men måste generera samma sekvens varje gång. Om du till exempel genererar slumpmässiga siffror i ett enhetstest, bör du generera samma antal sekvenser varje gång.
Ett enhetstest som misslyckas i en sekvens ska misslyckas igen nästa gång det körs, om det genererade en skillnadssekvens nästa gång kanske det inte misslyckas. För att göra det, ring Kernel # srand med ett känt och konstant värde.
Implementeringen av Kernel # rand är ganska un-Ruby. Det abstraherar inte PRNG på något sätt, och det låter dig inte heller initiera PRNG. Det finns en global stat för PRNG som alla koder delar. Om du byter utsäde eller på annat sätt ändrar PRNG: s tillstånd kan det ha ett större effektområde än du förväntat dig.
Men eftersom program förväntar sig att resultatet av denna metod är slumpmässigt - det är dess syfte! - detta kommer förmodligen aldrig att vara ett problem. Endast om programmet förväntar sig att se en förväntad sekvenssekvens, till exempel om det hade ringt srand med ett konstant värde, om det skulle se oväntade resultat.