మాడ్యూల్ పాఠాలు (1/5)
స్థిర-పొడవు శ్రేణులు
గోలో శ్రేణి ఒక స్థిరమైన పొడవును కలిగి ఉంటుంది, దాని రకంగా బేక్ చేయబడింది: [N]T.
ఇది చాలా అరుదుగా నేరుగా అప్లికేషన్ కోడ్లో ఉపయోగించబడుతుంది - మీరు
దాదాపు ఎల్లప్పుడూ డైనమిక్గా ఉండే ** ముక్కలతో** (తదుపరి పాఠం) పని చేస్తుంది
శ్రేణులపై వీక్షణలు.
అయినప్పటికీ, శ్రేణులను బాగా అర్థం చేసుకోవడం చాలా అవసరం: గోలోని ప్రతిదీ నిర్మించబడింది వాటి పైన.
ప్రకటన మరియు ప్రారంభించడం
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శ్రేణి యొక్క సున్నా విలువ ప్రతిదానితో పాటుగా ప్రకటించబడిన పొడవు యొక్క శ్రేణి మూలకం దాని సున్నా విలువలో:
var nums [5]int // [0 0 0 0 0]ఇండెక్సింగ్ మరియు len
a := [3]int{10, 20, 30}
fmt.Println(a[0]) // 10
a[1] = 99
fmt.Println(len(a)) // 3పరిధి వెలుపల యాక్సెస్ రన్టైమ్ భయాందోళనకు కారణమవుతుంది (నిశ్శబ్దంగా నిర్వచించబడదు C లో లాగా).
పొడవు రకంలో భాగం
var a [3]int
var b [4]int
// a = b // ERROR: different types[3]int మరియు [4]int రెండూ కలిగి ఉన్నప్పటికీ ప్రత్యేక రకాలు
int. ఇందువల్ల శ్రేణులు చాలా అరుదుగా ఫంక్షన్లకు పంపబడతాయి: మీరు చేయాల్సి ఉంటుంది
పరామితి రకంలో పొడవును హార్డ్-కోడ్ చేయండి.
విలువ ద్వారా కాపీ చేయండి
స్లైస్లు (రిఫరెన్స్) మరియు మ్యాప్లు (రిఫరెన్స్) కాకుండా, శ్రేణులు ** ద్వారా కాపీ చేయబడతాయి విలువ**:
a := [3]int{1, 2, 3}
b := a // copy
b[0] = 99
fmt.Println(a[0]) // 1 — a is unchangedఫంక్షన్కు వెళ్లేటప్పుడు కూడా ఇది వర్తిస్తుంది: ఫంక్షన్ దానిని అందుకుంటుంది సొంత కాపీ.
శ్రేణులను ఎప్పుడు ఉపయోగించాలి?
- కంపైల్ సమయంలో తెలిసిన స్థిర-పరిమాణ బఫర్లు (ఉదా. MD5 కోసం
[16]byte). - కాంపోజిట్ మ్యాప్ కీలు (స్లైస్లు "పోల్చదగినవి" కావు, శ్రేణులు).
- విపరీతమైన పనితీరు (పరోక్ష కాదు, కాష్-ఫ్రెండ్లీ).
99% కోడ్ కోసం: ముక్కలను ఉపయోగించండి.
దీనిని ప్రయత్నించండి
10, 20, 30 విలువలతో 3 ints యొక్క శ్రేణిని ప్రకటించండి మరియు దాని పొడవును ముద్రించండి.
సూచనను చూపించు
అర్రే లిటరల్: `[3]int{a, b, c}`.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
bని 5 ints (అన్నీ సున్నా) శ్రేణిగా ప్రకటించండి మరియు 99ని స్థానం 2కి కేటాయించండి.
సూచనను చూపించు
`var b [5]int` [0 0 0 0 0]గా ప్రారంభమవుతుంది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
[3]int మరియు [4]int ఒకే రకమా?
var a [3]int
var b [4]int
// a = b ?రీక్యాప్
[N]T: స్థిరమైన పొడవు, రకంలో భాగం.- సున్నా విలువ: ప్రతి మూలకం దాని సున్నా విలువ వద్ద.
[...]int{...}కంపైలర్ పొడవును అంచనా వేయడానికి అనుమతిస్తుంది.- విలువ ద్వారా కాపీ చేయండి (అంతర్గత ఫంక్షన్లతో సహా).
- పరిధి వెలుపల = భయాందోళన, నిర్వచించబడలేదు.
- ఆచరణలో, స్లైస్లను ఉపయోగించండి, ఇవి శ్రేణులపై వీక్షణలు.