خدع البطاقات

الشرائح

الشرائح في Go مشابهة للقوائم أو المصفوفات في لغات أخرى. تحتوي على عدة عناصر من نوع محدد (أو واجهة).

الشرائح في Go مبنية على المصفوفات. المصفوفات لها حجم ثابت. أما الشريحة، فهي عرض مرن وحجمها ديناميكي لعناصر المصفوفة.

تُكتب الشريحة مثل []T حيث T هو نوع العناصر في الشريحة:

var empty []int                 // an empty slice
withData := []int{0,1,2,3,4,5}  // a slice pre-filled with some data

يمكنك الحصول على عنصر عند فهرس معين يبدأ من الصفر أو تعيينه باستخدام ترميز الأقواس المربعة:

withData[1] = 5
x := withData[1] // x is now 5

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

newSlice := withData[2:4]
// => []int{2,3}
newSlice := withData[:2]
// => []int{0,1}
newSlice := withData[2:]
// => []int{2,3,4,5}
newSlice := withData[:]
// => []int{0,1,2,3,4,5}

يمكنك إضافة عناصر إلى شريحة باستخدام دالة append. أدناه نضيف 4 و2 إلى الشريحة a.

a := []int{1, 3}
a = append(a, 4, 2)
// => []int{1,3,4,2}

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

يمكن أيضًا استخدام append لدمج شريحتين:

nextSlice := []int{100,101,102}
newSlice  := append(withData, nextSlice...)
// => []int{0,1,2,3,4,5,100,101,102}

الدوال ذات العدد المتغير من الوسائط

عادةً ما تقبل الدوال في Go عددًا ثابتًا فقط من الوسائط. ومع ذلك، من الممكن أيضًا كتابة دوال ذات عدد متغير من الوسائط في Go.

الدالة ذات العدد المتغير من الوسائط هي دالة تقبل عددًا متغيرًا من الوسائط.

إذا كان نوع المعامل الأخير في تعريف دالة مسبوقًا بعلامة القطع ...، فيمكن للدالة أن تقبل أي عدد من الوسائط لذلك المعامل.

func find(a int, b ...int) {
    // ...
}

في الدالة أعلاه، المعامل b متغير ويمكننا تمرير 0 أو أكثر من الوسائط إلى b.

find(5, 6)
find(5, 6, 7)
find(5)

تعمل الدوال ذات العدد المتغير من الوسائط عن طريق تحويل العدد المتغير من الوسائط إلى شريحة من نوع المعامل المتغير.

إليك مثالًا على تنفيذ دالة ذات عدد متغير من الوسائط.

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)

    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            return
        }
    }

    fmt.Println(num, "not found in ", nums)
}

func main() {
    find(89, 90, 91, 95)
    // =>
    // type of nums is []int
    // 89 not found in  [90 91 95]

    find(45, 56, 67, 45, 90, 109)
    // =>
    // type of nums is []int
    // 45 found at index 2 in [56 67 45 90 109]

    find(87)
    // =>
    // type of nums is []int
    // 87 not found in  []
}

في السطر find(89, 90, 91, 95) من البرنامج أعلاه، الوسائط المتغيرة العدد لدالة find هي 90 و91 و95. تتوقع دالة find معاملًا متغيرًا من النوع int بعد num. لذلك ستحوّل هذه الوسائط الثلاثة بواسطة المصرِّف إلى شريحة من النوع int هي []int{90, 91, 95} ثم ستُمرر إلى دالة find باسم nums.

أحيانًا تكون لديك شريحة بالفعل وتريد تمريرها إلى دالة ذات عدد متغير من الوسائط. يمكن تحقيق ذلك بتمرير الشريحة متبوعة بـ .... سيخبر ذلك المصرِّف باستخدام الشريحة كما هي داخل الدالة ذات العدد المتغير من الوسائط. سيُحذف ببساطة في هذه الحالة الخطوة الموصوفة أعلاه حيث تُنشأ شريحة.

list := []int{1, 2, 3}
find(1, list...) // "find" defined as shown above