La génération de nombres aléatoires est importante pour de nombreuses tâches. Il s’agit notamment du développement de jeux, de la cryptographie et de l’analyse de données. Les valeurs aléatoires permettent d’obtenir des résultats distincts avec un élément de variabilité et d’imprévisibilité.
Go fournit deux paquets pour générer des valeurs aléatoires dans la bibliothèque standard : math/rand et crypto/rand. Le site math/rand est principalement destiné aux opérations mathématiques. Le site crypto/rand Ce paquet gère les opérations sécurisées par la cryptographie.
Les paquets rand
Le site math/rand Le paquet Rand fournit une méthode flexible pour générer des nombres aléatoires. Il met en œuvre une variété de générations de nombres pseudo-aléatoires. Le paquetage peut générer un nombre aléatoire avec différentes distributions, et utiliser des graines pour contrôler la séquence aléatoire. Il peut également générer des nombres aléatoires simultanément ou en parallèle.
Le site crypto/rand Le paquetage Rand implémente un générateur de nombres aléatoires cryptographiquement sécurisé. Il comprend une fonctionnalité permettant de générer des nombres premiers aléatoires avec une probabilité élevée.
Comme ces paquets portent le même nom, vous devrez utiliser des alias si vous souhaitez les utiliser tous les deux dans un même programme, par exemple :
import (
crand "crypto/rand"
mrand "math/rand"
)
Génération d’entiers aléatoires en Go
Vous pouvez utiliser la fonction math/rand Intn Fonction permettant de générer des nombres aléatoires dans une plage.
import (
"fmt"
"math/rand"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
// Intn generates a random integer between 0 and 100
// (not including 100)
randomInt := rand.Intn(100)
fmt.Println(randomInt)
}
Ce code transmet l’heure actuelle à la fonction Graine Fonction. Elle initialise le générateur de nombres aléatoires par défaut pour le pseudo-aléatoire.
Le site Intn La fonction Rand du paquetage Rand génère un nombre aléatoire compris dans une plage spécifiée, dans ce cas, de 0 à 100.
Générer des nombres aléatoires à virgule flottante
Vous pouvez générer des nombres aléatoires à virgule flottante avec la fonction Float32 et Flottant64 fonctions. Elles renvoient respectivement des nombres à virgule flottante de 32 et 64 bits.
Voici comment générer des nombres aléatoires à virgule flottante de 64 bits en Go.
import (
"fmt"
"math/rand"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
// generate a random float64 between 0.0 and 1.0
randomFloat := rand.Float64()
fmt.Println(randomFloat)
}
Le processus de génération de nombres en virgule flottante 32 bits est le même que celui de génération de nombres aléatoires en virgule flottante 64 bits.
Génération de nombres aléatoires cryptographiquement sécurisés en Go
Vous pouvez utiliser la fonction Int fonction de la crypto/rand pour générer un nombre aléatoire sécurisé sur le plan cryptographique. Le site Int La fonction prend en compte une instance de lecteur et un nombre maximum pour la limite.
import (
"crypto/rand"
"fmt"
"math/big"
)
func main() {
// Create a big.Int with the maximum value for the desired range
max := big.NewInt(100000000)
// Generate a random big.Int
// The first argument is a reader that returns random numbers
// The second argument is the maximum value (not inclusive)
randInt, err := rand.Int(rand.Reader, max)
if err != nil {
fmt.Println("Error generating random number:", err)
return
}
fmt.Println("Random number:", randInt)
}
Le site max définit la valeur maximale du nombre aléatoire à l’aide de la variable NewInt de la fonction maths/grands paquet. Le site Int La fonction renvoie le nombre entier aléatoire et une erreur à traiter.
Génération de valeurs aléatoires cryptographiquement sécurisées
Le site crypto/rand ne fournit pas de fonctionnalité intégrée pour générer des chaînes aléatoires sécurisées sur le plan cryptographique. Néanmoins, vous pouvez contourner ce problème en utilisant la fonction Lire fonction.
import (
"crypto/rand"
"fmt"
)
func cryptoRandom(stringChars string, valueLength int32) string {
bytesSlice := make([]byte, valueLength)
_, err := rand.Read(bytesSlice)
if err != nil {
return "There was an error reading from the byte slice"
}
for pos, value := range bytesSlice {
randomize := value % byte(len(stringChars))
bytesSlice[pos] = stringChars[randomize]
}
return string(bytesSlice)
}
func main() {
fmt.Println(cryptoRandom("Pneumonoultram" +
"icroscopicsilicovolcanoconiosis", 10))
}
Le site cryptoRandom La fonction ci-dessus prend une chaîne de caractères pour générer une chaîne aléatoire. Elle prend également une longueur – un entier de 32 bits – et renvoie une chaîne.
Dans le fichier cryptoRandom la fonction bytesSlice La variable bytesSlice est une tranche de la longueur de chaîne requise. La boucle for-range parcourt la tranche d’octets et retourne et récupère le modulo des éléments de la tranche et la longueur de la chaîne en octets. Elle met à jour l’index de la tranche d’octets avec l’index de la valeur modulo de la chaîne.
Enfin, la fonction cryptoRandom renvoie le format de la chaîne de caractères de la tranche d’octets.
Vous pouvez générer des UUIDs avec Go
La génération de valeurs aléatoires est utile dans un grand nombre de cas. Si vous avez besoin de nombreuses valeurs uniques et aléatoires, vous pouvez utiliser des UUIDs.
Les UUID (Universally Unique Identifiers) garantissent l’unicité globale des identifiants. Vous pouvez les utiliser pour distinguer les ressources entre les systèmes tout en évitant les conflits de noms.
Il existe de nombreux paquets que vous pouvez utiliser pour générer des UUIDs en Go. Vous pouvez utiliser le paquet os pour appeler la commande uuid sur votre système d’exploitation, recourir au paquet UUID de Google, ou utiliser le paquet gouuid pour générer des UUID.
