Arrays మరియు slices ల మధ్య తేడా ఏమిటి?

Question

Accepted Answer

ఒక **array** ఒక నిర్ణీత పరిమాణాన్ని కలిగి ఉంటుంది, అది దాని టైప్‌లో భాగం; ఒక **slice** అనేది ఒక అంతర్నిహిత array కు సంబంధించిన నమ్యమైన, డైనమిక్‌గా సైజ్ చేయబడిన దృశ్యం. ఆచరణలో మీరు దాదాపు ఎప్పుడూ **slices** ను ఉపయోగిస్తారు — arrays అరుదుగా రోజువారీ Go లో కనిపిస్తాయి.

## Arrays — నిర్ణీత సైజ్

```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
```

Array సైజ్ కంపైల్ సమయంలో నిర్ణయించబడుతుంది మరియు దాని టైప్‌లో భాగం (`[5]int` ≠ `[3]int`). Arrays కూడా **value types** — ఒకటిని కేటాయించడం లేదా పాస్ చేయడం మొత్తం array ని కాపీ చేస్తుంది. ఈ కఠినత్వం ఎందుకు అవి నేరుగా చాలా అరుదుగా ఉపయోగించబడుతుంది.

## Slices — డైనమిక్ మరియు నమ్యమైన

```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)
```

ఒక slice కు నిర్ణీత సైజ్ లేదు — మీరు `append` తో దానిని విస్తరిస్తారు. ఇది డైనమిక్ సీక్వెన్స్ కు సాధారణ ఎంపిక.

## Slices హుడ్ కింద ఎలా పనిచేస్తాయి

```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
```

## Slicing ఒక దృశ్యం సృష్టిస్తుంది (భాగస్వామ్య బ్యాకింగ్ array — ఒక గోచరం)

```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]!
```

Slicing (`s[low:high]`) కాపీ చేయదు — ఇది **ఒకే** అంతర్నిహిత array వైపు చూపుతూ ఒక కొత్త slice header సృష్టిస్తుంది. ఒకటిని సవరించడం మరొకటిని ప్రభావితం చేయవచ్చు — ఇది సూక్ష్మమైన బగ్‌ల యొక్క సాధారణ మూలం. స్వతంత్ర కాపీ కోసం `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)
```

## ఇది ఎందుకు ముఖ్యమైనది

Slices Go యొక్క చాలా-ఉపయోగించిన మరియు చాలా-తప్పుగా అర్థం చేసుకున్న లక్షణాలు.

Arrays నిర్ణీత-సైజ్ value types (నేరుగా చాలా అరుదుగా ఉపయోగించబడుతాయి) అయితే **slices** నమ్యమైన, సూచన-సమान దృశ్యాలు ఒక బ్యాకింగ్ array (రోజువారీ సాధనం) లోకి అని అర్థం చేసుకోవడం ఆధారమైనది.

ja్రితంగా, **భాగస్వామ్య-బ్యాకింగ్-array ప్రవర్తన**ను తెలుసుకోవడం — slicing ఒక దృశ్యం సృష్టిస్తుంది, కాపీ కాదు, కాబట్టి సవరణలు ఇతర slices లను ప్రభావితం చేయవచ్చు, మరియు `append` రీ-కేటాయిస్తుందా లేదా లేనిదా — సూక్ష్మమైన, కష్టమైన-టు-డీబగ్ aliasing బగ్‌ల యొక్క ఒక తరగతిని నిరోధిస్తుంది, ఇది చాలా అనుభవజ్ఞ డెవలపర్‌లను కూడా పట్టుకుంటుంది.

Slices మాస్టర్ చేయడం (len vs cap, append, copy, ఆ భాగస్వామ్య gotchas) రోజువారీ Go జ్ఞానానికి అవసరమైనది మరియు తరచుగా ఇంటర్వ్యూ విషయం, ఎందుకంటే దాదాపు అన్ని సংగ్రహ పని వాటిని ఉపయోగిస్తుంది.