يوم الانتخابات

كما في كثير من اللغات الأخرى، تحتوي لغة Go على المؤشرات. إذا كنت جديدًا على المؤشرات، فقد تبدو غامضة بعض الشيء، لكنها تصبح بسيطة جدًا بمجرد أن تعتاد عليها. إنها جزء أساسي من Go، لذا خصّص بعض الوقت لفهمها حقًا.

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

1. عندما تكون لدينا كميات كبيرة من البيانات، يصبح إنشاء نسخ لتمريرها بين الدوال غير فعّال إلى حد كبير. وبتمرير موقع الذاكرة الذي تُخزَّن فيه البيانات بدلًا من ذلك، يمكننا تقليص استهلاك برامجنا للموارد بشكل كبير.
2. وبتمرير المؤشرات بين الدوال، يمكننا الوصول إلى النسخة الوحيدة من البيانات وتعديلها مباشرةً، ما يعني أن أي تغييرات تجريها إحدى الدوال تصبح مرئية فورًا لأجزاء أخرى من البرنامج عند انتهاء الدالة.

المتغيرات والذاكرة

لنفترض أن لدينا متغيرًا عاديًا من نوع عدد صحيح اسمه a:

var a int

عندما نُعلن عن متغير، يجب على Go أن تجد مكانًا في الذاكرة لتخزين قيمته. وهذا الأمر مجرّد عنّا إلى حد كبير: عندما نحتاج إلى جلب القيمة المخزّنة في ذلك الجزء من الذاكرة، يكفي أن نشير إليها باسم المتغير.

على سبيل المثال، عندما نكتب a + 2، فإننا في الواقع نجلب القيمة المخزّنة في الذاكرة المرتبطة بالمتغير a ونضيف إليها 2.

وبالمثل، عندما نحتاج إلى تغيير القيمة في الجزء الخاص بالمتغير a من الذاكرة، يمكننا استخدام اسم المتغير لإجراء إسناد:

a = 3

سيخزّن الجزء من الذاكرة المرتبط بالمتغير a الآن القيمة 3.

المؤشرات

بينما تتيح لنا المتغيرات الإشارة إلى القيم في الذاكرة، فإنه من المفيد أحيانًا معرفة عنوان الذاكرة الذي يشير إليه المتغير. المؤشرات تحمل عناوين الذاكرة لتلك القيم. يمكنك الإعلان عن متغير من نوع مؤشر بوضع نجمة قبل النوع الأساسي:

var p *int // 'p' contains the memory address of an integer

هنا نُعلن عن متغير p من نوع «مؤشر إلى عدد صحيح» (*int). هذا يعني أن p سيحمل عنوان الذاكرة الخاص بعدد صحيح. القيمة الصفرية للمؤشرات هي nil، لأن المؤشر nil لا يحمل أي عنوان ذاكرة.

الحصول على مؤشر إلى متغير

لمعرفة عنوان الذاكرة الخاص بقيمة متغير، يمكننا استخدام عامل &. على سبيل المثال، إذا أردنا معرفة عنوان الذاكرة الخاص بالمتغير a وتخزينه في المؤشر p، يمكننا فعل ما يلي:

var a int
a = 2

var p *int
p = &a // the variable 'p' contains the memory address of 'a'

الوصول إلى القيمة عبر مؤشر (إلغاء الإشارة)

عندما يكون لدينا مؤشر، قد نرغب في معرفة القيمة المخزّنة في عنوان الذاكرة الذي يمثله المؤشر. يمكننا فعل ذلك باستخدام عامل *:

var a int
a = 2

var p *int
p = &a // the variable 'p' contains the memory address of 'a'

var b int
b = *p // b == 2

تجلب العملية *p القيمة المخزّنة في عنوان الذاكرة الذي يحمله p. غالبًا ما تُسمّى هذه العملية «إلغاء الإشارة».

يمكننا أيضًا استخدام عامل إلغاء الإشارة لإسناد قيمة جديدة إلى عنوان الذاكرة الذي يشير إليه المؤشر:

var a int        // declare int variable 'a'
a = 2            // assign 'a' the value of 2

var pa *int
pa = &a          // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2    // increment by 2 the value at memory address 'pa'

fmt.Println(a)   // Output: 4
                 // 'a' will have the new value that was changed via the pointer!

إسناد قيمة إلى *pa سيغيّر القيمة المخزّنة في عنوان الذاكرة الذي يحمله pa. وبما أن pa يحمل عنوان الذاكرة الخاص بالمتغير a، فإننا بإسناد قيمة إلى *pa نغيّر فعليًا قيمة a!

لكن خذ حذرك: تحقّق دائمًا من أن المؤشر ليس nil قبل إلغاء الإشارة إليه. فإلغاء الإشارة إلى مؤشر nil سيجعل البرنامج ينهار وقت التشغيل!

var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference

مؤشرات إلى البنى

حتى الآن رأينا مؤشرات إلى قيم أولية فقط. يمكننا أيضًا إنشاء مؤشرات إلى البنى:

type Person struct {
    Name string
    Age  int
}

var peter Person
peter = Person{Name: "Peter", Age: 22}

var p *Person
p = &peter

كان يمكننا أيضًا إنشاء بنية Person جديدة وتخزين مؤشر إليها على الفور:

var p *Person
p = &Person{Name: "Peter", Age: 22}

عندما يكون لدينا مؤشر إلى بنية، لا نحتاج إلى إلغاء الإشارة قبل الوصول إلى أحد الحقول:

var p *Person
p = &Person{Name: "Peter", Age: 22}

fmt.Println(p.Name) // Output: "Peter"
                    // Go automatically dereferences 'p' to allow
                    // access to the 'Name' field

الشرائح والخرائط مؤشرات بالفعل

الشرائح والخرائط أنواع خاصة لأنها تحتوي بالفعل على مؤشرات في تنفيذها الداخلي. وهذا يعني أننا في أغلب الأحيان لا نحتاج إلى إنشاء مؤشرات لهذه الأنواع لمشاركة عنوان الذاكرة الخاص بقيمها. تخيّل أن لدينا دالة تزيد قيمة مفتاح في خريطة:

func incrementPeterAge(m map[string]int) {
	m["Peter"] += 1
}

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

ages := map[string]int{
  "Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!

ينطبق الأمر نفسه عند تغيير عنصر موجود في شريحة.

لكن الإجراءات التي تُرجع شريحة جديدة مثل append حالة خاصة، وقد لا تعدّل الشريحة خارج الدالة. يعود ذلك إلى كيفية عمل الشرائح داخليًا، لكننا لن نتناول هذا بالتفصيل في هذا التمرين، فهو موضوع أكثر تقدمًا. وإذا كنت فضوليًا حقًا، يمكنك قراءة المزيد عن هذا في مدونة Go: آليات 'append'