עיצוב מספרים ומטבעות עם Go

עיצוב נכון של מספרים יכול להיות משימה לא פשוטה. ועיצוב מטבעות מביא לאתגרים נוספים הכוללים לוקליזציה. למרבה המזל, ל- Go יש תכונות שיעזרו.

ספריית התקן Go מספקת כלים שונים לעיצוב מספרים. חבילת strconv כוללת פונקציות לניתוח והמרת מספרים אל וממחרוזות.

חבילת strconv

ה strconv חבילה היא כלי רב עוצמה להמרה בין מספרים למחרוזות. אתה יכול להשתמש בו כדי לעבוד עם מספרים בפורמטים שונים.

strconv הוא חלק מהספרייה הסטנדרטית, כך שהוא רלוונטי לרבים מהספרייה מושגי Go בסיסיים שכדאי להכיר. כך תוכל לייבא אותו:

יְבוּא"strconv"

החבילה מספקת פונקציות להמרת מספרים אל וממחרוזות בפורמטים שונים. הוא כולל פונקציות לעבודה עם מספרים שלמים ומספרי נקודה צפה.

strconv יכול גם לטפל בהמרה לפורמטים בינאריים, אוקטליים והקסדצימליים וממנו וכן סימון מדעי.

עיצוב מספרים שלמים ב-Go

חבילת strconv איטו הפונקציה מספקת פונקציונליות להמרת מספרים שלמים למחרוזות. ה איטו הפונקציה לוקחת מספר שלם ומחזירה את ייצוג המחרוזת של אותו מספר שלם.

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
 מספרים שלמים := 3043
 stringVersion := strconv. איטו (מספרים שלמים)
 fmt. Println (stringVersion) // פלט: "3043"
}

קוד זה ממיר ערך של מספר שלם למחרוזת באמצעות איטו. לאחר מכן הוא מוציא את המחרוזת שהתקבלה לקונסולה באמצעות ה- fmt חֲבִילָה.

בנוסף ל איטו פונקציה, strconv מספק:

• FormatInt לעיצוב מספרים שלמים כמחרוזות עם בסיס נתון
• AppendInt להוספת מספרים שלמים בצורת מחרוזת לפרוסה של בתים.

הנה איך אתה יכול להשתמש ב- FormatInt פונקציה לעיצוב מספר שלם:

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
 מספרים שלמים := 12345
 מחרוזות := strconv. FormatInt(int64(מספרים שלמים), 10)
 fmt. Println (מחרוזות) // פלט: "12345"
}

קוד זה משתמש int64() כדי להמיר את הערך המקורי למספר שלם של 64 סיביות. לאחר מכן הוא מעביר את התוצאה ל FormatInt, יחד עם בסיס להמרה, במקרה זה 10. FormatInt מחזיר מחרוזת אשר Println ואז פלט לקונסולה.

ה AppendInt הפונקציה לוקחת פרוסת בתים, an int64 ערך, ובסיס.

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
 מספרים שלמים := 12345
 byteSlice := עשה([]בייט, 0, 20)
 byteSlice = strconv. AppendInt (byteSlice, int64(מספרים שלמים), 10)
 fmt. Println(חוּט(byteSlice)) // פלט: "12345"
}

שימו לב ש-AppendInt מקבל פרוסת בתים להוספה, ומחזירה את פרוסת הביטים שנוצרה. במקרה זה, פרוסת הבתים הראשונית ריקה, אך בעלת קיבולת של 20 לאחסן את ייצוג המחרוזת המתקבל של המספר השלם.

ניתוח מחרוזות כמספרים שלמים

ה אטוי הפונקציה ממירה מחרוזות למספרים שלמים. הוא קולט מחרוזת כקלט ומחזיר ייצוג שלם של המחרוזת הזו יחד עם סוג שגיאה.

הנה איך אתה יכול להשתמש ב- אטוי פונקציה להמרת מחרוזת למספר שלם:

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
 מחרוזות := "123"
 מספרים שלמים, שגיאה := strconv. אטוי (מחרוזות)
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
 }
 fmt. Println (מספרים שלמים) 
}

התוכנית מוציאה את הערך השלם למסוף:

אתה יכול גם להשתמש ב ParseUint פונקציה לנתח את ייצוג המחרוזת של מספרים שלמים ללא סימנים.

חֲבִילָה רָאשִׁי
יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
// נתח מחרוזת כבסיס 10 ומספר שלם ללא סימן 0-bit
 val, err := strconv. ParseUint("12345", 10, 0)
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
 } אַחֵר {
 fmt. Println (val) // פלט: 12345
 }
}

ה ParseUint הפונקציה מנתחת את המחרוזת 12345 כבסיס עשר, מספר שלם ללא סימן. גודל 0-bit מבטיח שהוא מחזיר סוג int סטנדרטי. הוא מחזיר את הערך המנתח ושגיאה.

אתה יכול להשתמש ב ParseFloat פונקציה לנתח ייצוג מחרוזת של מספר נקודה צפה.

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
// נתח מחרוזת כמספר נקודה צפה של 64 סיביות
 val, err := strconv. ParseFloat("3.14", 64)
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
 } אַחֵר {
 fmt. Println (val) // פלט: 3.14
 }
}

ה ParseFloat הפונקציה מנתחת את המחרוזת כמספר נקודה צפה של 64 סיביות ומחזירה את המחרוזת וסוג שגיאה.

עיצוב מטבעות ב-Go

בניית אפליקציה שמקיימת אינטראקציה עם מטבעות דורשת עיצוב וניתוח מספרים. עבודה עם מטבעות שונים יכולה להיות אתגר, אבל strconv ו חשבונאות חבילות יכולות לעזור לך לעצב אותן.

כך תוכל לנתח מחרוזת מטבע ל-float עבור פעולות על המטבע:

יְבוּא (
"fmt"
"strconv"
)
funcרָאשִׁי() {
// מחרוזת מטבע לניתוח
 currencyStr := "$1,234.56"
// הסר את סמל המטבע והמיר לצוף
 floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)
אם טעות != אֶפֶס {
 fmt. Println (שגיאה)
לַחֲזוֹר
 }
// הדפס את הערך הצף המנתח
 fmt. Println (floatVal) // פלט: 1234.56
}

ה currencyStr משתנה הוא ייצוג מחרוזת של ערך מטבע עם סימן דולר כסמל. התוכנית משתמשת ב- ParseFloat פונקציה לנתח את מחרוזת המטבע החל מהאלמנט השני (אחרי סמל המטבע).

באופן קונבנציונלי, עדיף להימנע משימוש בצפים עבור מטבעות מכיוון שהם עלולים לגרום לחישובים שגויים ובאגים בייצור.

לחלופין, אתה יכול להשתמש בחבילה של צד שלישי כמו חשבונאות בעל פונקציונליות לעיצוב וניתוח מטבעות.

הפעל את פקודת הטרמינל הזו בספריית הפרויקט שלך כדי להתקין את חבילת החשבונאות:

לך להשיג github.com/leekchan/accounting

התחל ביצירת מופע של ה חשבונאות struct. נזכיר שמבנים הם אחד מהם תכונות הליבה מונחות אובייקט של Go, בדומה לשיעורים משפות אחרות. אתה יכול לאתחל מופע חשבונאי עם סמל מטבע וערך דיוק, בין האפשרויות האחרות.

אתה יכול להשתמש ב FormatMoney פונקציה של החבילה החשבונאית לעצב מספרים למטבעות.

חֲבִילָה רָאשִׁי
יְבוּא (
"fmt"
"מתמטיקה/גדול"
"github.com/leekchan/accounting"
)
funcרָאשִׁי() {
 ac := חשבונאות. הנהלת חשבונות{סמל: "$", דיוק: 2}
 fmt. Println (ac. FormatMoney(123456789.213123))
 fmt. Println (ac. FormatMoney(12345678))
 fmt. Println (ac. FormatMoney (גדול. New Rat(77777777, 3)))
 fmt. Println (ac. FormatMoney (גדול. New Rat(-77777777, 3)))
 fmt. Println (ac. FormatMoneyBigFloat (בגדול. NewFloat(123456789.213123)))
}

ה ac משתנה הוא המופע החשבונאי. תוכנית זו מעצבת ומדפיסה ערכים כספיים באמצעות ה FormatMoney ו FormatMoneyBigFloat שיטות הערכאה החשבונאית. ה NewRat פונקציה מה גָדוֹל חבילה יוצרת מספר רציונלי בהינתן מונה ומכנה. ה NewFloat הפונקציה עוזרת לייצג מספרי נקודה צפה גדולה.

Go יכול לעזור לך לעצב גם סוגים אחרים

Go מספקת שפע של פונקציות להמרת מספרים ומטבעות בצורה פשוטה.

השפה מציעה גם מערכת חזקה לעיצוב מחרוזות. פונקציית Sprintf בהשראת C של חבילת fmt מאפשרת לך ליצור מחרוזות מעוצבות באמצעות תחביר מיוחד של מציין מיקום. אתה יכול להשתמש ב-Sprintf כדי לבנות מחרוזות שכוללות מספרים וערכי מטבע, מה שמקל על יצירת פלט קריא על ידי אדם.