ముక్కలు: ఇడియోమాటిక్ నిర్మాణం

ఒక స్లైస్ అనేది Goలో ఎక్కువగా ఉపయోగించే డేటా నిర్మాణం: ఒక డైనమిక్ వీక్షణ అంతర్లీన శ్రేణిపై. సింటాక్స్: []T. శ్రేణుల వలె కాకుండా, పొడవు రకంలో భాగం కాదు మరియు మీరు దీన్ని appendతో పెంచుకోవచ్చు.

ఒక ముక్క యొక్క అనాటమీ

అంతర్గతంగా స్లైస్ అనేది మూడు-ఫీల్డ్ స్ట్రక్చర్:

• అంతర్లీన శ్రేణిలోని మొదటి మూలకానికి పాయింటర్
• a పొడవు (len): కనిపించే మూలకాల సంఖ్య
• a ** సామర్థ్యం** (cap): వీక్షణ ప్రారంభం నుండి మూలకాలు అందుబాటులో ఉన్నాయి అంతర్లీన శ్రేణి చివరి వరకు

s := []int{10, 20, 30}
fmt.Println(len(s), cap(s)) // 3 3

సృష్టి

a := []int{1, 2, 3}          // literal
b := make([]int, 3)          // [0 0 0]   len=3 cap=3
c := make([]int, 3, 10)      // len=3 cap=10 (reserved)
var d []int                  // nil slice: len=0 cap=0, still usable with append

append: ఎల్లప్పుడూ ఫలితాన్ని కేటాయించండి

append మూలకాలను జోడించి, కొత్త స్లైస్ (సంభావ్యతతో) అందిస్తుంది సామర్థ్యం సరిపోకపోతే కొత్త శ్రేణిని కేటాయించడం):

s := []int{1, 2, 3}
s = append(s, 4)              // [1 2 3 4]
s = append(s, 5, 6, 7)        // append multiple elements
s = append(s, altra...)       // concatenate another slice (spread)

స్లైస్ ఎక్స్‌ప్రెషన్ s[a:b]

a (కలిసి) నుండి b (ప్రత్యేకమైన) వరకు ఉప-స్లైస్‌ని సంగ్రహిస్తుంది:

s := []int{10, 20, 30, 40, 50}
sub := s[1:4]              // [20 30 40]
inizio := s[:2]            // [10 20]
fine := s[3:]              // [40 50]
intera := s[:]             // [10 20 30 40 50]

ఉప-స్లైస్‌లు అంతర్లీన శ్రేణిని అసలు స్లైస్‌తో భాగస్వామ్యం చేస్తాయి: sub[i] = ... ద్వారా ఉత్పరివర్తనలు sలో కూడా కనిపిస్తాయి.

ఆపద: శ్రేణి భాగస్వామ్యం

s := []int{1, 2, 3, 4}
sub := s[0:2]
sub[0] = 99
fmt.Println(s)             // [99 2 3 4] — modified!

స్వతంత్ర కాపీని పొందడానికి, copy లేదా appendని ఉపయోగించండి:

out := make([]int, len(sub))
copy(out, sub)

దీనిని ప్రయత్నించండి

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

రీక్యాప్

• []T: శ్రేణిపై డైనమిక్ వీక్షణ; ట్రిపుల్ (ptr, len, cap).
• make([]T, len, cap) ముందుగా కేటాయించడానికి; var s []T ఉపయోగించదగిన నిల్ స్లైస్ కోసం.
• s = append(s, ...): ఎల్లప్పుడూ ఫలితాన్ని కేటాయించండి.
• s[a:b] అంతర్లీన శ్రేణిని భాగస్వామ్యం చేస్తుంది: copy(...) స్వతంత్ర కాపీల కోసం.
• A nil స్లైస్ = చదవడానికి/పరిధి/అనుబంధించడానికి సరే; నిల్ మ్యాప్ నుండి చాలా భిన్నంగా ఉంటుంది.