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

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

תוכן תרשים:

מה הם משתנים?

משתנה היא מיקום אחסון שמזוהה בשם (או מסמל) שחוזק ערך. הערך הזה יכול להשתנות (או להיות משתנה) בזמן ההוצאה לשימוש של התוכנה. זו סיבה של השמה משתנה.

לדוגמה:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

יצרנו משתנה עם מסמל של myName שחוזק ערך של מסמל טקסט.

אם הבחנתם, שינינו את הערך למשהו אחר, ואנחנו יכולים לעשות זאת במספר פעמים בגלל שלמשתנה מותרת לעשות זאת.

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

איך ליצור משתנה בגו

ישני דרכים עיקריות ליצור משתנה בגו, דרך הצגה ברורה ודרך הצגה קצרה.

דרך הצגה ברורה

זוהי הדרך המסורתית ליצור משתנה בגו. היא עובדת על ידי שימוש במילה מקוד הvar והצגת סוג המשתנה, מעודדת את הקוד להיות יותר קריא וברור.

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

אתם יכולים לראות שלכל משתנה, הגדרנו את סוג המידע לפני שינוי ערך בו.

output:
25 Temitope 5.7

המילה מקוד הvar והסוג המשתנה יכולים גם להיות ללא ערך מקודם:

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

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

דר

השיחורת הקיצונית להצעת משתמשים (:=) היא דרך קצרה יותר להציע משתמשים. השיטה מאפשרת לך להציע ולהתחיל משתמש בשורה אחת בלי לציין ברור את הסוג שלו, מפני שהסוג נבין מהערך שנתנה.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

כאן, משתמש כל אחד הוצע לצידו של הערך שלו, וGo בודק את הסוג. לדוגמה, age הוצע והתחיל עם ערך של 25, וGo בין את הסוג ל int. name הוצע עם הערך "Temitope", וGo בין את הסוג ל string. לבסוף, height הוצע עם 5.7, וGo בין את הסוג ל float64.

output:
25 Temitope 5.7

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

המשתמשים המרובים

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

package main

import "fmt"

func main() {

    var age, height int = 25, 180

    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)

    fmt.Println(name, city)
}

כאן, המשתמש age ו height מוצעים כמספרים ומוגדרים עם הערכים 25 ו-180, בעליל. המשתמש name ו city גם מוצעים כספרים ומוגדרים עם "Temitope" ו "New York":

Output:
25 180
Temitope New York

אתה יכול גם להציע משתמשים רבים בבלוק כך:

package main

import "fmt"

func main() {

    var (
        age int = 25

        name string = "Temitope"

        height int = 180

        city string = "New York"
    )

    fmt.Println(age, name, height, city)

}

כאן, המשתמשים age, name, height, ו city מוצעים בתוך בלוק var אחד, ולכל משתמש יש שורה מסויימת.

Output:
25 Temitope 180 New York

ערכים אפסים

כשמתגוררים משתנים בלי להגדיר אותם, הם מוערכים בערך אפס על ידי מסגרת הנתונים באופן בר-שיטה. הערכים הללו שונים לפי סוג המשתנים. למטה ניתן לראות דוגמא לאופן בו ניתן להגדיר ערכים בראשונה:

package main

import "fmt"

func main() {

    var intValue int

    var floatValue float64

    var boolValue bool

    var stringValue string

    var ptrValue *int

    var sliceValue []int

    var mapValue map[string]int

    fmt.Println("Zero values:")

    fmt.Println("int:", intValue)

    fmt.Println("float64:", floatValue)

    fmt.Println("bool:", boolValue)

    fmt.Println("string:", stringValue)

    fmt.Println("pointer:", ptrValue)

    fmt.Println("slice:", sliceValue)

    fmt.Println("map:", mapValue)

}

בקוד העליון, זה מה שיקרה:

  • המשתנה הספציפי intValue יקבל ערך אפסי 0.

  • המספר המערבי floatValue יקבל ערך אפסי 0.

  • המשתנה הבוליאנית boolValue יקבל ערך אפסי false.

  • המשתנה המילית stringValue יקבל ערך אפסי "" (מסר ריק).

  • המשתנה המצבית ptrValue, הגיף sliceValue והמפה mapValue כולם יקבלו ערך אפסי nil.

תוצאה:

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

מה היא מונחת משתנים?

משתנים יכולים להיות מוגדרים ברחבי הגלובל או ברחבי התוכנה הנפוצה. המונחת של המשתנה מחל

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

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

    fmt.Println("Initial Counter:", globalCounter)

    incrementCounter()

    fmt.Println("After Increment:", globalCounter)

}

בדוגמה העליונה, globalCounter הוא המשתנה העולמי, והוא נגיש לפונקציות incrementCounter וmain.

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

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

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

בקוד העליון, יש לנו localCounter כמשתנה מקומי בתוך הפונקציה incrementCounter. בכל פעם שincrementCounter נקרא, מוצע localCounter נוצר, מורשה ל 0, ומגביר.

הערך של localCounter לא ממשיך לקיים בין קריאות הפונקציות, אז הוא לא יכול להשפיע על חלק כלשהו של התוכנה כשמשנה נעשה בתוך הפונקציה.

רגולטורים בגו

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

  • השתמש בשמות תיאוריים: השתמש בשמות שמתארים בבירור את מטרת או תוכן המשתנה. לדוגמה, במקום להשתמש בשמות מעורפלים כמו x או y, השתמש בשמות כמו age, totalPrice, או userName שמתארים בבירור מה המשתנה מייצג.

  • השתמש ב-CamelCase לשמות רב-מילתיים: בגו, נהוג להשתמש ב-camelCase לשמות משתנים שמורכבים ממספר מילים. המילה הראשונה באות קטנה, והאות הראשונה של כל מילה עוקבת היא באות גדולה.

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

  • השתמשו בשמות קצרים עבור משתנים קצרי חיים: עבור משתנים קצרי חיים, כמו מוני לולאות או אינדקסים, מקובל להשתמש בשמות קצרים כמו i, j, או k.

מה הם קבועים ב-Go?

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

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

כיצד להכריז על קבועים ב-Go

ניתן להכריז על קבועים באמצעות מילת המפתח const, ואחריה השם, הסוג (אופציונלי אם הערך מרמז על הסוג), והערך של הקבוע. כך עושים זאת:

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

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

סוגי קבועים ב-Go

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

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

package main

import "fmt"

const gravity = 9.81

func main() {

    var height int = 10

    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)

}

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

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

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

כאן, speedOfLight הוא המבנה המוגדר עם הסוג int.

הוא יכול להיות משמש בפעולות עם ערכים int אחרים או להיות ממונע באופן ברור לסוג אחר.

זה הסיכום

במאמר הזה, בדקנו מה הם משתנים ומבנים ואיך להציע אותם בGo.

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

נשמח א