One common task in programming is generating random numbers, which can be useful for a variety of applications such as simulations, games, cryptography, and more.

To generate a random number in Go (actually, it’s pseudo-random, but in this article, we will refer to it as random), you just need to use the Go built-in `math/rand`

package that provides functions for generating random numbers.

In the examples below, we will show you how to generate any random number, as well as how to create functions to generate random `int`

and `float64`

numbers in specific ranges.

In Go, the

`math/rand`

package provides functions to generate pseudo-random numbers. They are generated using an algorithm that produces a sequence of numbers that appear to be random, but are actually deterministic. The sequence of numbers produced by the algorithm can be replicated if the initial state or seed is known.Pseudo-random numbers are sufficient for most applications where randomness is required, such as games and simulations. However, in applications where security is a concern, such as cryptography, true random numbers should be used to ensure the highest level of randomness and unpredictability. In Go, the

`crypto/rand`

package provides functions to generate true random numbers.

## Generate any random integer number

To generate any integer random number in Go, just use the `Int()`

function from the `math/rand`

package. This function generates a non-negative random integer over the `[0, MaxInt]`

range.

As of Go 1.20, there is no need to set the seed before calling functions that generate random numbers, and the

`Seed()`

function is marked as deprecated.

```
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Printf("random integer: %d\n", rand.Int())
}
```

An example output:

```
random integer: 5696350091330895579
```

You can run this application a couple of times to see that you get different results each time.

The `math/rand`

package contains many methods to generate different types of random numbers, for example:

`func Int() int`

`func Intn(n int) int`

`func Int63() int64`

`func Int63n(n int64) int64`

`func Uint64() uint64`

`func Float64() float64`

- and some more

See the package documentation for more information.

## Generate a random `float64`

number

In the same way as an integer, you can also generate a random floating-point number. The only thing you need to be aware of is that the `Float64()`

function (and other floating-point functions) generate a number in the range `[0.0,1.0)`

.

```
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Printf("random float64: %f\n", rand.Float64())
}
```

Output:

```
random float64: 0.764513
```

## Generate a random `int`

number over a range

In many use cases, however, you need to generate a number in a given range, such as an integer in the range `[5,10)`

, instead of a completely arbitrary integer. There is no function in the `math/rand`

package that does this automatically, but we can use the `Intn(n int)`

function to achieve a similar result. This function returns a random number in the range `[0, n)`

, so to get a value in the range `[min, max)`

we can generate a value from `[0, max-min)`

using this function, and add `min`

to the result.

Look at the example to see exactly how it is done.

```
package main
import (
"fmt"
"math/rand"
)
func randInt(min, max int) int {
return min + rand.Intn(max-min)
}
func main() {
fmt.Printf("random integer in range [5, 10): %d\n", randInt(5, 10))
}
```

Output:

```
random integer in range [5, 10): 6
```

## Generate a random `float64`

number in a given range

In a similar way as for integers, you can generate a random floating-point number from the range `[min, max)`

. In the following example, we create the `randFloat()`

function for this purpose. It uses the built-in function `rand.Float64()`

to generate a number in the range `[0, 1)`

. This number is then multiplied times `(max-min)`

and shifted by the value of `min`

to get a number in the range `[min, max)`

.

```
package main
import (
"fmt"
"math/rand"
)
func randFloat(min, max float64) float64 {
return min + rand.Float64()*(max-min)
}
func main() {
fmt.Printf("random float64 in range [2.4, 3.2): %f\n", randFloat(2.4, 3.2))
}
```

Output:

```
random float64 in range [2.4, 3.2): 3.142109
```