类 Random
Random 提供了 Ruby 伪随机数生成器（PRNG）的接口。PRNG 生成一个确定性的比特序列，近似于真正的随机性。该序列可以用整数、浮点数或二进制字符串表示。
可以使用 Random.srand 用系统生成的或用户提供的种子值初始化生成器。
类方法 Random.rand 提供了 Kernel.rand 的基本功能，并对浮点数进行了更好的处理。这两个都是 Ruby 系统 PRNG 的接口。
Random.new 将创建一个新的 PRNG，其状态独立于 Ruby 系统 PRNG，允许多个具有不同种子值或序列位置的生成器同时存在。 Random 对象可以被封存，允许序列被保存和恢复。
PRNG 目前实现为一个修改后的梅森旋转器，周期为 2**19937-1。由于该算法不用于加密，因此您必须使用 SecureRandom 用于安全目的，而不是此 PRNG。
另请参阅 Random::Formatter 模块，该模块添加了生成各种形式的随机数据的便捷方法。
公共类方法
返回一个随机二进制字符串。参数 size 指定返回字符串的长度。
static VALUE
random_s_bytes(VALUE obj, VALUE len)
{
rb_random_t *rnd = rand_start(default_rand());
return rand_bytes(&random_mt_if, rnd, NUM2LONG(rb_to_int(len)));
}
使用 seed 创建一个新的 PRNG 来设置初始状态。如果省略 seed，则生成器将使用 Random.new_seed 初始化。
有关种子值使用的更多信息，请参阅 Random.srand。
static VALUE
random_init(int argc, VALUE *argv, VALUE obj)
{
rb_random_t *rnd = try_get_rnd(obj);
const rb_random_interface_t *rng = rb_rand_if(obj);
if (!rng) {
rb_raise(rb_eTypeError, "undefined random interface: %s",
RTYPEDDATA_TYPE(obj)->wrap_struct_name);
}
unsigned int major = rng->version.major;
unsigned int minor = rng->version.minor;
if (major != RUBY_RANDOM_INTERFACE_VERSION_MAJOR) {
rb_raise(rb_eTypeError, "Random interface version "
STRINGIZE(RUBY_RANDOM_INTERFACE_VERSION_MAJOR) "."
STRINGIZE(RUBY_RANDOM_INTERFACE_VERSION_MINOR) " "
"expected: %d.%d", major, minor);
}
argc = rb_check_arity(argc, 0, 1);
rb_check_frozen(obj);
if (argc == 0) {
rnd->seed = rand_init_default(rng, rnd);
}
else {
rnd->seed = rand_init(rng, rnd, rb_to_int(argv[0]));
}
return obj;
}
返回一个任意种子值。当没有指定种子值作为参数时，Random.new 使用此值。
Random.new_seed #=> 115032730400174366788466674494640623225
static VALUE
random_seed(VALUE _)
{
VALUE v;
with_random_seed(DEFAULT_SEED_CNT, 1) {
v = make_seed_value(seedbuf, DEFAULT_SEED_CNT);
}
return v;
}
使用 Ruby 系统 PRNG 返回一个随机数。
另请参阅 Random#rand.
static VALUE
random_s_rand(int argc, VALUE *argv, VALUE obj)
{
VALUE v = rand_random(argc, argv, Qnil, rand_start(default_rand()));
check_random_number(v, argv);
return v;
}
返回用于初始化 Ruby 系统 PRNG 的种子值。这可用于在稍后时间使用相同状态初始化另一个生成器，使其产生相同的数字序列。
Random.seed #=> 1234 prng1 = Random.new(Random.seed) prng1.seed #=> 1234 prng1.rand(100) #=> 47 Random.seed #=> 1234 Random.rand(100) #=> 47
static VALUE
random_s_seed(VALUE obj)
{
rb_random_mt_t *rnd = rand_mt_start(default_rand());
return rnd->base.seed;
}
使用 number 对系统伪随机数生成器进行播种。返回先前的种子值。
如果省略 number，则使用操作系统提供的熵源（如果可用）对生成器进行播种（在 Unix 系统上为 /dev/urandom，在 Windows 上为 RSA 加密提供程序），然后将其与时间、进程 ID 和序列号组合。
srand 可用于确保程序不同运行之间伪随机数序列的可重复性。通过将种子设置为已知值，可以在测试期间使程序确定性。
srand 1234 # => 268519324636777531569100071560086917274 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319] [ rand(10), rand(1000) ] # => [4, 664] srand 1234 # => 1234 [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
VALUE seed, old;
rb_random_mt_t *r = rand_mt_start(default_rand());
if (rb_check_arity(argc, 0, 1) == 0) {
seed = random_seed(obj);
}
else {
seed = rb_to_int(argv[0]);
}
old = r->base.seed;
rand_init(&random_mt_if, &r->base, seed);
r->base.seed = seed;
return old;
}
返回一个字符串，使用平台提供的功能。返回值预期为二进制形式的加密安全的伪随机数。如果平台提供的功能未能准备结果，此方法将引发 RuntimeError。
在 2017 年，Linux 手册页 random(7) 写道：“当今可用的任何加密原语都无法保证超过 256 位的安全”。因此，将 size > 32 传递给此方法可能存在疑问。
Random.urandom(8) #=> "\x78\x41\xBA\xAF\x7D\xEA\xD8\xEA"
static VALUE
random_raw_seed(VALUE self, VALUE size)
{
long n = NUM2ULONG(size);
VALUE buf = rb_str_new(0, n);
if (n == 0) return buf;
if (fill_random_bytes(RSTRING_PTR(buf), n, TRUE))
rb_raise(rb_eRuntimeError, "failed to get urandom");
return buf;
}
公共实例方法
如果两个生成器具有相同的内部状态，则返回 true，否则返回 false。等效生成器将返回相同的伪随机数序列。两个生成器通常只有在使用相同的种子进行初始化时才具有相同的状态
Random.new == Random.new # => false Random.new(1234) == Random.new(1234) # => true
并且具有相同的调用历史记录。
prng1 = Random.new(1234) prng2 = Random.new(1234) prng1 == prng2 # => true prng1.rand # => 0.1915194503788923 prng1 == prng2 # => false prng2.rand # => 0.1915194503788923 prng1 == prng2 # => true
static VALUE
rand_mt_equal(VALUE self, VALUE other)
{
rb_random_mt_t *r1, *r2;
if (rb_obj_class(self) != rb_obj_class(other)) return Qfalse;
r1 = get_rnd_mt(self);
r2 = get_rnd_mt(other);
if (memcmp(r1->mt.state, r2->mt.state, sizeof(r1->mt.state))) return Qfalse;
if ((r1->mt.next - r1->mt.state) != (r2->mt.next - r2->mt.state)) return Qfalse;
if (r1->mt.left != r2->mt.left) return Qfalse;
return rb_equal(r1->base.seed, r2->base.seed);
}
返回一个包含 size 字节的随机二进制字符串。
random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO" random_string.size # => 10
static VALUE
random_bytes(VALUE obj, VALUE len)
{
rb_random_t *rnd = try_get_rnd(obj);
return rand_bytes(rb_rand_if(obj), rnd, NUM2LONG(rb_to_int(len)));
}
当 max 是一个 Integer 时，rand 返回一个大于或等于零且小于 max 的随机整数。与 Kernel.rand 不同，当 max 是一个负整数或零时，rand 会抛出一个 ArgumentError。
prng = Random.new prng.rand(100) # => 42
当 max 是一个 Float 时，rand 返回一个介于 0.0 和 max 之间的随机浮点数，包括 0.0 但不包括 max。
prng.rand(1.5) # => 1.4600282860034115
当 range 是一个 Range 时，rand 返回一个随机数，其中 range.member?(number) == true。
prng.rand(5..9) # => one of [5, 6, 7, 8, 9] prng.rand(5...9) # => one of [5, 6, 7, 8] prng.rand(5.0..9.0) # => between 5.0 and 9.0, including 9.0 prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
范围的起始值和结束值都必须响应减法 (-) 和加法 (+) 方法，否则 rand 会抛出一个 ArgumentError。
static VALUE
random_rand(int argc, VALUE *argv, VALUE obj)
{
VALUE v = rand_random(argc, argv, obj, try_get_rnd(obj));
check_random_number(v, argv);
return v;
}
返回用于初始化生成器的种子值。这可以用来在稍后时间用相同的状态初始化另一个生成器，使其产生相同的数字序列。
prng1 = Random.new(1234) prng1.seed #=> 1234 prng1.rand(100) #=> 47 prng2 = Random.new(prng1.seed) prng2.rand(100) #=> 47
static VALUE
random_get_seed(VALUE obj)
{
return get_rnd(obj)->seed;
}