יצירת מספרים אקראית חשובה למשימות רבות. אלה כוללים פיתוח משחקים, קריפטוגרפיה וניתוח נתונים. ערכים אקראיים מאפשרים תוצאות ברורות עם אלמנט של שונות ובלתי צפויות.
Go מספקת שתי חבילות ליצירת ערכים אקראיים בספרייה הסטנדרטית: מתמטיקה/רנד ו קריפטו/ראנד. ה מתמטיקה/רנד החבילה מיועדת בעיקר לפעולות מתמטיות. ה קריפטו/ראנד החבילה מטפלת בפעולות מאובטחות מבחינה קריפטוגרפית.
חבילות הראנד
ה מתמטיקה/רנד החבילה מספקת שיטה גמישה עבור יצירת מספרים אקראיים. הוא מיישם מגוון של דורות מספרים פסאודו-אקראיים. החבילה יכולה ליצור מספר אקראי עם הפצות שונות, ולהשתמש ב-seeds כדי לשלוט ברצף האקראי. זה יכול גם ליצור מספרים אקראיים במקביל או במקביל.
ה קריפטו/ראנד החבילה מיישמת מחולל מספרים אקראיים מאובטח מבחינה קריפטוגרפית. זה כולל פונקציונליות ליצירת מספרים ראשוניים אקראיים עם הסתברות גבוהה.
מכיוון שלחבילות אלו יש שם זהה, תצטרך להשתמש בכינויים אם תרצה להשתמש בשתיהן בתוכנית אחת, למשל:
יְבוּא (
קרנד "קריפטו/ראנד"
מרנד "מתמטיקה/רנד"
)
יצירת מספרים שלמים אקראיים ב-Go
אתה יכול להשתמש ב מתמטיקה/רנדIntn פונקציה ליצירת מספרים אקראיים בטווח.
יְבוּא (
"fmt"
"מתמטיקה/רנד"
"זְמַן"
)funcרָאשִׁי() {
ראנד. זרע (זמן. Now().UnixNano())// Intn יוצר מספר שלם אקראי בין 0 ל-100
// (לא כולל 100)
randomInt := רנד. Intn(100)
fmt. Println (randomInt)
}
קוד זה מעביר את הזמן הנוכחי ל- זֶרַע פוּנקצִיָה. הוא מאתחל את מחולל המספרים האקראיים המוגדרים כברירת מחדל עבור פסאודו-אקראי.
ה Intn הפונקציה של חבילת rand יוצרת מספר אקראי בין טווח מוגדר, במקרה זה, 0 עד 100.
צור מספרים אקראיים של נקודה צפה
אתה יכול ליצור מספרי נקודה צפה אקראית עם Float32 ו Float64 פונקציות. הם מחזירים מספרי נקודה צפה של 32 סיביות ו-64 סיביות בהתאמה.
כך תוכל ליצור מספרי נקודה צפה אקראית של 64 סיביות ב-Go.
יְבוּא (
"fmt"
"מתמטיקה/רנד"
"זְמַן"
)funcרָאשִׁי() {
ראנד. זרע (זמן. Now().UnixNano())// צור צף אקראי64 בין 0.0 ל-1.0
randomFloat := רנד. Float64()
fmt. Println (randomFloat)
}
התהליך של יצירת מספרי נקודה צפה של 32 סיביות זהה ליצירת מספרי נקודה צפה אקראית של 64 סיביות.
יצירת מספרים אקראיים מאובטחים באופן קריפטוגרפי ב-Go
אתה יכול להשתמש ב Int פונקציה של קריפטו/ראנד חבילה ליצירת מספר אקראי מאובטח מבחינה קריפטוגרפית. ה Int הפונקציה לוקחת מופע קורא ומספר מקסימלי עבור המגבלה.
יְבוּא (
"קריפטו/ראנד"
"fmt"
"מתמטיקה/גדול"
)funcרָאשִׁי() {
// צור גדול. Int עם הערך המקסימלי עבור הטווח הרצוי
מקסימום := גדול. NewInt(100000000)
// צור גדול אקראי. Int
// הארגומנט הראשון הוא קורא שמחזיר מספרים אקראיים
// הארגומנט השני הוא הערך המקסימלי (לא כולל)
randInt, err := rand. אינט (רנד. קורא, מקסימום)
אם טעות != אֶפֶס {
fmt. Println("שגיאה ביצירת מספר אקראי:", טעות)
לַחֲזוֹר
}
fmt. Println("מספר אקראי:", randInt)
}
ה מקסימום המשתנה מגדיר את הערך המקסימלי עבור המספר האקראי באמצעות ה- NewInt פונקציה של מתמטיקה/גדול חֲבִילָה. ה Int הפונקציה מחזירה את המספר השלם האקראי ושגיאה לטיפול.
יצירת ערכים אקראיים מאובטחים בצורה קריפטוגרפית
ה קריפטו/ראנד החבילה אינה מספקת פונקציונליות מובנית להפקה מאובטח מבחינה קריפטוגרפית מחרוזות אקראיות. ובכל זאת, אתה יכול לעקוף את זה באמצעות ה לקרוא פוּנקצִיָה.
יְבוּא (
"קריפטו/ראנד"
"fmt"
)funccryptoRandom(stringChars חוּט, valueLength int32)חוּט {
bytesSlice := עשה([]בייט, valueLength)
_, טעות := רנד. קרא (bytesSlice)אם טעות != אֶפֶס {
לַחֲזוֹר"היתה שגיאה בקריאה מפרוסת הבתים"
}ל pos, ערך := טווח bytesSlice {
אקראי := ערך % בייט(לן(stringChars))
bytesSlice[pos] = stringChars[אקראי]
}לַחֲזוֹרחוּט(bytesSlice)
}
funcרָאשִׁי() {
fmt. Println (cryptoRandom("פנאומונוולטרם" +
"איקרוסקופית סיליקווולקנוקונוזיס", 10))
}
ה cryptoRandom הפונקציה למעלה לוקחת מחרוזת כדי ליצור ממנה מחרוזת אקראית. זה גם לוקח אורך - מספר שלם של 32 סיביות - ומחזיר מחרוזת.
בתוך ה cryptoRandom פונקציה, ה bytesSlice המשתנה הוא פרוסה באורך המחרוזת הנדרש. לולאת ה-for-range חוצה את פרוסת הבתים ומחזירה ומחזירה את המודולוס של רכיבי הפרוסה ואת אורך המחרוזת בבתים. הוא מעדכן את האינדקס של פרוסת הבתים עם אינדקס ערך המודולו של המחרוזת.
סוף - סוף, ה cryptoRandom הפונקציה מחזירה את פורמט המחרוזת של פרוסת הבתים.
אתה יכול ליצור UUIDs עם Go
יצירת ערכים אקראיים שימושית עבור מגוון רחב של מקרי שימוש. אם אתה צריך הרבה ערכים אקראיים וייחודיים, אתה יכול להשתמש ב-UUID.
UUIDs (Universally Unique Identifiers) מבטיחים ייחודיות גלובלית למזהים. אתה יכול להשתמש בהם כדי להבחין בין משאבים בין מערכות תוך הימנעות מהתנגשויות בשמות.
ישנן חבילות רבות בהן תוכל להשתמש כדי ליצור UUIDs ב-Go. אתה יכול להשתמש בחבילת OS כדי לקרוא ל-uuid פקודה במערכת ההפעלה שלך, השתמש בחבילת UUID של Google, או השתמש בחבילת gouuid כדי ליצור UUIDs.
