Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat. Citeşte mai mult.

Generarea numerelor aleatorii este importantă pentru multe sarcini. Acestea includ dezvoltarea jocurilor, criptografia și analiza datelor. Valorile aleatorii permit rezultate distincte cu un element de variabilitate și imprevizibilitate.

Go oferă două pachete pentru generarea de valori aleatorii în biblioteca standard: matematică/rand și cripto/rand. The matematică/rand pachetul este în principal pentru operații matematice. The cripto/rand pachetul gestionează operațiuni securizate criptografic.

Pachetele rand

The matematică/rand pachetul oferă o metodă flexibilă pentru generand numere aleatorii. Implementează o varietate de generații de numere pseudo-aleatoare. Pachetul poate genera un număr aleator cu distribuții diferite și poate folosi semințe pentru a controla secvența aleatoare. De asemenea, poate genera numere aleatoare concomitent sau în paralel.

instagram viewer

The cripto/rand pachetul implementează un generator de numere aleatoare sigur din punct de vedere criptografic. Include funcționalitate pentru a genera numere prime aleatorii cu probabilitate mare.

Deoarece aceste pachete au același nume, va trebui să utilizați aliasuri dacă doriți să folosiți ambele într-un singur program, de exemplu:

import (
 crand "cripto/rand"
 Domnul si "matematică/rand"
)

Generarea numerelor întregi aleatorii în Go

Puteți folosi matematică/randIntn funcția de a genera numere aleatorii într-un interval.

import (
"fmt"
"matematică/rand"
"timp"
)
funcprincipal() {
 rand. Sămânță (timp. Acum().UnixNano())


// Intn generează un număr întreg aleatoriu între 0 și 100 
// (neincluzând 100)
 randomInt := rand. Intn(100) 
 fmt. Println (randomInt)
}

Acest cod transmite ora curentă către Sămânță funcţie. Inițializează generatorul implicit de numere aleatoare pentru pseudo-aleatorie.

The Intn funcția pachetului rand generează un număr aleator între un interval specificat, în acest caz, de la 0 la 100.

Generați numere aleatorii în virgulă mobilă

Puteți genera numere aleatorii în virgulă mobilă cu ajutorul Plutitor32 și Float64 funcții. Acestea returnează numere în virgulă mobilă pe 32 de biți și, respectiv, pe 64 de biți.

Iată cum puteți genera numere aleatoare cu virgulă mobilă pe 64 de biți în Go.

import (
"fmt"
"matematică/rand"
"timp"
)
funcprincipal() {
 rand. Sămânță (timp. Acum().UnixNano())


// generează un float64 aleatoriu între 0.0 și 1.0
 randomFloat := rand. Float64()
 fmt. Println (randomFloat)
}

Procesul de generare a numerelor în virgulă mobilă pe 32 de biți este același cu generarea de numere în virgulă mobilă aleatorie pe 64 de biți.

Generarea de numere aleatoare securizate criptografic în Go

Puteți folosi Int funcția de cripto/rand pachet pentru a genera un număr aleator criptografic sigur. The Int funcția preia o instanță de citire și un număr maxim pentru limită.

import (
"cripto/rand"
"fmt"
"matematic/mare"
)
funcprincipal() {
// Creați un mare. Int cu valoarea maximă pentru intervalul dorit
 max := mare. NewInt(100000000)

// Generați un big aleatoriu. Int
// Primul argument este un cititor care returnează numere aleatorii
// Al doilea argument este valoarea maximă (nu este inclusiv)
 randInt, err := rand. Int (rand. Cititor, max)
dacă greș!= zero {
 fmt. Println(„Eroare la generarea numărului aleatoriu:”, greseala)
întoarcere
 }

 fmt. Println("Număr aleatoriu:", randInt)
}

The max variabila definește valoarea maximă pentru numărul aleatoriu folosind NewInt funcția de matematică/mare pachet. The Int funcția returnează întregul aleator și o eroare de manipulare.

Generarea de valori aleatorii securizate criptografic

The cripto/rand pachetul nu oferă funcționalitate încorporată pentru generare sigur din punct de vedere criptografic șiruri aleatorii. Totuși, puteți rezolva acest lucru folosind Citit funcţie.

import (
"cripto/rand"
"fmt"
)
funccriptoRandom(stringChars şir, valueLength int32)şir {
 bytesSlice := face([]octet, valueLength)
 _, err := rand. Citire (bytesSlice)


dacă greș!= zero {
întoarcere„A apărut o eroare la citirea din porțiunea de octeți”
 }


pentru poz, valoare := gamă bytesSlice {
 randomize := valoare % octet(len(stringChars))
 bytesSlice[poz] = stringChars[randomize]
 }


întoarcereşir(bytesSlice)
}
funcprincipal() {
 fmt. Println (cryptoRandom(„Pneumonoultram” +
"icroscopicsilicovulcanoconiosis", 10))
}

The criptoRandom funcția de mai sus preia un șir din care să genereze un șir aleator. De asemenea, ia o lungime - un număr întreg de 32 de biți - și returnează un șir.

În criptoRandom funcția, cea bytesSlice variabila este o porțiune din lungimea șirului necesară. Bucla for-range traversează porțiunea de octeți și returnează și preia modulul elementelor secțiunii și lungimea șirului în octeți. Acesta actualizează indexul secțiunii de octeți cu indexul valorii modulo al șirului.

În cele din urmă, cel criptoRandom funcția returnează formatul șirului de octeți.

Puteți genera UUID-uri cu Go

Generarea de valori aleatoare este utilă pentru o gamă largă de cazuri de utilizare. Dacă aveți nevoie de multe valori aleatorii, unice, puteți utiliza UUID-uri.

UUID-urile (Universally Unique Identifiers) asigură unicitatea globală pentru identificatori. Le puteți folosi pentru a distinge resursele între sisteme, evitând în același timp conflictele de denumire.

Există multe pachete pe care le puteți folosi pentru a genera UUID-uri în Go. Puteți folosi pachetul OS pentru a apela uuid comanda pe sistemul dvs. de operare, apelați la pachetul UUID de la Google sau utilizați pachetul gouuid pentru a genera UUID-uri.