如何在Bash中生成随机数？

如何在Bash范围内生成随机数？

使用$RANDOM。与简单的Shell算术结合使用时通常很有用。例如，要生成1到10（含）之间的随机数：

$ echo $((1 + RANDOM % 10))
3

实际的发电机在variables.c，功能brand()。旧版本是一个简单的线性发电机。版本4.0 bash使用引用了1985年论文的生成器，这大概意味着它是伪随机数的一个不错的来源。我不会将其用于模拟（当然也不会用于加密），但它可能足以满足基本脚本任务的需要。

如果您要执行的操作需要严重的随机数，则可以使用/dev/random或/dev/urandom可用：

$ dd if=/dev/urandom count=4 bs=1 | od -t d

请参阅$RANDOM：

$RANDOM 是内部Bash函数（不是常数），它返回0到32767范围内的伪随机整数。不应将其用于生成加密密钥。

您也可以使用shuf（在coreutils中可用）。

shuf -i 1-100000 -n 1

在您的shell中尝试一下：

$ od -A n -t d -N 1 /dev/urandom

在这里，-t d指定输出格式应为十进制符号；-N 1表示要从中读取一个字节/dev/urandom。

你也可以从awk获得随机数

awk 'BEGIN {
   # seed
   srand()
   for (i=1;i<=1000;i++){
     print int(1 + rand() * 100)
   }
}'

有$ RANDOM。我不知道它是如何工作的。但这有效。为了进行测试，您可以执行以下操作：

echo $RANDOM

我喜欢这个技巧：

echo ${RANDOM:0:1} # random number between 1 and 9
echo ${RANDOM:0:2} # random number between 1 and 99

...

介于0和9之间（含0和9）的随机数。

echo $((RANDOM%10))

如果您使用的是Linux系统，则可以从/ dev / random或 / dev / urandom中获得随机数。请注意，如果没有足够的随机数，/ dev / random将被阻止。如果您需要速度超过随机性，请使用/ dev / urandom。

这些“文件”将填充由操作系统生成的随机数。如果获得真或伪随机数，则取决于系统上/ dev / random的实现。真正的随机数是借助从鼠标，硬盘驱动器，网络等设备驱动程序收集到的噪声形式生成的。

您可以使用dd从文件中获取随机数

我采纳了其中的一些想法，并制作了一个函数，如果需要大量随机数，该函数应该可以快速执行。

od如果您需要大量随机数，则通话费用很高。相反，我只调用它一次，并从/ dev / urandom中存储1024个随机数。当rand被调用时，最后一个随机数返回和缩放。然后将其从缓存中删除。当缓存为空时，将读取另外1024个随机数。

例：

rand 10; echo $RET

在RET中返回一个介于0和9之间（含0和9）的随机数。

declare -ia RANDCACHE
declare -i RET RAWRAND=$(( (1<<32)-1 ))

function rand(){  # pick a random number from 0 to N-1. Max N is 2^32
  local -i N=$1
  [[ ${#RANDCACHE[*]} -eq 0 ]] && { RANDCACHE=( $(od -An -tu4 -N1024 /dev/urandom) ); }  # refill cache
  RET=$(( (RANDCACHE[-1]*N+1)/RAWRAND ))  # pull last random number and scale
  unset RANDCACHE[${#RANDCACHE[*]}-1]     # pop read random number
};

# test by generating a lot of random numbers, then effectively place them in bins and count how many are in each bin.

declare -i c; declare -ia BIN

for (( c=0; c<100000; c++ )); do
  rand 10
  BIN[RET]+=1  # add to bin to check distribution
done

for (( c=0; c<10; c++ )); do
  printf "%d %d\n" $c ${BIN[c]} 
done

更新：并不是所有N都很好。如果与小N一起使用，也会浪费随机位。请注意（在这种情况下）32位随机数具有足够的熵，可以容纳0到9之间的9个随机数（10 * 9） = 1,000,000,000 <= 2 * 32）我们可以从每个32个随机源值中提取多个随机数。

#!/bin/bash

declare -ia RCACHE

declare -i RET             # return value
declare -i ENT=2           # keep track of unused entropy as 2^(entropy)
declare -i RND=RANDOM%ENT  # a store for unused entropy - start with 1 bit

declare -i BYTES=4         # size of unsigned random bytes returned by od
declare -i BITS=8*BYTES    # size of random data returned by od in bits
declare -i CACHE=16        # number of random numbers to cache
declare -i MAX=2**BITS     # quantum of entropy per cached random number
declare -i c

function rand(){  # pick a random number from 0 to 2^BITS-1
  [[ ${#RCACHE[*]} -eq 0 ]] && { RCACHE=( $(od -An -tu$BYTES -N$CACHE /dev/urandom) ); }  # refill cache - could use /dev/random if CACHE is small
  RET=${RCACHE[-1]}              # pull last random number and scale
  unset RCACHE[${#RCACHE[*]}-1]  # pop read random number
};

function randBetween(){
  local -i N=$1
  [[ ENT -lt N ]] && {  # not enough entropy to supply ln(N)/ln(2) bits
    rand; RND=RET       # get more random bits
    ENT=MAX             # reset entropy
  }
  RET=RND%N  # random number to return
  RND=RND/N  # remaining randomness
  ENT=ENT/N  # remaining entropy
};

declare -ia BIN

for (( c=0; c<100000; c++ )); do
  randBetween 10
  BIN[RET]+=1
done

for c in ${BIN[*]}; do
  echo $c
done

从/ dev / random或/ dev / urandom字符特殊文件中读取是一种方法。

这些设备在读取时会返回真正的随机数，旨在帮助应用程序软件选择安全密钥进行加密。从由各种随机事件贡献的熵池中提取这样的随机数。{LDD3，Jonathan Corbet，Alessandro Rubini和Greg Kroah-Hartman]

这两个文件是内核随机化的接口，特别是

void get_random_bytes_arch(void* buf, int nbytes)

如果此功能是由硬件实现的（通常是），则从硬件中抽取真正随机的字节，或者从熵池（由事件之间的定时组成，如鼠标和键盘中断以及在SA_SAMPLE_RANDOM中注册的其他中断之间的定时）提取。

dd if=/dev/urandom count=4 bs=1 | od -t d

这可行，但是将不需要的输出从ddstdout 写入。下面的命令仅给出我需要的整数。通过调整算术扩展的位掩码，我什至可以根据需要获得指定数量的随机位：

me@mymachine:~/$ x=$(head -c 1 /dev/urandom > tmp && hexdump 
                         -d tmp | head -n 1 | cut -c13-15) && echo $(( 10#$x & 127 ))

关于什么：

perl -e 'print int rand 10, "\n"; '

也许我为时已晚，但是使用jotBash在范围内生成随机数又如何呢？

jot -r -p 3 1 0 1

这将生成一个随机（-r）数字，精度为3个小数位-p。在这种情况下，您会得到一个介于0和1（1 0 1）之间的数字。您也可以打印顺序数据。根据手册，随机数的来源是：

如果未指定种子，则通过arc4random（3）获得随机数；如果给出种子，则通过random（3）获得随机数。

基于@ Nelson，@ Barun和@Robert的出色答案，这是一个生成随机数的Bash脚本。

• 可以生成您想要的位数。
• 每个数字都是单独生成的/dev/urandom，比Bash的内置数字好得多$RANDOM

#!/usr/bin/env bash

digits=10

rand=$(od -A n -t d -N 2 /dev/urandom |tr -d ' ')
num=$((rand % 10))
while [ ${#num} -lt $digits ]; do
  rand=$(od -A n -t d -N 1 /dev/urandom |tr -d ' ')
  num="${num}$((rand % 10))"
done
echo $num

生成0到n范围内的随机数（带符号的16位整数）。结果设置在$ RAND变量中。例如：

#!/bin/bash

random()
{
    local range=${1:-1}

    RAND=`od -t uI -N 4 /dev/urandom | awk '{print $2}'`
    let "RAND=$RAND%($range+1)"
}

n=10
while [ $(( n -=1 )) -ge "0" ]; do
    random 500
    echo "$RAND"
done

程序的随机分支或是/否；1/0; 正确/错误输出：

if [ $RANDOM -gt 16383  ]; then              # 16383 = 32767/2 
    echo var=true/1/yes/go_hither
else 
    echo var=false/0/no/go_thither
fi

如果您不愿记住16383：

if (( RANDOM % 2 )); then 
    echo "yes"
else 
    echo "no"
fi