సంతకం మరియు పారామితులు

Goలో, funcతో విధులు ప్రకటించబడ్డాయి. సంతకం సింటాక్స్ భిన్నంగా ఉంటుంది C/Java నుండి: పరామితి పేరు తర్వాత టైప్ వెళుతుంది, a ద్వారా వేరు చేయబడింది స్థలం. ఇది బిగ్గరగా బాగా చదివే ఎంపిక — బదులుగా "n of type int" యొక్క "int n".

ప్రాథమిక వాక్యనిర్మాణం

func sum(a int, b int) int {
    return a + b
}

func greet(name string) {
    fmt.Println("ciao", name)
}

రిటర్న్ విలువ లేని ఫంక్షన్ రిటర్న్ రకాన్ని వదిలివేస్తుంది.

ఒకే రకమైన వరుస పారామితులు

బహుళ వరుస పారామితులు ఒకే రకాన్ని పంచుకుంటే, మీరు ప్రకటించవచ్చు ఇది చివరిదానిలో ఒక్కసారి మాత్రమే. ఇది ఇడియోమాటిక్ మరియు మీరు దీన్ని ప్రతిచోటా చూస్తారు:

func sum(a, b int) int { return a + b }
func max3(a, b, c float64) float64 { /* ... */ }
func parse(s, sep string, limit int) []string { /* ... */ }

ఎగుమతి చేసిన vs ఎగుమతి చేయని ఫంక్షన్‌లు

గోలో, దృశ్యత పేరు ద్వారా నిర్ణయించబడుతుంది: ప్రారంభమయ్యే ఐడెంటిఫైయర్‌లు పెద్ద అక్షరంతో ఎగుమతి చేయబడింది (ఇతర ప్యాకేజీల నుండి కనిపిస్తుంది), మిగిలినవి ప్యాకేజీకి ప్రైవేట్‌గా ఉంటాయి.

func Sum(a, b int) int { ... }    // esportata
func helper() { ... }              // privata al package

విలువలుగా విధులు

విధులు ఫస్ట్-క్లాస్ విలువలు: మీరు వాటిని కేటాయించవచ్చు, పాస్ చేయవచ్చు మరియు వాటిని తిరిగి ఇవ్వండి. మేము మూసివేతలపై పాఠంలో లోతుగా త్రవ్విస్తాము.

op := sum            // op ha tipo func(int, int) int
fmt.Println(op(2, 3)) // 5

main మరియు init: రెండు ప్రత్యేక పేర్లు

• func main() అనేది main ప్యాకేజీకి ప్రవేశ స్థానం. వాదనలు లేవు, రిటర్న్ విలువలు లేవు.
• func init() ప్యాకేజీ ప్రారంభంలో స్వయంచాలకంగా పిలువబడుతుంది (మల్టిపుల్ కూడా అనేక ఫైల్‌లు ఒకదానిని నిర్వచించినప్పుడు సార్లు). సెటప్ కోసం ఉపయోగకరమైన; పొదుపుగా వాడండి.

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

func f(? ?) {}

రీక్యాప్

• func name(param type, ...) returnType { ... }.
• పేరు తర్వాత టైప్ చేయండి; ఒకే రకమైన వరుస పారామితులు → ఒక్కసారి మాత్రమే ప్రకటించండి.
• పెద్ద అక్షరం ప్రారంభ = ఎగుమతి చేయబడింది; చిన్న అక్షరం = ప్యాకేజీకి ప్రైవేట్.
• విధులు ఫస్ట్-క్లాస్ (కేటాయించదగినవి, పాస్ చేయదగినవి).
• main మరియు init ప్రత్యేక సెమాంటిక్స్‌తో రిజర్వు చేయబడిన పేర్లు.