المتغيرات والمعادلات هما مبدأين أساسيين في أغلب اللغات البرمجية. إنهما مبنيتان لتخزين وإدارة البيانات.

في هذه المقالة، سننظر إلى كيف تعمل المتغيرات والمعادلات في Go.

جدول محتويات:

ما هي المتغيرات؟

تعني أن المتغير هو موقع تخزين يعرف بماركاته (أو معرف) والذي يحمل قيمة. يمكن تغيير هذه القيمة (أو التنوع) أثناء تنفيذ البرنامج. وهذا سبب تسميته بالمتغير.

على سبيل المثال:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

قمنا بإنشاء متغير بمعرف myName الذي يحمل قيمة نصية.

لو لاحظتم، غيرنا القيمة إلى نص آخر، ويمكننا فعل ذلك مرات عديدة لأن المتغيرات تسمح بذلك.

المتغيرات تسمح لك بتخزين البيانات التي يمكن أن يكون لها أنواع مختلفة، مثل الأعداد الصحيحة، أرقام نقطية متنقلة، أو أشياء أخرى.

كيفية إنشاء متغير في Go

هناك طريقتان رئيسيتين لإنشاء متغير في Go: إعلان التعريف والتعريف القصير.

إعلان التعريف

هذه طريقة تقليدية لإنشاء متغير في Go. إنها تعمل عن طريق استخدام كلمة المفتاح 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[]

ما هو مجال المتغير؟

يمكن تعريف المتغيرات على الصعيد العالمي أو على الصعيد المحلي. يحدد المجال المتغير أين يمكن حصول وتعديله ضمن ترتيب برمجت

يتم declare المتغيرات العالمية خارج أي function، عادةً في أعلى الملف، ويمكن الوصول إليها من أي function داخل نفس الpackage. هذا مثال:

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 هو المتغير العالمي، ويمكن الوصول إليه من الfunction incrementCounter والfunction main.

أيضًا، قيمة globalCounter تبقى مستقرة بين مجموعتي المكالمات. هذا يعني أن أي تغيير يتم إجراؤه في مجموعة ما يؤثر على قيمته في أجزاء البرنامج الأخرى.

بطريقة مختلفة، يتم declare المتغيرات المحلية داخل الfunction أو الblok ويمكن الوصول إليها فقط داخل تلك الfunction أو الblok معين. يتم إنشاءها عند تنفيذ الfunction أو الblok وتدميرها بمجرد إنتهاءه. على سبيل المثال:

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

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

}

func main() {

    incrementCounter()

    incrementCounter()

}

في الكود السابق، لدينا localCounter من أي متغير محلي داخل function incrementCounter. كل مرة يتم طلب function incrementCounter، يتم إنشاء متغير localCounter جديد، يتم تنظيمه الآن إلى 0، ثم يتم تزييده.

قيمة localCounter لا تبقى مستقرة بين مجموعتي المكالمات، لذا لا يمكنها تأثير أي جزء من البرنامج عندما يتم تغييره في الfunction.

ما يتعلق بمعايير تسمية المتغيرات في Go

تعمير المتغيرات الصحيح يعني شيئًا مهمًا في كتابة البرمجيات النظيفة وقابلة للقيام بالتنظيف والمتابعة. توجد برنامج Go بعض المعايير والقوانين الخاصة لتسمية المتغيرات. من أدناه بعضها:

  • استخدم أسماء وصفية: استخدم أسماء تصف بوضوح الغرض أو المحتوى الخاص بالمتغير. على سبيل المثال، بدلاً من استخدام أسماء غامضة مثل x أو y، استخدم أسماء مثل العمر، السعر الإجمالي، أو اسم المستخدم التي توضح بوضوح ما يمثله المتغير.

  • استخدم كامل كيس لأسماء متعددة الكلمات: في جو، من الممارسة الشائعة استخدام كامل كيس لأسماء المتغيرات التي تتألف من كلمات متعددة. الكلمة الأولى بحروف صغيرة، والحرف الأول من كل كلمة تليها بحروف كبيرة.

  • تجنب استخدام شرطات سفلية: على عكس بعض اللغات الأخرى، يفضل جو استخدام كامل كيس بدلاً من استخدام شرطات سفلية لفصل الكلمات في أسماء المتغيرات. تلتزم بكامل كيس للتمسك بالأسلوب الجمالي في جو.

  • استخدم أسماء قصيرة للمتغيرات ذات العمر القصير: بالنسبة للمتغيرات ذات العمر القصير، مثل عدادات الحلقة أو المؤشرات، من المقبول استخدام أسماء قصيرة مثل 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 لأنواعها ومدى مرونتها عند الاستخدام.

لا يتم تعيين الثوابت غير المكتوبة نوعًا ما لم يتم استخدامها في سياق يتطلب نوعًا. عند إعلان ثابت غير مكتوب ، ستستنتج 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.

المتغيرات والثوابت هي أدوات حاسمة في البرمجة. تتيح للمطورين إدارة البيانات بكفاءة وتلاعبها. عندما تفهم كيفية استخدامها ، يمكنك تحسين جودة الشفرة الخاصة بك.

الرجاء مشاركتها إذا وجدتها مفيدة.