অ্যারে এবং স্লাইসের মধ্যে পার্থক্য কী?

Question

Accepted Answer

একটি **অ্যারে**-র একটি নির্দিষ্ট আকার থাকে যা এর টাইপের অংশ; একটি **স্লাইস** হল একটি নমনীয়, গতিশীল-আকারের দৃশ্য একটি অন্তর্নিহিত অ্যারে-তে। অনুশীলনে আপনি প্রায় সবসময় **স্লাইস** ব্যবহার করেন — অ্যারেগুলি দৈনন্দিন Go-তে বিরল।

## অ্যারে — নির্দিষ্ট আকার

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

অ্যারের আকার কম্পাইল সময়ে নির্দিষ্ট এবং এর টাইপের অংশ (`[5]int` ≠ `[3]int`)। অ্যারেগুলি **মূল্য প্রকার**ও — একটি নির্ধারণ বা পাস করা সম্পূর্ণ অ্যারে অনুলিপি করে। এই দৃঢ়তাই এর কারণ যে তারা সরাসরি খুব কম ব্যবহৃত হয়।

## স্লাইস — গতিশীল এবং নমনীয়

```go
s := []int{1, 2, 3}          // a slice (no size in the brackets)
s = append(s, 4)             // grow it — append returns a new slice
fmt.Println(len(s), cap(s))  // length and capacity

nums := make([]int, 0, 10)   // make a slice: length 0, capacity 10 (pre-allocated)
```

স্লাইসের কোনো নির্দিষ্ট আকার নেই — আপনি এটি `append` দিয়ে বৃদ্ধি করেন। এটি go-to গতিশীল সিকোয়েন্স।

## স্লাইসগুলি অনুমানের অধীনে কীভাবে কাজ করে

```text
A slice is a small struct: { pointer to underlying array, length, capacity }
  - len = number of elements currently in the slice
  - cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
```

## স্লাইসিং একটি দৃশ্য তৈরি করে (ভাগ করা সমর্থন অ্যারে — একটি সূত্র)

```go
original := []int{1, 2, 3, 4, 5}
sub := original[1:3]         // [2, 3] — a VIEW into the same backing array
sub[0] = 99                  // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
```

স্লাইসিং (`s[low:high]`) অনুলিপি করে না — এটি একটি নতুন স্লাইস হেডার তৈরি করে যা একই অন্তর্নিহিত অ্যারে-তে নির্দেশ করে। একটি সংশোধন অন্যটিকে প্রভাবিত করতে পারে — সূক্ষ্ম বাগের একটি সাধারণ উৎস। স্বাধীন অনুলিপির জন্য `copy()` ব্যবহার করুন।

## append-এর পুনরায় বরাদ্দ সারপ্রাইজ

```go
a := []int{1, 2, 3}
b := append(a, 4)            // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
```

## কেন এটি গুরুত্বপূর্ণ

স্লাইসগুলি Go-এর সবচেয়ে বেশি-ব্যবহৃত এবং সবচেয়ে-ভুল-বোঝা বৈশিষ্ট্যগুলির মধ্যে একটি।

বুঝতে পারা যে অ্যারেগুলি নির্দিষ্ট-আকার মূল্য প্রকার (সরাসরি খুব কম ব্যবহৃত) যখন **স্লাইসগুলি** একটি সমর্থন অ্যারে-তে নমনীয়, রেফারেন্স-সদৃশ দৃশ্য (দৈনন্দিন সরঞ্জাম) হল তা মৌলিক।

গুরুত্বের সাথে, **ভাগ করা-সমর্থন-অ্যারে আচরণ** জানা — যে স্লাইসিং একটি দৃশ্য তৈরি করে, অনুলিপি নয়, তাই পরিবর্তনগুলি অন্যান্য স্লাইসগুলিকে প্রভাবিত করতে পারে, এবং `append` পুনরায় বরাদ্দ করতে পারে বা নাও পারে — সূক্ষ্ম, কঠিন-ডিবাগ-করা উপনাম বাগের একটি শ্রেণী প্রতিরোধ করে যা এমনকি অভিজ্ঞ ডেভেলপারদের ধরে ফেলে।

স্লাইসগুলিতে দক্ষতা অর্জন করা (len বনাম cap, append, copy, শেয়ারিং সূত্র) অপরিহার্য দৈনন্দিন Go জ্ঞান এবং একটি ঘন ঘন সাক্ষাৎকার বিষয়, যেহেতু প্রায় সমস্ত সংগ্রহ কাজ তাদের ব্যবহার করে।