الشرائح (Slices) هي نوع بيانات مهم في لغة Go، حيث توفر واجهة أكثر قوة للتسلسلات مقارنة بالمصفوفات.

package main

import (
    "fmt"
    "slices"
)

func main() {

على عكس المصفوفات، يتم تحديد نوع الشرائح فقط بالعناصر التي تحتوي عليها (وليس عدد العناصر). الشريحة غير المهيأة تساوي nil وطولها 0.

    var s []string
    fmt.Println("uninit:", s, s == nil, len(s) == 0)

لإنشاء شريحة بطول غير صفري، استخدم الدالة المضمنة make. هنا نقوم بإنشاء شريحة من النصوص (strings) بطول 3 (تكون قيمها صفرية ابتدائياً). افتراضياً، سعة الشريحة الجديدة تساوي طولها؛ إذا كنا نعلم أن الشريحة ستنمو مسبقاً، فمن الممكن تمرير السعة صراحةً كمعامل إضافي لـ make.

    s = make([]string, 3)
    fmt.Println("emp:", s, "len:", len(s), "cap:", cap(s))

يمكننا التعيين والحصول على القيم تماماً كما هو الحال مع المصفوفات.

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

len تعيد طول الشريحة كما هو متوقع.

    fmt.Println("len:", len(s))

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

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

يمكن أيضاً نسخ (copy) الشرائح. هنا نقوم بإنشاء شريحة فارغة c بنفس طول s وننسخ من s إلى c.

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

تدعم الشرائح عامل الـ “قص” (slice operator) بالصيغة slice[low:high]. على سبيل المثال، هذا يحصل على شريحة من العناصر s[2] و s[3] و s[4].

    l := s[2:5]
    fmt.Println("sl1:", l)

هذا يقص حتى (ولكن باستثناء) s[5].

    l = s[:5]
    fmt.Println("sl2:", l)

وهذا يقص من (وبما في ذلك) s[2].

    l = s[2:]
    fmt.Println("sl3:", l)

يمكننا التصريح عن متغير للشريحة وتهيئته في سطر واحد أيضاً.

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

تحتوي حزمة slices على عدد من الدوال المفيدة للشرائح.

    t2 := []string{"g", "h", "i"}
    if slices.Equal(t, t2) {
        fmt.Println("t == t2")
    }

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

    twoD := make([][]int, 3)
    for i := range 3 {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := range innerLen {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

تشغيل البرنامج:

$ go run slices.go
uninit: [] true true
emp: [  ] len: 3 cap: 3
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
t == t2
2d:  [[0] [1 2] [2 3 4]]