ترفندهای کارت

اسلایس

اسلایس در 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

می‌توانید با گرفتن بازه‌ای از عناصر، اسلایس جدیدی از یک اسلایس موجود بسازید. باز هم با استفاده از نماد کروشه، اما این بار هم اندیس شروع (شامل) و هم اندیس پایان (غیرشامل) را مشخص می‌کنید. اگر اندیس شروع را مشخص نکنید، به‌طور پیش‌فرض ۰ می‌شود. اگر اندیس پایان را مشخص نکنید، به‌طور پیش‌فرض طول اسلایس می‌شود.

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 متغیر است و می‌توانیم ۰ یا بیشتر آرگومان به 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} تبدیل می‌شوند و سپس به‌عنوان nums به تابع find پاس داده می‌شوند.

گاهی از قبل یک اسلایس دارید و می‌خواهید آن را به یک تابع متغیر پاس دهید. این کار با پاس دادن اسلایس و سپس ... انجام می‌شود. این به کامپایلر می‌گوید که اسلایس را همان‌طور که هست درون تابع متغیر استفاده کند. در این حالت، مرحله‌ای که در بالا توضیح داده شد و در آن یک اسلایس ساخته می‌شود، به‌سادگی حذف می‌شود.

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