我已经采取了一些这些想法，并做出了一个函数，应该执行迅速，如果大量的随机数是必需的。

如果你需要很多随机数，调用od的代价是很高的。相反，我只调用它一次，并存储来自/dev/urandom的1024个随机数。当调用rand时，返回最后一个随机数并按比例缩放。然后从缓存中删除它。当缓存为空时，再读取1024个随机数。

例子:

rand 10; echo $RET

返回RET中0到9(含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位随机数有足够的熵容纳9个0到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

生成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

生成随机的3位数字

这对于创建示例数据非常有用。示例:将所有测试数据放在名为“test-create-volume-123”的目录中，然后在测试完成后，删除整个目录。通过生成恰好三个数字，就不会有奇怪的排序问题。

printf '%02d\n' $((1 + RANDOM % 100))

这是按比例缩小的，例如到一个数字:

printf '%01d\n' $((1 + RANDOM % 10))

它可以放大，但只能放大到四位数。原因见上文:)

使用随机的美元。它通常与简单的shell算法结合使用很有用。例如，要生成1到10(包括)之间的随机数:

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

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

如果你在做一些需要大量随机数的事情，你可以使用/dev/random或/dev/urandom(如果它们可用的话):

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

这里有$RANDOM。 我不知道具体是怎么回事。但它确实有效。 对于测试，您可以执行:

echo $RANDOM