الشرائح Slice في Golang: append وmake وlen مقابل cap وخطأ المشاركة

الشريحة في مثال واحد

الشريحة (slice) نافذة قابلة للنمو على مصفوفة. تنشئها بحرفية أو بـ make، وتكبّرها بـ append، وتقرأ حجمها بـ len.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

لا طول بين القوسين المربّعين في []string. هذا هو الفرق عن نوع المصفوفة مثل [4]string، الذي حجمه ثابت.

ما هي الشريحة

قيمة الشريحة ترويسة صغيرة من ثلاثة حقول:

• مؤشر إلى عنصر في مصفوفة خلفية
• طول: عدد العناصر التي تراها الشريحة
• سعة: عدد العناصر الموجودة من ذلك المؤشر حتى نهاية المصفوفة الخلفية

نسخ شريحة (إسنادها، أو تمريرها إلى دالة) ينسخ هذه الترويسة فقط. والنسختان تشيران إلى العناصر نفسها. تأتي كل مفاجآت الشرائح تقريبًا من نسيان ذلك.

make: الطول والسعة

تحجز make([]T, len, cap) مصفوفة خلفية وتعيد شريحة عليها. السعة اختيارية وقيمتها الافتراضية تساوي الطول.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

خلط شائع: make([]int, 5) متبوعة بخمسة استدعاءات append تعطيك عشرة عناصر، أولها خمسة أصفار. استخدم make([]int, 0, 5) عندما تنوي الإلحاق، أو make([]int, 5) عندما تنوي الإسناد بالفهرس.

الحجز المسبق للسعة عندما تعرف الحجم النهائي يتجنّب النمو المتكرّر. إنه تحسين، لا شرط.

append والنمو

تضيف append العناصر بعد الطول الحالي. إذا كانت السعة كافية تكتب في مكانها. وإلا تحجز مصفوفة أكبر، وتنسخ العناصر القديمة إليها، وتعيد شريحة تشير إلى المصفوفة الجديدة.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

تتضاعف السعة تقريبًا ما دامت الشريحة صغيرة وتنمو بمعامل أصغر (يقترب من 1.25x) بعد تجاوزها 256 عنصرًا. الأرقام الدقيقة تفصيل في وقت التشغيل تغيّر بين إصدارات Go، فلا تكتب أبدًا شيفرة تعتمد عليها.

لأن append قد تعيد مصفوفة مختلفة، يجب أن تستخدم نتيجتها:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

إلحاق شريحة كاملة يستخدم صيغة النشر: s = append(s, other...).

التقطيع يتشارك المصفوفة الخلفية

تنشئ s[low:high] ترويسة شريحة جديدة على المصفوفة نفسها، تغطّي الفهارس من low حتى high دون شموله. يمكن حذف أي من الحدّين. لا تُنسخ أي عناصر.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

المخرجات:

[10 99 30 40 50]
3 4

هذه المشاركة هي ما يجعل التقطيع رخيصًا. وهي أيضًا مصدر أشهر خطأ في الشرائح.

خطأ التسمية المزدوجة مع append

عندما يكون لشريحة فرعية سعة فائضة، يكتب الإلحاق بها في مصفوفة الأب، فوق عناصر ما زال الأب يستخدمها.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

المخرجات:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

تتشارك a وb خانة المصفوفة التي بعد "cmd"، فكتب الإلحاق الثاني فوق الأول. تبدو الشيفرة سليمة وتعمل كلما صادف أن السعة ممتلئة، ولهذا يظهر هذا الخطأ أحيانًا فقط.

إصلاحان:

1. تعبير التقطيع الكامل s[low:high:max] يحدّ السعة بـ max-low. دون سعة فائضة يجب أن يحجز append التالي. تجعل first := base[:2:2] المثال الأول آمنًا.
2. انسخ صراحة عندما ستعيش الشريحة أطول من الاستدعاء أو سيُلحق بها بشكل مستقل: slices.Clone(prefix) أو append([]string(nil), prefix...).

فخ مرتبط: شريحة صغيرة من مصفوفة ضخمة تُبقي المصفوفة كلها حيّة لجامع النفايات. إذا قرأت ملفًا بحجم 100 MB واحتفظت بـ data[:10]، تبقى الـ 100 MB في الذاكرة. انسخ الجزء الذي تحتفظ به.

copy

تنسخ الدالة المدمجة copy(dst, src) عدد min(len(dst), len(src)) من العناصر وتعيد ذلك العدد. ولا تكبّر dst أبدًا.

package main

import (
	"fmt"
	"slices"
)

func main() {
	src := []int{1, 2, 3}

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

تتعامل copy بشكل صحيح مع تداخل المصدر والوجهة، فتقدّم copy(s[1:], s) العناصر موضعًا واحدًا دون إفساد.

الحزمة slices

منذ Go 1.21 تحتوي الحزمة القياسية slices على دوال مساعدة عامة للعمليات التي كنت تكتبها يدويًا.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

تعيد Delete وInsert شريحة يجب أن تسندها، مثل append. وللترتيب صفحته الخاصة: الترتيب.

حذف العناصر أثناء المرور بالفهرس يتخطّى عناصر. استخدم slices.DeleteFunc بدلًا من ذلك:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

الشرائح ثنائية الأبعاد

شريحة من الشرائح تعطيك شبكة يمكن أن تختلف أطوال صفوفها. يجب حجز كل صف على حدة.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

نسيان make الداخلية يترك كل صف nil، فتسبّب grid[1][2] = 7 حالة panic برسالة index out of range [2] with length 0.

الشرائح nil والشرائح الفارغة

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

تتصرّف الشريحة nil كالفارغة مع len وcap وrange وappend، ففضّل var s []T كحالة صفرية. هيّئ بـ []T{} فقط عندما يهمّ الفرق، وهذا في الغالب مخرجات JSON (null مقابل []). افحص الفراغ بـ len(s) == 0، لا بـ s == nil.

الشرائح والدوال

تستطيع الدالة التي تتلقّى شريحة تغيير عناصرها، ويرى المستدعي التغييرات. لكنها لا تستطيع تغيير طول المستدعي، لأنها تلقّت نسخة من الترويسة. الدالة التي تلحق يجب أن تعيد الشريحة الجديدة:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

لهذا تعيد append وslices.Delete وslices.Insert كلها شريحة.

أخطاء شائعة

• تجاهل نتيجة append. لا تُترجم عند إهمالها كليًا، لكن إسناد append(s, x) إلى متغيّر غير الذي تواصل استخدامه خطأ منطقي.
• إلحاقان من أساس واحد. قد يتشاركان التخزين. انسخ الأساس أو استخدم تعبير تقطيع كاملًا.
• make([]T, n) ثم append. تترك n صفرًا في البداية.
• فهرس خارج النطاق. تسبّب s[len(s)] حالة panic. العنصر الأخير هو s[len(s)-1].
• مقارنة الشرائح بـ ==. لا تُترجم إلا s == nil. استخدم slices.Equal.