Az Önhöz hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk. Olvass tovább.

A véletlenszám-generálás számos feladatnál fontos. Ide tartozik a játékfejlesztés, a kriptográfia és az adatelemzés. A véletlenszerű értékek különböző kimeneteleket tesznek lehetővé, a változékonyság és a kiszámíthatatlanság elemével.

A Go két csomagot biztosít a véletlen értékek generálásához a szabványos könyvtárban: matek/rand és kripto/rand. A matek/rand csomag elsősorban matematikai műveletekre vonatkozik. A kripto/rand csomag kriptográfiailag biztonságos műveleteket kezel.

A rand csomagok

A matek/rand csomag rugalmas módszert biztosít véletlen számok generálása. Számos pszeudo-véletlen számgenerálást valósít meg. A csomag különböző eloszlású véletlenszámokat generálhat, és magokat használhat a véletlenszerű sorrend szabályozására. Véletlen számokat is generálhat egyidejűleg vagy párhuzamosan.

A kripto/rand csomag kriptográfiailag biztonságos véletlenszám-generátort valósít meg. Ez magában foglalja a véletlenszerű prímszámok nagy valószínűséggel történő generálására szolgáló funkciókat.

instagram viewer

Mivel ezeknek a csomagoknak ugyanaz a neve, álneveket kell használnia, ha mindkettőt egyetlen programban szeretné használni, például:

import (
 crand "crypto/rand"
 mrand "matematika/rand"
)

Véletlenszerű egész számok generálása a Go-ban

Használhatja a matematika/randIntn függvény véletlen számok generálására egy tartományban.

import (
"fmt"
"matematika/rand"
"idő"
)
funcfő-() {
 rand. Mag (idő. Most().UnixNano())


// Az Intn véletlenszerű egész számot generál 0 és 100 között 
// (100 nélkül)
 randomInt := rand. Intn(100) 
 fmt. Println (randomInt)
}

Ez a kód átadja az aktuális időt a Mag funkció. Inicializálja az alapértelmezett véletlenszám-generátort a pszeudo-véletlenséghez.

A Intn A rand csomag függvénye véletlen számot generál egy megadott tartomány között, ebben az esetben 0 és 100 között.

Véletlenszerű lebegőpontos számokat generál

Véletlenszerű lebegőpontos számokat generálhat a Úszó32 és Úszó64 funkciókat. 32 bites, illetve 64 bites lebegőpontos számokat adnak vissza.

Így generálhat véletlenszerű 64 bites lebegőpontos számokat a Go alkalmazásban.

import (
"fmt"
"matematika/rand"
"idő"
)
funcfő-() {
 rand. Mag (idő. Most().UnixNano())


// véletlenszerű float64 generálása 0.0 és 1.0 között
 randomFloat := rand. Float64()
 fmt. Println (randomFloat)
}

A 32 bites lebegőpontos számok előállításának folyamata megegyezik a véletlenszerű 64 bites lebegőpontos számok generálásával.

Kriptográfiailag biztonságos véletlenszámok generálása a Go-ban

Használhatja a Int funkciója kripto/rand csomag kriptográfiailag biztonságos véletlenszám generálásához. A Int függvény egy olvasópéldányt és egy maximális számot vesz fel a korláthoz.

import (
"crypto/rand"
"fmt"
"matematika/nagy"
)
funcfő-() {
// Hozzon létre egy nagyot. Int a kívánt tartomány maximális értékével
 max := nagy. NewInt(100000000)

// Véletlen nagy generálása. Int
// Az első argumentum egy olvasó, amely véletlen számokat ad vissza
// A második argumentum a maximális érték (nem tartalmazza)
 randInt, err := rand. Int (rand. olvasó, max)
ha hiba! = nulla {
 fmt. Println("Hiba a véletlen szám generálásakor:", hiba)
Visszatérés
 }

 fmt. Println("Véletlen szám:", randInt)
}

A max változó határozza meg a véletlen szám maximális értékét a NewInt funkciója matek/nagy csomag. A Int függvény a véletlenszerű egész számot és a kezelési hibát adja vissza.

Kriptográfiailag biztonságos véletlenszerű értékek generálása

A kripto/rand csomag nem biztosít beépített funkciót a generáláshoz kriptográfiailag biztonságos véletlenszerű karakterláncok. Ennek ellenére megkerülheti ezt a lehetőséget a Olvas funkció.

import (
"crypto/rand"
"fmt"
)
funccryptoRandom(karakterláncok húr, valueLength int32)húr {
 bytesSlice := készítsenek([]byte, valueLength)
 _, err := rand. Olvasás (bytesSlice)


ha hiba! = nulla {
Visszatérés"Hiba történt a bájtszelet olvasása közben"
 }


számára poz, érték := hatótávolság bytesSlice {
 véletlenszerű := érték % byte(len(karakterláncok))
 bytesSlice[pos] = stringChars[randomize]
 }


Visszatéréshúr(bytesSlice)
}
funcfő-() {
 fmt. Println (cryptoRandom("Pneumonoultram" +
"ikroszkópos szilikovulkanokoniózis", 10))
}

A cryptoRandom A fenti függvény egy karakterláncot vesz fel, amelyből véletlenszerű karakterláncot generál. Ezenkívül egy hosszúságot vesz igénybe – egy 32 bites egész számot –, és egy karakterláncot ad vissza.

Ban,-ben cryptoRandom funkció, a bytesSlice változó a szükséges karakterlánc-hosszúság egy szelete. A for-range ciklus bejárja a bájtszeletet, és visszaadja és lekéri a szelet elemeinek modulusát és a karakterlánc hosszát bájtokban. Frissíti a bájtszelet indexét a karakterlánc modulo érték indexével.

Végül a cryptoRandom függvény a bájtszelet karakterlánc-formátumát adja vissza.

A Go segítségével UUID-ket generálhat

A véletlenszerű értékek generálása a felhasználási esetek széles körében jól jöhet. Ha sok véletlenszerű, egyedi értékre van szüksége, használhat UUID-t.

Az UUID-k (Universally Unique Identifiers) biztosítják az azonosítók globális egyediségét. Segítségükkel megkülönböztetheti az erőforrásokat a rendszerek között, miközben elkerülheti az elnevezési ütközéseket.

Számos csomag használható UUID-k generálására a Go-ban. Használhatja az os csomagot az uuid hívásához parancsot az operációs rendszerén, használja a Google UUID-csomagját, vagy használja a gouuid csomagot a generáláshoz UUID-k.