go语言生成随机数和随机字符串的实现方法

生成随机数

随机数的生成是计算机科学的一个研究领域，同时也是一种艺术。这是因为计算机是纯粹的逻辑机器，所以使用计算机生成随机数异常困难！

你可以用 math/rand 包来生成随机数。开始生成随机数之前首先需要一个种子，种子用于整个过程的初始化，它相当重要。因为如果你每次都用同样的种子初始化，那么就总是会得到相同的随机数序列。这意味着每个人都可以重新生成同一个序列，那这个序列就根本不能再算是随机的了！

我们将用来生成随机数的程序名为 randomnumbers.go，下面分成四个部分进行介绍。这个程序需要几个参数，分别是生成随机数的下限、生成随机数的上限、生成随机数的数量。如果你还用了第四个命令参数，那么程序会将它作为随机数生成器的种子。在测试的时候，你就可以再次使用这个参数生成相同的数列。

程序的第一部分如下所示：

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "time"
)

func random(min, max int) int {
    return rand.intn(max-min) + min
}

random() 函数完成了所有的工作，它通过根据指定的范围调用 rand.intn() 生成随机数。

这个命令行程序的第二部分如下：

func main() {
    min := 0
    max := 100
    total := 100
    seed := time.now().unix()

    arguments := os.args

这一部分对程序中将会用到的变量进行了初始化。

randomnumbers.go 的第三部分包含如下的 go 代码：

    switch len(arguments) {
    case 2:
        fmt.println("usage: ./randomnumbers min max total seed")
        min, _ = strconv.atoi(arguments[1])
        max = min + 100
    case 3:
        fmt.println("usage: ./randomnumbers min max total seed")
        min, _ = strconv.atoi(arguments[1])
        max, _ = strconv.atoi(arguments[2])
    case 4:
        fmt.println("usage: ./randomnumbers min max total seed")
        min, _ = strconv.atoi(arguments[1])
        max, _ = strconv.atoi(arguments[2])
        total, _ = strconv.atoi(arguments[3])
    case 5:
        min, _ = strconv.atoi(arguments[1])
        max, _ = strconv.atoi(arguments[2])
        total, _ = strconv.atoi(arguments[3])
        seed, _ = strconv.parseint(arguments[4], 10, 64)
    default:
        fmt.println("using default values!")
    }

switch 代码块背后的逻辑相对简单：根据命令行参数的数量决定程序中的参数是使用缺省的默认值还是使用用户提供的值。为了简化程序，strconv.atoi() 和 strconv.parseint() 函数返回的 error 参数使用下划线字符接收，然后被忽略。如果是商业程序就千万不能忽略 strconv.atoi() 和 strconv.parseint() 函数返回的 error 参数！

最后，使用 strconv.parseint() 对 seed 变量赋新的值是因为 rand.seed() 函数要求的参数类型是 int64。strconv.parseint() 的第一个参数是要解析的字符串，第二个参数是输出数的基数，第三个参数是输出数的位数。由于我们想要生成的是一个 64 位的十进制整数，所以使用 10 作为基数，使用 64 作为位数。注意，如果你想解析无符号的整数的话应该使用 strconv.parseuint() 函数代替。

randomnumbers.go 的最后一部分是如下的 go 代码：

    rand.seed(seed)
    for i := 0; i < total; i++ {
        myrand := random(min, max)
        fmt.print(myrand)
        fmt.print(" ")
    }
    fmt.println()
}

除了使用 unix 时间戳作为随机数生成器的种子，你还可以使用 /dev/random 这个系统设备。你可以在第 8 章“go unix系统编程”中了解 /dev/random 的相关内容。

执行 randomnumbers.go 将会生成如下输出：

$ go run randomnumbers.go
75 69 15 75 62 67 64 8 73 1 83 92 7 34 8 70 22 58 38 8 54 91 65 1 50 76 5 82 61 90 10 38 40 63 6 28 51 54 49 27 52 92 76 35 44 9 66 76 90 10 29 22 20 83 33 92 80 50 62 26 19 45 56 75 40 30 97 23 87 10 43 11 42 65 80 82 25 53 27 51 99 88 53 36 37 73 52 61 4 81 71 57 30 72 51 55 62 63 79
$ go run randomnumbers.go 1 3 2
usage: ./randomnumbers min max total seed
1 1 
$ go run randomnumbers.go 1 3 2
usage: ./randomnumbers min max total seed
2 2
$ go run randomnumbers.go 1 5 10 10
3 1 4 4 1 1 4 4 4 3
$ go run randomnumbers.go 1 5 10 10
3 1 4 4 1 1 4 4 4 3

如果你对随机数生成真的很有兴趣，那么你应该先读一下 donald e.knuth 写的 the art of computer programming (addison-wesley professional, 2011) 的第二卷。

如果需要用 go 生成更安全的随机数的话，你可以使用 crypto/rand 包。这个包中实现了满足密码学安全的伪随机数生成器。你可以在 https://golang.org/pkg/crypto/rand/ 文档页面了解更多关于 crypto/rand 包的信息。

生成随机字符串

一旦你知道了计算机是如何呈现出单个字符，从随机数过渡到随机字符串就不难了。这一节将会介绍如何使用前一节中 randomnumbers.go 的代码生成难以猜出的密码。用于完成这个任务的 go 程序叫做 generatepassword.go，下面将分四个部分进行介绍。这个程序只需要一个命令行参数，就是你需要生成的密码的长度。

generatepassword.go 的第一部分包含如下的 go 代码：

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "time"
)

func random(min, max int) int {
    return rand.intn(max-min) + min
}

generatepassword.go 的第二个代码段如下：

func main() {
    min := 0
    max := 94
    seed := time.now().unix()
    var length int64 = 8

    arguments := os.arg

我们只想得到可打印的 ascii 字符，所以对生成随机数的范围进行了限制。ascii 字符表中可打印的字符一共有 94 个。这意味着该程序生成的随机数的范围应该是从 0 到 94 且不包括 94。

generatepassword.go 的第三个代码段如下：

    switch len(arguments) {
    case 2:
        length, _ = strconv.parseint(os.args[1], 10, 64)
    default:
        fmt.println("using default values!")
    }

       rand.seed(seed)

generatepassword.go 的最后一部分如下：

    startchar := "!"
    var i int64 = 1
    for {
        myrand := random(min, max)
        newchar := string(startchar[0] + byte(myrand))
        fmt.print(newchar)
        if i == length {
            break
        }
        i++
    }
    fmt.println()
}

startchar 参数保存了这个程序可以生成的第一个 ascii 字符，也就是十进制 ascii 值为 33 的感叹号。已知该程序生成的随机数小于 94，可以计算出生成的最大的 ascii 值为 93 + 33，等于 126，也就是 ~ 的 ascii 值。下面的输出是含有十进制数值的 ascii 字符表：

the decimal set:

  0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel
  8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si
 16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb
 24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us
 32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '
 40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /
 48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7
 56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?
 64  @    65  a    66  b    67  c    68  d    69  e    70  f    71  g
 72  h    73  i    74  j    75  k    76  l    77  m    78  n    79  o
 80  p    81  q    82  r    83  s    84  t    85  u    86  v    87  w
 88  x    89  y    90  z    91  [    92  \    93  ]    94  ^    95  _
 96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g
104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o
112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w
120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del

在你最喜欢的 unix shell 中输入 man ascii 就能生成易读的 ascii 字符表。

执行 generatepassword.go 并传入合适的命令行参数将生成如下输出：

$ go run generatepassword.go
using default values!
ugs$5mv1
$ go run generatepassword.go
using default values!
pa/8ha@?
$ go run generatepassword.go 20
hbr+=3\ua'b@ext4qg|o
$ go run generatepassword.go 20
xlcr|r{*px/::'t2u^t'

到此这篇关于go语言生成随机数和随机字符串的实现方法的文章就介绍到这了,更多相关go语言生成随机数和随机字符串内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！