ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 4 · 5లో పాఠం 1కోర్సులో 16/50~8 min
మాడ్యూల్ పాఠాలు (1/5)

స్థిర-పొడవు శ్రేణులు

గోలో శ్రేణి ఒక స్థిరమైన పొడవును కలిగి ఉంటుంది, దాని రకంగా బేక్ చేయబడింది: [N]T. ఇది చాలా అరుదుగా నేరుగా అప్లికేషన్ కోడ్‌లో ఉపయోగించబడుతుంది - మీరు దాదాపు ఎల్లప్పుడూ డైనమిక్‌గా ఉండే ** ముక్కలతో** (తదుపరి పాఠం) పని చేస్తుంది శ్రేణులపై వీక్షణలు.

అయినప్పటికీ, శ్రేణులను బాగా అర్థం చేసుకోవడం చాలా అవసరం: గోలోని ప్రతిదీ నిర్మించబడింది వాటి పైన.

ప్రకటన మరియు ప్రారంభించడం

Go
var a [3]int = [3]int{10, 20, 30}
b := [3]int{1, 2, 3}            // inference with :=
c := [3]int{}                   // all zero: [0, 0, 0]
d := [...]int{1, 2, 3, 4}       // length inferred = 4

శ్రేణి యొక్క సున్నా విలువ ప్రతిదానితో పాటుగా ప్రకటించబడిన పొడవు యొక్క శ్రేణి మూలకం దాని సున్నా విలువలో:

Go
var nums [5]int  // [0 0 0 0 0]

ఇండెక్సింగ్ మరియు len

Go
a := [3]int{10, 20, 30}
fmt.Println(a[0])      // 10
a[1] = 99
fmt.Println(len(a))    // 3

పరిధి వెలుపల యాక్సెస్ రన్‌టైమ్ భయాందోళనకు కారణమవుతుంది (నిశ్శబ్దంగా నిర్వచించబడదు C లో లాగా).

పొడవు రకంలో భాగం

Go
var a [3]int
var b [4]int
// a = b   // ERROR: different types

[3]int మరియు [4]int రెండూ కలిగి ఉన్నప్పటికీ ప్రత్యేక రకాలు int. ఇందువల్ల శ్రేణులు చాలా అరుదుగా ఫంక్షన్‌లకు పంపబడతాయి: మీరు చేయాల్సి ఉంటుంది పరామితి రకంలో పొడవును హార్డ్-కోడ్ చేయండి.

విలువ ద్వారా కాపీ చేయండి

స్లైస్‌లు (రిఫరెన్స్) మరియు మ్యాప్‌లు (రిఫరెన్స్) కాకుండా, శ్రేణులు ** ద్వారా కాపీ చేయబడతాయి విలువ**:

Go
a := [3]int{1, 2, 3}
b := a               // copy
b[0] = 99
fmt.Println(a[0])    // 1 — a is unchanged

ఫంక్షన్‌కు వెళ్లేటప్పుడు కూడా ఇది వర్తిస్తుంది: ఫంక్షన్ దానిని అందుకుంటుంది సొంత కాపీ.

శ్రేణులను ఎప్పుడు ఉపయోగించాలి?

  • కంపైల్ సమయంలో తెలిసిన స్థిర-పరిమాణ బఫర్‌లు (ఉదా. MD5 కోసం [16]byte).
  • కాంపోజిట్ మ్యాప్ కీలు (స్లైస్‌లు "పోల్చదగినవి" కావు, శ్రేణులు).
  • విపరీతమైన పనితీరు (పరోక్ష కాదు, కాష్-ఫ్రెండ్లీ).

99% కోడ్ కోసం: ముక్కలను ఉపయోగించండి.

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

వ్యాయామం#go.m4.l1.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

10, 20, 30 విలువలతో 3 ints యొక్క శ్రేణిని ప్రకటించండి మరియు దాని పొడవును ముద్రించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

అర్రే లిటరల్: `[3]int{a, b, c}`.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం#go.m4.l1.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

bని 5 ints (అన్నీ సున్నా) శ్రేణిగా ప్రకటించండి మరియు 99ని స్థానం 2కి కేటాయించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

`var b [5]int` [0 0 0 0 0]గా ప్రారంభమవుతుంది.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

Quiz#go.m4.l1.e3
సిద్ధంగా ఉంది

[3]int మరియు [4]int ఒకే రకమా?

Go
var a [3]int
var b [4]int
// a = b ?
సమాధాన ఎంపికలు

రీక్యాప్

  • [N]T: స్థిరమైన పొడవు, రకంలో భాగం.
  • సున్నా విలువ: ప్రతి మూలకం దాని సున్నా విలువ వద్ద.
  • [...]int{...} కంపైలర్ పొడవును అంచనా వేయడానికి అనుమతిస్తుంది.
  • విలువ ద్వారా కాపీ చేయండి (అంతర్గత ఫంక్షన్‌లతో సహా).
  • పరిధి వెలుపల = భయాందోళన, నిర్వచించబడలేదు.
  • ఆచరణలో, స్లైస్‌లను ఉపయోగించండి, ఇవి శ్రేణులపై వీక్షణలు.