La génération de nombres aléatoires est importante pour de nombreuses tâches. Ceux-ci incluent le développement de jeux, la cryptographie et l'analyse de données. Les valeurs aléatoires permettent des résultats distincts avec un élément de variabilité et d'imprévisibilité.
Go fournit deux packages pour générer des valeurs aléatoires dans la bibliothèque standard: mathématiques/rands et crypto/rand. Le mathématiques/rands package est principalement pour les opérations mathématiques. Le crypto/rand package gère les opérations cryptographiquement sécurisées.
Les forfaits rand
Le mathématiques/rands offre une méthode flexible pour générer des nombres aléatoires. Il implémente une variété de générations de nombres pseudo-aléatoires. Le package 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 crypto/rand package implémente un générateur de nombres aléatoires cryptographiquement sécurisé. Il inclut une fonctionnalité pour générer des nombres premiers aléatoires avec une probabilité élevée.
Étant donné que ces packages portent le même nom, vous devrez utiliser des alias si vous souhaitez utiliser les deux dans un même programme, par exemple :
importer (
crand "crypto/rand"
M. et "mathématiques/rands"
)
Génération d'entiers aléatoires en Go
Vous pouvez utiliser le maths/randsinternational fonction pour générer des nombres aléatoires dans une plage.
importer (
"fmt"
"mathématiques/rands"
"temps"
)fonctionprincipal() {
rand. Graine (temps. Maintenant().UnixNano())// Intn génère un entier aléatoire entre 0 et 100
// (non compris 100)
randomInt := rand. International(100)
fmt. Println (randomInt)
}
Ce code transmet l'heure actuelle au Graine fonction. Il initialise le générateur de nombres aléatoires par défaut pour le pseudo-aléatoire.
Le international fonction du package rand génère un nombre aléatoire entre une plage spécifiée, dans ce cas, 0 à 100.
Générer des nombres aléatoires à virgule flottante
Vous pouvez générer des nombres à virgule flottante aléatoires avec le Float32 et Flotteur64 les fonctions. Ils renvoient respectivement des nombres à virgule flottante 32 bits et 64 bits.
Voici comment vous pouvez générer des nombres à virgule flottante 64 bits aléatoires dans Go.
importer (
"fmt"
"mathématiques/rands"
"temps"
)fonctionprincipal() {
rand. Graine (temps. Maintenant().UnixNano())// génère un float64 aléatoire entre 0.0 et 1.0
randomFloat := rand. Float64()
fmt. Println (randomFloat)
}
Le processus de génération de nombres à virgule flottante 32 bits est le même que celui de génération de nombres à virgule flottante 64 bits aléatoires.
Génération de nombres aléatoires cryptographiquement sécurisés dans Go
Vous pouvez utiliser le Int fonction de la crypto/rand package pour générer un nombre aléatoire cryptographiquement sécurisé. Le Int La fonction prend une instance de lecteur et un nombre maximum pour la limite.
importer (
"crypto/rand"
"fmt"
"mathématiques/grand"
)fonctionprincipal() {
// Crée un grand. Int avec la valeur maximale pour la plage souhaitée
max := grand. NouvelEntier(100000000)
// Génère un big. Int
// Le premier argument est un lecteur qui renvoie des nombres aléatoires
// Le deuxième argument est la valeur maximale (non inclus)
randInt, erreur := rand. Int (rand. Lecteur, max)
si erreur != néant {
fmt. Imprimerln("Erreur lors de la génération du nombre aléatoire :", euh)
retour
}
fmt. Imprimerln("Nombre aléatoire:", randEntier)
}
Le maximum définit la valeur maximale du nombre aléatoire à l'aide de la NouvelEntier fonction de la maths/grand emballer. Le Int La fonction renvoie l'entier aléatoire et une erreur de traitement.
Génération de valeurs aléatoires cryptographiquement sécurisées
Le crypto/rand package ne fournit pas de fonctionnalité intégrée pour générer cryptographiquement sécurisé chaînes aléatoires. Néanmoins, vous pouvez contourner ce problème en utilisant le Lire fonction.
importer (
"crypto/rand"
"fmt"
)fonctioncrypto-aléatoire(chaîneChars chaîne, valeurLongueur int32)chaîne {
bytesSlice := faire([]octet, valeurLongueur)
_, euh := rand. Lire (bytesSlice)si erreur != néant {
retour"Une erreur s'est produite lors de la lecture de la tranche d'octet"
}pour pos, valeur := gamme bytesSlice {
randomiser := valeur % octet(len(stringChars))
bytesSlice[pos] = stringChars[randomize]
}retourchaîne(bytesSlice)
}
fonctionprincipal() {
fmt. Println (cryptoRandom("Pneumonoultram" +
"silicovolcanoconiose microscopique", 10))
}
Le crypto-aléatoire La fonction ci-dessus prend une chaîne pour générer une chaîne aléatoire à partir de. Il prend également une longueur (un entier de 32 bits) et renvoie une chaîne.
Dans le crypto-aléatoire fonction, la bytesSlice variable est une tranche de la longueur de chaîne requise. La boucle for-range traverse la tranche d'octets et renvoie et récupère le module des éléments de la tranche et la longueur de la chaîne en octets. Il met à jour l'index de la tranche d'octet avec l'index de valeur modulo de la chaîne.
Finalement, le crypto-aléatoire La fonction renvoie le format de chaîne de la tranche d'octets.
Vous pouvez générer des UUID avec Go
La génération de valeurs aléatoires est pratique pour un large éventail de cas d'utilisation. Si vous avez besoin de nombreuses valeurs aléatoires et uniques, vous pouvez utiliser des UUID.
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 nommage.
Il existe de nombreux packages que vous pouvez utiliser pour générer des UUID dans Go. Vous pouvez utiliser le package os pour appeler l'uuid sur votre système d'exploitation, utilisez le package UUID de Google ou utilisez le package gouuid pour générer UUID.
