గో ప్రోగ్రామింగ్ లాంగ్వేజ్ అని కూడా పిలువబడే గోలాంగ్ అనేది 2007లో గూగుల్ రూపొందించిన ఓపెన్ సోర్స్ ప్రోగ్రామింగ్ లాంగ్వేజ్. ఈ భాష యొక్క వెర్షన్ 1.0 2012లో విడుదలైంది. ఇది C వంటి నిర్మాణాత్మక ప్రోగ్రామింగ్ లాంగ్వేజ్ మరియు నెట్‌వర్కింగ్ సేవలు, క్లౌడ్ వంటి వివిధ రకాల అప్లికేషన్లు. అప్లికేషన్లు, వెబ్ అప్లికేషన్లు మొదలైనవాటిని గోలాంగ్ భాష ద్వారా అభివృద్ధి చేయవచ్చు. ఇది పైథాన్ వంటి అనేక రకాల ప్యాకేజీలను కలిగి ఉంటుంది. ఇది నేర్చుకోవడం చాలా సులభం, ఇది కొత్త ప్రోగ్రామర్‌ల కోసం ఈ భాషను ప్రముఖంగా చేస్తుంది. 30 గోలాంగ్ ప్రోగ్రామింగ్ ఉదాహరణలు ఈ ట్యుటోరియల్‌లో బేసిక్స్ నుండి గోలాంగ్ నేర్చుకోవడానికి వివరించబడ్డాయి.
ముందస్తు అవసరాలు:
వివిధ రకాల ఆపరేటింగ్ సిస్టమ్‌ల ద్వారా గోలాంగ్‌కు మద్దతు ఉంది. ఉబుంటులో గోలాంగ్‌ని ఇన్స్టాల్ చేసే విధానం ఈ ట్యుటోరియల్‌లో చూపబడింది. సిస్టమ్‌ను నవీకరించడానికి క్రింది ఆదేశాలను అమలు చేయండి మరియు ఈ ట్యుటోరియల్‌లోని ఉదాహరణలను సాధన చేయడానికి ముందు సిస్టమ్‌లో గోలాంగ్‌ను ఇన్స్టాల్ చేయండి.
$ సుడో సముచితమైన నవీకరణ
$ సుడో సముచితమైనది ఇన్స్టాల్ పెరుగుతాయి
గోలాంగ్ యొక్క ఇన్స్టాల్ చేసిన సంస్కరణను తనిఖీ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి.
$ గో వెర్షన్
- హలో హలో వరల్డ్
- గోలాంగ్ స్ట్రింగ్ వేరియబుల్స్
- స్ట్రింగ్ నుండి గోలాంగ్ పూర్ణాంకానికి
- లోపలికి గోలాంగ్ స్ట్రింగ్ t
- గోలాంగ్ స్ట్రింగ్ సంయోగం
- గోలాంగ్ మల్టీలైన్ స్ట్రింగ్
- గోలాంగ్ స్ప్లిట్ స్ట్రింగ్
- గోలాంగ్ స్ప్రింట్ఎఫ్
- గోలాంగ్ ఎనమ్
- గోలాంగ్ నిర్మాణం
- గోలన్ శ్రేణి
- గోలాంగ్ సెట్లు
- లూప్ కోసం గోలాంగ్
- పరిధి కోసం గోలాంగ్
- గోలాంగ్ అయితే లూప్
- గోలాంగ్ కొనసాగుతుంది
- గోలాంగ్ స్విచ్ కేసు
- గోలాంగ్ యాదృచ్ఛిక సంఖ్య
- గోలాంగ్ నిద్ర
- గోల్డెన్ టైమ్
- గోలాంగ్ uuid
- గోలాంగ్ రీడ్ ఫైల్
- గోలాంగ్ ఫైల్‌ని లైన్ వారీగా చదివాడు
- గోలాంగ్ ఫైల్‌కి వ్రాయండి
- గోలాంగ్ ఫైల్ ఉందో లేదో తనిఖీ చేయండి
- గోలన్ csv
- గోలాంగ్ యమ్ల్
- గోలాంగ్ http అభ్యర్థన
- గోలాంగ్ కమాండ్ లైన్ ఆర్గ్యుమెంట్స్
- గోలాంగ్ లోపం నిర్వహణ
హలో హలో వరల్డ్
ది ప్రధాన గోలాంగ్ యొక్క ప్యాకేజీ గోలాంగ్ ప్రోగ్రామింగ్ కోసం అవసరమైన అన్ని ప్యాకేజీలను కలిగి ఉంది మరియు గోలాంగ్ స్క్రిప్ట్ యొక్క అమలును ప్రారంభించడం అవసరం. ది fmt టెర్మినల్‌లో ఫార్మాట్ చేసిన స్ట్రింగ్‌ను ప్రింట్ చేయడానికి దిగుమతి చేయడానికి ప్యాకేజీ అవసరం. కింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. స్ట్రింగ్ విలువ, ‘హలో వరల్డ్.’ స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత టెర్మినల్‌లో ముద్రించబడుతుంది.
//అవుట్‌పుట్‌ను ప్రింట్ చేయడానికి fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//ఎగ్జిక్యూషన్‌ను ప్రారంభించడానికి ప్రధాన() ఫంక్షన్‌ను నిర్వచించండి
ఫంక్ ప్రధాన () {
//కొత్త లైన్‌తో సాధారణ సందేశాన్ని ముద్రించండి
fmt . Println ( 'హలో వరల్డ్.' )
}
స్క్రిప్ట్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి. ఇక్కడ, స్క్రిప్ట్ ఉదాహరణ1, గో ఫైల్‌లో సేవ్ చేయబడింది.
$ Example1.go రన్ చేయిగోలాంగ్ ఫైల్ యొక్క బైనరీ ఫైల్‌ను రూపొందించడానికి కింది ఆదేశాన్ని అమలు చేయండి.
$ బిల్డ్ example1.go
ఎక్జిక్యూటబుల్ ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి.
$ . / ఉదాహరణ 1పై ఆదేశాలను అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది,,
గోలాంగ్ స్ట్రింగ్ వేరియబుల్స్
స్ట్రింగ్ వేరియబుల్స్ డేటా రకాన్ని నిర్వచించకుండా మరియు గోలాంగ్‌లోని డేటా రకంతో ఉపయోగించవచ్చు. కింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి, అది సాధారణ స్ట్రింగ్ డేటాను మరియు స్ట్రింగ్ వేరియబుల్స్‌తో స్ట్రింగ్ డేటాను ప్రింట్ చేస్తుంది. యొక్క ఉపయోగాలు Printf() మరియు Println() విధులు స్క్రిప్ట్‌లో చూపబడ్డాయి.
ప్యాకేజీ ప్రధాన//అవుట్‌పుట్‌ను ప్రింట్ చేయడానికి fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//మెయిన్() ఫంక్షన్‌ను నిర్వచించండి
ఫంక్ ప్రధాన () {
//ఒక కొత్త లైన్‌తో స్ట్రింగ్ విలువను ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'LinuxHint.com నుండి గోలాంగ్ నేర్చుకోండి. \n ' )
//మొదటి స్ట్రింగ్ వేరియబుల్‌ని నిర్వచించండి
ఉంది str1 = 'గోలాంగ్ ప్రోగ్రామింగ్.'
//న్యూలైన్ లేకుండా వేరియబుల్‌ను ప్రింట్ చేయండి
fmt . ప్రింట్ఎఫ్ ( '%s తెలుసుకోండి' , str1 )
//రెండవ స్ట్రింగ్ వేరియబుల్‌ని నిర్వచించండి
ఉంది str2 = 'నేర్చుకోవడం సులభం.'
//వేరియబుల్‌ను కొత్త లైన్‌తో ప్రింట్ చేయండి
fmt . Println ( 'అది' , str2 )
}
పై స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. రెండు సంయోగ తీగల అవుట్‌పుట్ ఇక్కడ ముద్రించబడింది.
స్ట్రింగ్ నుండి గోలాంగ్ పూర్ణాంకానికి
ది strconv.Choke() మరియు strconv.FormatInt() గోలాంగ్‌లో పూర్ణాంకాన్ని స్ట్రింగ్ విలువగా మార్చడానికి ఫంక్షన్‌లను ఉపయోగించవచ్చు. ది strconv.Choke() పూర్ణాంక విలువను సంఖ్యల స్ట్రింగ్‌గా మార్చడానికి ఉపయోగించబడుతుంది. ది strconv.FormatInt() దశాంశ-ఆధారిత పూర్ణాంక విలువలను స్ట్రింగ్‌గా మార్చడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. పైన పేర్కొన్న ఫంక్షన్‌లను ఉపయోగించడం ద్వారా గోలాంగ్‌లో పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చే మార్గాన్ని చూపే కింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. వినియోగదారు నుండి ఒక సంఖ్య తీసుకోబడుతుంది మరియు సంఖ్య యొక్క సంబంధిత స్ట్రింగ్ విలువ అవుట్‌పుట్‌గా ముద్రించబడుతుంది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//fmt మరియు strconv ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'strconv'
)
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//పూర్ణాంక వేరియబుల్‌ని ప్రకటించండి
ఉంది n int
//సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'సంఖ్యను నమోదు చేయండి:' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & n )
//Itoa() ఫంక్షన్‌ని ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చండి
మార్చు1 := strconv . మునిగిపోయాడు ( n )
fmt . ప్రింట్ఎఫ్ ( 'Itoa(): %s ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మారుస్తోంది \n ' , మార్చు1 )
//FormatInt() ఫంక్షన్‌ని ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చండి
మార్చు2 := strconv . FormatInt ( int64 ( n ), 10 )
fmt . ప్రింట్ఎఫ్ ( 'FormatInt(): %s ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మారుస్తోంది \n ' , మార్చు2 )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. సంఖ్య. 45 స్ట్రింగ్‌గా మార్చబడింది. '45'.
పూర్ణాంకానికి గోలాంగ్ స్ట్రింగ్
ది strconv.Atoi() గోలాంగ్‌లో స్ట్రింగ్‌ను పూర్ణాంకానికి మార్చడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది పూర్ణాంకంలోకి మార్చబడే స్ట్రింగ్ విలువను తీసుకుంటుంది మరియు రెండు రకాల విలువలను అందిస్తుంది. సంభాషణ విజయవంతమైతే ఒక విలువ పూర్ణాంకం మరియు సంభాషణ విఫలమైతే మరొక విలువ లోపం శూన్యం విలువ తిరిగి ఇవ్వబడుతుంది. కింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి, అది ఉపయోగించి అనేక స్ట్రింగ్ విలువలను పూర్ణాంకంలోకి మారుస్తుంది strconv.Atoi() ఫంక్షన్. స్ట్రింగ్ విలువ, “342” 342 సంఖ్యగా మార్చబడుతుంది మరియు అమలు తర్వాత ముద్రించబడుతుంది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//fmt మరియు strconv ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'strconv'
)
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించండి
str := '342'
//Atoi() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌ను పూర్ణాంకానికి మార్చండి
ధర , తప్పు := strconv . ట్రైలర్ ( str )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
//మార్పిడి చేసిన విలువను ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'పుస్తకం ధర %d \n ' , ధర )
} లేకపోతే {
//దోష సందేశాన్ని ముద్రించండి
fmt . Println ( తప్పు )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. స్ట్రింగ్ విలువ, “342” ఇక్కడ 342కి మార్చబడింది.
గోలాంగ్ స్ట్రింగ్ సంయోగం
Printf() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా స్ట్రింగ్‌లను ‘+’ ఆపరేటర్‌తో కలిపే కింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. ‘+’ ఆపరేటర్‌ని ఉపయోగించడం ద్వారా సంయోగం చేయబడిన స్ట్రింగ్ విలువను ముద్రించడానికి Println() ఫంక్షన్ ఇక్కడ ఉపయోగించబడింది మరియు '%s' స్పెసిఫైయర్‌ని ఉపయోగించి సంయోగం చేయబడిన స్ట్రింగ్ విలువను ముద్రించడానికి Printf() ఫంక్షన్ ఇక్కడ ఉపయోగించబడింది. స్క్రిప్ట్‌లో రెండు స్ట్రింగ్ వేరియబుల్స్ డిక్లేర్ చేయబడ్డాయి, అవి తరువాత సంగ్రహించబడ్డాయి.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//అవుట్‌పుట్‌ను ప్రింట్ చేయడానికి fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//రెండు స్ట్రింగ్ వేరియబుల్స్ డిక్లేర్ చేయండి
ఉంది str1 , str2 స్ట్రింగ్
//స్ట్రింగ్ విలువలను కేటాయించండి
str1 = 'గోలన్'
str2 = 'ప్రోగ్రామింగ్'
//'+' ఆపరేటర్‌ని ఉపయోగించి స్ట్రింగ్‌ను సంగ్రహించడం
fmt . Println ( ''+' ఆపరేటర్‌ని ఉపయోగించి సంకలిత స్ట్రింగ్ విలువ:' , str1 + str2 )
//'%s' స్పెసిఫైయర్‌ని ఉపయోగించి స్ట్రింగ్‌ను సంగ్రహించడం
fmt . ప్రింట్ఎఫ్ ( 'ఫార్మాట్ స్పెసిఫైయర్‌ని ఉపయోగించి సంకలిత స్ట్రింగ్ విలువ: %s%s \n ' , str1 , str2 )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ బహుళ-లైన్ స్ట్రింగ్
గోలాంగ్ స్క్రిప్ట్‌ని ఉపయోగించి బహుళ-లైన్ వచనాన్ని ముద్రించడానికి క్రింది ఉదాహరణలో మూడు విభిన్న మార్గాలు చూపబడ్డాయి. బహుళ-లైన్ వచనాన్ని రూపొందించడానికి మొదటి స్ట్రింగ్ వేరియబుల్‌లో ‘\n’ అక్షరం ఉపయోగించబడింది. బహుళ-లైన్ వచనాన్ని ముద్రించడానికి బ్యాక్‌టిక్‌లు (`) రెండవ స్ట్రింగ్‌లో ఉపయోగించబడ్డాయి. బహుళ-లైన్ వచనాన్ని ముద్రించడానికి మూడవ స్ట్రింగ్‌లో స్పెసిఫైయర్‌లతో బ్యాక్‌టిక్‌లు (`) ఉపయోగించబడ్డాయి.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//'\n' అక్షరంతో బహుళ-లైన్ స్ట్రింగ్ విలువను ప్రకటించండి
str1 := 'గోలాంగ్ ప్రోగ్రామింగ్ చాలా సులభం \n నేర్చుకోవడం. \n \n '
fmt . ప్రింట్ఎఫ్ ( str1 )
//బ్యాక్‌టిక్‌లతో (`) బహుళ-లైన్ స్ట్రింగ్ విలువను ప్రకటించండి
str2 := `నేర్చుకో
గోలాంగ్
నుండి
LinuxHint
బ్లాగ్.`
fmt . ప్రింట్ఎఫ్ ( '%s \n \n ' , str2 )
//రెండు స్ట్రింగ్ విలువలను ప్రకటించండి
భాష := 'గోలన్'
డెవలపర్ := 'గూగుల్'
//వేరియబుల్స్ మరియు బ్యాక్‌టిక్‌లతో స్ట్రింగ్ విలువను ప్రకటించండి
str3 := `%s
ఉంది
అభివృద్ధి చేశారు
ద్వారా
%s.`
fmt . ప్రింట్ఎఫ్ ( str3 , భాష , డెవలపర్ )
//కొత్త పంక్తిని జోడించండి
fmt . Println ()
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. బహుళ-లైన్ స్ట్రింగ్ విలువలను కలిగి ఉన్న మూడు స్ట్రింగ్ వేరియబుల్స్ యొక్క అవుట్‌పుట్ ఇక్కడ ముద్రించబడింది.
గోలాంగ్ స్ప్లిట్ స్ట్రింగ్
strings.Split() ఫంక్షన్ సెపరేటర్ ఆధారంగా స్ట్రింగ్ డేటాను విభజించడానికి ఉపయోగించబడింది. కింది స్క్రిప్ట్ వినియోగదారు నుండి స్ట్రింగ్ విలువను తీసుకుంటుంది మరియు కోలన్ (:) ఆధారంగా స్ట్రింగ్ విలువను విభజిస్తుంది. స్ప్లిట్ విలువల మొత్తం సంఖ్య మరియు మొదటి రెండు స్ప్లిట్ విలువలు అమలు చేసిన తర్వాత ముద్రించబడతాయి.
ప్యాకేజీ ప్రధాన//fmt మరియు స్ట్రింగ్స్ ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'తీగలు'
)
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించండి
ఉంది str స్ట్రింగ్
//ప్రాంప్ట్ సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'కోలన్‌తో స్ట్రింగ్‌ను నమోదు చేయండి(:)-' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & str )
//విభజనను నిర్వచించండి
వేరుచేసేవాడు := ':'
//స్ట్రింగ్ విలువను విభజించండి
స్ప్లిట్_విలువ := తీగలను . విభజించండి ( str , వేరుచేసేవాడు )
//స్ప్లిట్ విలువల సంఖ్యను లెక్కించండి
పొడవు := మాత్రమే ( స్ప్లిట్_విలువ )
//స్ప్లిట్ విలువల సంఖ్యను ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'విభజన విలువల మొత్తం సంఖ్య %d \n ' , పొడవు )
//స్ప్లిట్ విలువలను ప్రింట్ చేయండి
fmt . Println ( 'మొదటి విభజన విలువ' , స్ప్లిట్_విలువ [ 0 ])
fmt . Println ( 'రెండవ విభజన విలువ' , స్ప్లిట్_విలువ [ 1 ])
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. ఇన్‌పుట్ విలువ, “golang:google” కోలన్ (:) ఆధారంగా రెండు భాగాలుగా విభజించబడింది.
గోలాంగ్ స్ప్రింట్ఎఫ్
Sprintf() ఫంక్షన్ గోలాంగ్‌లో ఫార్మాట్ చేయబడిన స్ట్రింగ్ విలువలను ఇతర ప్రామాణిక ప్రోగ్రామింగ్ భాషల వలె వేరియబుల్‌లో నిల్వ చేయడానికి ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్‌లో స్ట్రింగ్ మరియు పూర్ణాంక వేరియబుల్ ప్రకటించబడ్డాయి. ఈ వేరియబుల్స్ యొక్క విలువలు Sprintf() ఫంక్షన్‌ని ఉపయోగించి వేరియబుల్‌గా ఫార్మాట్ చేయబడ్డాయి మరియు నిల్వ చేయబడతాయి.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//ప్రధాన విధిని నిర్వచించండి
ఫంక్ ప్రధాన () {
//రెండు వేరియబుల్స్ డిక్లేర్ చేయండి
ఉంది str స్ట్రింగ్
ఉంది ఒకదానిపై int
//స్ట్రింగ్ విలువను కేటాయించండి
str = 'గోలన్'
//సంఖ్య విలువను కేటాయించండి
ఒకదానిపై = 2012
//కలిపిన స్ట్రింగ్ విలువను వేరియబుల్‌లో నిల్వ చేయండి
కలిపి_str := fmt . స్ప్రింట్ఎఫ్ ( '%s యొక్క మొదటి సంస్కరణ %dలో విడుదల చేయబడింది.' , str , ఒకదానిపై )
//వేరియబుల్‌ని ప్రింట్ చేయండి
fmt . ప్రింట్ఎఫ్ ( 'Sprintf() యొక్క అవుట్‌పుట్ \n %s \n ' , కలిపి_str )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ ఎనమ్
సంబంధిత స్థిరమైన విలువల సమూహం యొక్క డేటా రకాన్ని ప్రకటించడానికి గోలాంగ్‌లో ఎన్యూమ్ లేదా ఎన్యూమరేటర్ ఉపయోగించబడింది. గోలాంగ్‌లో enum రకం యొక్క ప్రకటన ఇతర ప్రోగ్రామింగ్ భాషల కంటే భిన్నంగా ఉంటుంది. ఒక enum రకం 12 విలువలు ప్రకటించబడ్డాయి మరియు నిర్దిష్ట enum విలువ యొక్క సంఖ్యా విలువ తర్వాత ముద్రించబడింది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//నెల విలువను సంఖ్యలో నిల్వ చేయడానికి రకాన్ని ప్రకటించండి (1-12)
రకం నెల int
//1 నుండి ప్రారంభమయ్యే ప్రతి నెల విలువకు స్థిరాంకాలను ప్రకటించండి
స్థిరంగా (
జనవరి నెల = అయోటా + 1
ఫిబ్రవరి
Mar
ఏప్రిల్
మే
జూన్
జూలై
ఆగస్ట్
సెప్టెంబరు
అక్టోబర్
నవంబర్
డిసెంబర్
)
//ప్రధాన విధిని ప్రకటించండి
ఫంక్ ప్రధాన () {
//ఒక నెల విలువతో వేరియబుల్‌ని ప్రకటించండి
ఉంది M_num = మే
//నెల సంబంధిత సంఖ్య విలువను ముద్రించండి
fmt . Println ( 'సంఖ్యలో నెల విలువ' , M_num )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. మే యొక్క సంబంధిత సంఖ్యా విలువ 5.
గోలాంగ్ నిర్మాణం
వివిధ రకాల వేరియబుల్‌లను కలిగి ఉన్న రకాన్ని ప్రకటించడానికి గోలాంగ్‌లో స్ట్రక్ట్ లేదా స్ట్రక్చర్ ఉపయోగించబడుతుంది. ఇది పట్టిక డేటా లేదా బహుళ రికార్డులను నిల్వ చేయడానికి ఉపయోగపడుతుంది. కింది స్క్రిప్ట్‌లో, నాలుగు మూలకాల యొక్క స్ట్రక్చర్ వేరియబుల్ ప్రకటించబడింది. తరువాత, నిర్వచించిన స్ట్రక్ట్ వేరియబుల్ ఉపయోగించి రెండు రికార్డులు జోడించబడ్డాయి. struct విలువలను వివిధ మార్గాల్లో ముద్రించే విధానం స్క్రిప్ట్ చివరి భాగంలో చూపబడింది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
//నాలుగు మూలకాల నిర్మాణాన్ని నిర్వచించండి
రకం ఉత్పత్తి నిర్మాణం {
id స్ట్రింగ్
పేరు స్ట్రింగ్
పరిమాణం స్ట్రింగ్
ధర int
}
ఫంక్ ప్రధాన () {
//మొదటి స్ట్రక్చర్ వేరియబుల్‌ని డిక్లేర్ చేయండి
ఉత్పత్తి1 := ఉత్పత్తి { 'p-1209' , 'HDD' , '5TB' , 80 }
//రెండవ స్ట్రక్చర్ వేరియబుల్‌ని డిక్లేర్ చేయండి
ఉత్పత్తి2 := ఉత్పత్తి { 'p-7342' , 'మౌస్' , '' , పదిహేను }
//స్ట్రక్చర్ వేరియబుల్స్‌ని ప్రింట్ చేయండి
fmt . Println ( 'మొదటి ఉత్పత్తి:' , ఉత్పత్తి1 )
fmt . Println ( 'రెండవ ఉత్పత్తి:' , ఉత్పత్తి2 )
//మొదటి స్ట్రక్చర్ వేరియబుల్ యొక్క నాలుగు విలువలను విడిగా ప్రింట్ చేయండి
fmt . Println ( 'మొదటి ఉత్పత్తి వివరాలు:' )
fmt . Println ( 'ID:' , ఉత్పత్తి1 . id )
fmt . Println ( 'పేరు:' , ఉత్పత్తి1 . పేరు )
fmt . Println ( 'పరిమాణం:' , ఉత్పత్తి1 . పరిమాణం )
fmt . Println ( 'ధర:' , ఉత్పత్తి1 . ధర )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలన్ శ్రేణి
ఇతర ప్రామాణిక ప్రోగ్రామింగ్ భాషల వంటి నిర్దిష్ట డేటా రకం యొక్క బహుళ విలువలను నిల్వ చేయడానికి గోలాంగ్‌లో అర్రే వేరియబుల్ ఉపయోగించబడుతుంది. స్ట్రింగ్ విలువల శ్రేణి మరియు సంఖ్యా విలువల శ్రేణిని ప్రకటించే మరియు యాక్సెస్ చేసే విధానం స్క్రిప్ట్‌లో చూపబడింది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
//స్ట్రింగ్ విలువల శ్రేణిని ప్రకటించండి
str_arr := [ 4 ] స్ట్రింగ్ { 'గూగుల్ కామ్' , 'ask.com' , 'bing.com' , 'you.com' }
//తీగ యొక్క శ్రేణిని ముద్రించండి
fmt . Println ( 'స్ట్రింగ్ అర్రే విలువలు:' , str_arr )
//అరే యొక్క 3వ మూలకాన్ని ప్రింట్ చేయండి
fmt . Println ( 'శ్రేణి యొక్క 3వ విలువ' , str_arr [ 2 ])
//సంఖ్యా విలువల శ్రేణిని ప్రకటించండి
int_arr := [ 6 ] int { 65 , 3. 4 , 12 , 81 , 52 , 70 }
//పూర్ణాంక శ్రేణిని ముద్రించండి
fmt . Println ( 'పూర్ణాంక శ్రేణి విలువలు: ' , int_arr )
//అరే యొక్క 4వ మూలకాన్ని ముద్రించండి
fmt . Println ( 'శ్రేణి యొక్క 4వ విలువ' , int_arr [ 3 ])
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ సెట్లు
సెట్ అనేది విభిన్న విలువల సేకరణను నిల్వ చేయడానికి గోలాంగ్ యొక్క మరొక డేటా నిర్మాణం. ఇది ఒక వస్తువులో ప్రత్యేక విలువలను నిల్వ చేయడానికి ఉపయోగించబడుతుంది. గోలాంగ్‌కి ఇతర ప్రోగ్రామింగ్ భాషల వలె అంతర్నిర్మిత సెట్ డేటా నిర్మాణం లేదు. కానీ ఈ లక్షణాన్ని ఖాళీ నిర్మాణం{} మరియు మ్యాప్ ఉపయోగించి అమలు చేయవచ్చు. కింది స్క్రిప్ట్‌లో, ఖాళీ స్ట్రక్ట్‌తో మ్యాప్‌ని ఉపయోగించడం ద్వారా స్ట్రింగ్‌ల సెట్ వేరియబుల్ ప్రకటించబడింది. తరువాత, మూడు విలువలు జోడించబడ్డాయి, ఒక విలువ తొలగించబడింది మరియు సెట్‌లో ఒక విలువ మళ్లీ జోడించబడింది. సెట్ యొక్క విలువలు కలిసి మరియు విడిగా ముద్రించబడ్డాయి.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
//తీగల సమితిని నిర్వచించండి
కేవలం := పటం [ స్ట్రింగ్ ] నిర్మాణం {}{}
//ఖాళీ నిర్మాణాన్ని ఉపయోగించి సెట్‌లో మూడు మూలకాలను చొప్పించండి
కేవలం [ 'వెళ్ళండి' ] = నిర్మాణం {}{}
కేవలం [ 'బాష్' ] = నిర్మాణం {}{}
కేవలం [ 'పైథాన్' ] = నిర్మాణం {}{}
//సెట్‌లో ప్రస్తుతం ఉన్న ఎలిమెంట్‌లను ప్రింట్ చేయండి
fmt . Println ( కేవలం )
//సెట్ నుండి ఒక మూలకాన్ని తీసివేయండి
తొలగించు ( కేవలం , 'పైథాన్' )
//సెట్‌కి కొత్త ఎలిమెంట్‌ని జోడించండి
కేవలం [ 'జావా' ] = నిర్మాణం {}{}
//ఒక మూలకాన్ని తీసివేసి, జోడించిన తర్వాత సెట్ విలువలను ప్రింట్ చేయండి
fmt . Println ( కేవలం )
fmt . ప్రింట్ఎఫ్ ( ' \n సెట్ విలువలు: \n ' )
//సెట్‌లోని ప్రతి మూలకాన్ని విడిగా ప్రింట్ చేయండి
కోసం ఎల్ := పరిధి కేవలం {
fmt . Println ( ఎల్ )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
లూప్ కోసం గోలాంగ్
ది ఫర్ లూప్‌ని గోలాంగ్‌లో వివిధ మార్గాల్లో మరియు విభిన్న ప్రయోజనాల కోసం ఉపయోగించవచ్చు. లూప్ కోసం మూడు వ్యక్తీకరణల ఉపయోగం క్రింది స్క్రిప్ట్‌లో చూపబడింది. 5 ఇన్‌పుట్ విలువలను తీసుకోవడానికి లూప్ 5 సార్లు పునరావృతమవుతుంది మరియు ఈ ఇన్‌పుట్ విలువల మొత్తం తర్వాత ముద్రించబడుతుంది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
//పూర్ణాంక వేరియబుల్‌ని ప్రకటించండి
ఉంది సంఖ్య int
//మొత్తం విలువను నిల్వ చేయడానికి వేరియబుల్‌ను ప్రకటించండి
ఉంది మొత్తం = 0
//ఒక లూప్ నిర్వచించండి
కోసం n := 1 ; n < = 5 ; n ++ {
//ప్రాంప్ట్ సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'సంఖ్యను నమోదు చేయండి:' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & సంఖ్య )
//మొత్తం వేరియబుల్‌తో ఇన్‌పుట్ సంఖ్యను జోడించండి
మొత్తం = మొత్తం + సంఖ్య
}
//సమ్మషన్ ఫలితాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'ఐదు ఇన్‌పుట్ విలువల మొత్తం %d \n ' , మొత్తం )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. 6, 3, 4, 7 మరియు 9 మొత్తం 29.
పరిధి కోసం గోలాంగ్
స్ట్రింగ్, అర్రే మరియు మ్యాప్‌లను యాక్సెస్ చేయడానికి గోలాంగ్‌లోని లూప్‌తో పరిధి ఉపయోగించబడుతుంది. పరిధితో లూప్‌ని ఉపయోగించడం ద్వారా స్ట్రింగ్‌ల శ్రేణిని యాక్సెస్ చేసే విధానం క్రింది స్క్రిప్ట్‌లో చూపబడింది. లూప్ కోసం మొదటిది శ్రేణి విలువలను మాత్రమే ముద్రిస్తుంది మరియు లూప్ కోసం రెండవది శ్రేణి యొక్క సూచికలు మరియు విలువలను ముద్రిస్తుంది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
// స్ట్రింగ్ యొక్క శ్రేణిని ప్రకటించండి
పువ్వులు := [ 4 ] స్ట్రింగ్ { 'గులాబీ' , 'లిల్లీ' , 'డాలియా' , 'సన్ ఫ్లవర్' }
fmt . Println ( 'శ్రేణి విలువలు:' )
//శ్రేణి విలువలను ముద్రించండి
కోసం _ , విలువ := పరిధి పువ్వులు {
fmt . Println ( విలువ )
}
fmt . Println ( 'శ్రేణి సూచికలు మరియు విలువలు:' )
//ఇండెక్స్ ఆధారంగా శ్రేణి విలువలను ముద్రించండి
కోసం లో , విలువ := పరిధి పువ్వులు {
fmt . ప్రింట్ఎఫ్ ( '%d := %s \n ' , లో + 1 , విలువ )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ అయితే లూప్
గోలాంగ్‌కి ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల వలె వేల్ లూప్ లేదు. అయితే, లూప్‌ని ఉపయోగించడం ద్వారా అయితే లూప్ యొక్క ఫీచర్‌ని గోలాంగ్‌లో అమలు చేయవచ్చు. a for loopని ఉపయోగించడం ద్వారా కాసేపు లూప్‌ని అమలు చేసే విధానం క్రింది స్క్రిప్ట్‌లో చూపబడింది. ఫర్ లూప్ 4 సార్లు పునరావృతమవుతుంది మరియు నాలుగు సంఖ్యలను తీసుకుంటుంది. పాక్షిక విలువతో ఈ సంఖ్యల మొత్తం తర్వాత ముద్రించబడుతుంది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
కౌంటర్ := 1
మొత్తం := 0 . 0
ఉంది సంఖ్య ఫ్లోట్64
కోసం కౌంటర్ < = 4 {
//ప్రాంప్ట్ సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'సంఖ్యను నమోదు చేయండి:' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & సంఖ్య )
//మొత్తం వేరియబుల్‌తో ఇన్‌పుట్ సంఖ్యను జోడించండి
మొత్తం = మొత్తం + సంఖ్య
//కౌంటర్‌ను 1 పెంచండి
కౌంటర్ ++
}
//సమ్మషన్ ఫలితాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'నాలుగు ఇన్‌పుట్ విలువల మొత్తం %0.2f \n ' , మొత్తం )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. 6.8, 3.2, 8.5 మరియు 4.9 మొత్తం 23.40.
గోలాంగ్ కొనసాగుతుంది
షరతు ఆధారంగా నిర్దిష్ట స్టేట్‌మెంట్‌లను వదిలివేయడానికి ఏదైనా లూప్‌లో కొనసాగింపు స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్‌లో, కొనసాగింపు ప్రకటనను ఉపయోగించడం ద్వారా శ్రేణి యొక్క 2వ మరియు నాల్గవ విలువల విలువలను వదిలివేసే లూప్‌ను పునరావృతం చేయడానికి for loop ఉపయోగించబడుతుంది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
కౌంటర్ := 1
మొత్తం := 0 . 0
ఉంది సంఖ్య ఫ్లోట్64
కోసం కౌంటర్ < = 4 {
//ప్రాంప్ట్ సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'సంఖ్యను నమోదు చేయండి:' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & సంఖ్య )
//మొత్తం వేరియబుల్‌తో ఇన్‌పుట్ సంఖ్యను జోడించండి
మొత్తం = మొత్తం + సంఖ్య
//కౌంటర్‌ను 1 పెంచండి
కౌంటర్ ++
}
//సమ్మషన్ ఫలితాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'నాలుగు ఇన్‌పుట్ విలువల మొత్తం %0.2f \n ' , మొత్తం )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ స్విచ్ కేసు
గోలాంగ్‌లోని స్విచ్-కేస్ స్టేట్‌మెంట్ ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల మాదిరిగానే ఉంటుంది కానీ గోలాంగ్‌లోని ప్రతి కేస్ స్టేట్‌మెంట్‌తో బ్రేక్ స్టేట్‌మెంట్ అవసరం లేదు. స్విచ్ బ్లాక్ లోపల బహుళ కేస్ విలువలను నిర్వచించే విధానం క్రింది ఉదాహరణలో చూపబడింది.
ప్యాకేజీ ప్రధాన//fmt ప్యాకేజీని దిగుమతి చేయండి
దిగుమతి 'fmt'
ఫంక్ ప్రధాన () {
ఉంది n int
//ప్రాంప్ట్ సందేశాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'నెల విలువను సంఖ్యలో నమోదు చేయండి:' )
//యూజర్ నుండి ఇన్‌పుట్ తీసుకోండి
fmt . స్కాన్ చేయండి ( & n )
//మాచింగ్ కేస్ విలువ ఆధారంగా సందేశాన్ని ముద్రించండి
మారండి n {
కేసు 1 , 2 , 3 , 4 :
fmt . Println ( 'వింటర్ సెమిస్టర్.' )
కేసు 5 , 6 , 7 , 8 :
fmt . Println ( 'వేసవి సెమిస్టర్.' )
కేసు 9 , 10 , పదకొండు , 12 :
fmt . Println ( 'పతనం సెమిస్టర్.' )
డిఫాల్ట్ :
fmt . Println ( 'నెల విలువ పరిధి వెలుపల ఉంది.' )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ యాదృచ్ఛిక సంఖ్య
యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి గోలాంగ్‌లో గణితం/ర్యాండ్ ప్యాకేజీ ఉపయోగించబడింది. నాలుగు రకాల యాదృచ్ఛిక సంఖ్యలను రూపొందించే విధానం క్రింది స్క్రిప్ట్‌లో చూపబడింది. దీర్ఘ పూర్ణాంక యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి rand.Int() ఫంక్షన్ ఉపయోగించబడుతుంది. rand.Intn(n) ఫంక్షన్ నిర్దిష్ట పరిధి యొక్క పూర్ణాంక యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి ఉపయోగించబడుతుంది మరియు అత్యధిక విలువ ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్ విలువగా పాస్ చేయబడుతుంది. 999 స్క్రిప్ట్‌లో ఆర్గ్యుమెంట్ విలువగా సెట్ చేయబడింది. rand.Float32() ఫంక్షన్ ఒక చిన్న పాక్షిక యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి ఉపయోగించబడుతుంది మరియు rand.Float64() ఫంక్షన్ సుదీర్ఘ పాక్షిక యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి ఉపయోగించబడుతుంది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//అవసరమైన మాడ్యూళ్లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'సమయం'
'గణితం/రాండ్'
)
ఫంక్ ప్రధాన () {
//యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి విత్తనాన్ని సెట్ చేయండి
రాండ్ . విత్తనం ( సమయం . ఇప్పుడు () . UnixNano ())
// ఉత్పత్తి చేయబడిన యాదృచ్ఛిక పూర్ణాంకాన్ని ముద్రించండి
fmt . Println ( 'యాదృచ్ఛిక పూర్ణాంకం విలువ:' , రాండ్ . Int ())
//999లోపు యాదృచ్ఛిక పూర్ణాంకాన్ని ముద్రించండి
fmt . Println ( 'పరిధితో యాదృచ్ఛిక పూర్ణాంకం విలువ:' , రాండ్ . Intn ( 999 ))
//యాదృచ్ఛిక 32 బిట్స్ ఫ్లోట్‌ను ప్రింట్ చేయండి
fmt . Println ( 'రాండమ్ 32 బిట్స్ ఫ్లోట్ విలువ:' , రాండ్ . ఫ్లోట్32 ())
//యాదృచ్ఛిక 64 బిట్స్ ఫ్లోట్‌ను ప్రింట్ చేయండి
fmt . Println ( 'రాండమ్ 64 బిట్స్ ఫ్లోట్ విలువ:' , రాండ్ . ఫ్లోట్64 ())
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ నిద్ర
సమయం.స్లీప్() ఫంక్షన్ నిర్దిష్ట కాలానికి స్క్రిప్ట్ అమలును పాజ్ చేయడానికి గోలాంగ్‌లో ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్ మూడు సంఖ్యల సగటును గణిస్తుంది మరియు స్క్రిప్ట్‌ను ముగించే ముందు 3 సెకన్లు వేచి ఉంటుంది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'సమయం'
)
ఫంక్ ప్రధాన () {
fmt . Println ( 'స్క్రిప్ట్‌ని అమలు చేయడం ప్రారంభించండి...' )
//మూడు వేరియబుల్స్‌ని నిర్వచించండి
a := 40
బి := 30
సి := 29
//వేరియబుల్స్‌ని ప్రింట్ చేయండి
fmt . ప్రింట్ఎఫ్ ( 'మూడు సంఖ్యలు: %d, %d, %d \n ' , a , బి , సి )
fmt . Println ( 'మూడు సంఖ్యల సగటును గణిస్తోంది...' )
సగటు := ( a + బి + సి ) / 3
//3 సెకన్లు ఆలస్యం
సమయం . నిద్రించు ( 3 * సమయం . రెండవ )
//ఫలితాలను ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'సగటు విలువ %d \n ' , సగటు )
fmt . Println ( 'ప్రోగ్రామ్ ముగించబడింది.' )
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోల్డెన్ టైమ్
ప్రస్తుత తేదీ మరియు సమయాన్ని చదవడానికి గోలాంగ్‌లో టైమ్ ప్యాకేజీ ఉపయోగించబడుతుంది. ఈ ప్యాకేజీ తేదీ మరియు సమయాన్ని వివిధ మార్గాల్లో చదవడానికి అనేక పద్ధతులు మరియు లక్షణాలను కలిగి ఉంది. తేదీ మరియు సమయాన్ని యాక్సెస్ చేయడానికి గోలాంగ్‌లో తేదీ మరియు సమయం, ‘సోమ జనవరి 2 15:04:05 -0700 MST 2006’ సూచన విలువగా ఉపయోగించబడుతుంది. సమయ ప్యాకేజీ యొక్క ఉపయోగాలు క్రింది ఉదాహరణలో చూపబడ్డాయి.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'సమయం'
)
ఫంక్ ప్రధాన () {
//ప్రస్తుత తేదీ మరియు సమయాన్ని చదవండి
నేడు := సమయం . ఇప్పుడు ()
//ప్రస్తుత తేదీని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'ఈరోజు %s. \n ' , నేడు . ఫార్మాట్ ( '02-జనవరి-2006' ))
//ప్రస్తుత తేదీ మరియు సమయాన్ని ముద్రించండి
fmt . ప్రింట్ఎఫ్ ( 'ప్రస్తుత తేదీ మరియు సమయం %s \n ' , నేడు . ఫార్మాట్ ( సమయం . RFC1123 ))
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ uuid
UUID లేదా యూనివర్సల్లీ యూనిక్ ఐడెంటిఫైయర్ గోలాంగ్ స్క్రిప్ట్ ద్వారా రూపొందించబడుతుంది. కంప్యూటర్ సిస్టమ్‌ను గుర్తించడానికి ఇది 128-బిట్ ప్రత్యేక విలువ. మీరు uuid నుండి డౌన్‌లోడ్ చేసుకోవాలి github.com/google/uuid కింది స్క్రిప్ట్‌ని అమలు చేయడానికి ముందు.
హోమ్ డైరెక్టరీకి వెళ్లి, గోలాంగ్ స్క్రిప్ట్ ద్వారా uuidని రూపొందించడానికి అవసరమైన ప్యాకేజీని డౌన్‌లోడ్ చేయడానికి క్రింది ఆదేశాలను అమలు చేయండి.
$ గో mod init uuid$ github.comని పొందండి / గూగుల్ / uuid
కింది స్క్రిప్ట్‌లో, ప్రత్యేక ఐడెంటిఫైయర్‌ని అందించే uuid.New() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మొదటి uuid రూపొందించబడింది. రెండవ uuid రెండు విలువలను అందించే uuid.NewUUID() ఫంక్షన్ ద్వారా రూపొందించబడింది. విలువ ప్రత్యేక ఐడెంటిఫైయర్‌ను కలిగి ఉంటుంది మరియు రెండవ విలువ అది ఉనికిలో ఉంటే దోష సందేశాన్ని కలిగి ఉంటుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'github.com/google/uuid'
)
ఫంక్ ప్రధాన () {
//కొత్త() ఫంక్షన్‌ని ఉపయోగించి ప్రత్యేక IDని రూపొందించండి
కొత్త ID := uuid . కొత్తది ()
fmt . ప్రింట్ఎఫ్ ( 'మొదటి UUID రూపొందించబడింది %s. \n ' , కొత్త ID )
//NewUUID() ఫంక్షన్‌ని ఉపయోగించి ప్రత్యేక IDని రూపొందించండి
కొత్త ID , తప్పు := uuid . కొత్తUUID ()
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
fmt . ప్రింట్ఎఫ్ ( 'ఉత్పత్తి చేయబడిన రెండవ UUID %s. \n ' , కొత్త ID )
} లేకపోతే {
fmt . Println ( తప్పు )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ రీడ్ ఫైల్
ది io/ioutil ఫైల్ యొక్క కంటెంట్‌ను చదవడానికి గోలాంగ్ ప్యాకేజీ ఉపయోగించబడుతుంది. ఈ ప్యాకేజీ యొక్క ReadFile() ఫంక్షన్ ఫైల్ యొక్క మొత్తం కంటెంట్‌ను చదువుతుంది. ఈ ఫంక్షన్ ఫైల్ ఉనికిలో ఉన్నట్లయితే ఫైల్ యొక్క పూర్తి కంటెంట్‌ను వేరియబుల్‌లోకి అందిస్తుంది, లేకపోతే దోష సందేశం తిరిగి వస్తుంది. ఇప్పటికే ఉన్న టెక్స్ట్ ఫైల్ యొక్క పూర్తి కంటెంట్‌ను చదివే విధానం క్రింది స్క్రిప్ట్‌లో చూపబడింది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'io/ioutil'
'fmt'
'లాగ్'
)
ఫంక్ ప్రధాన () {
//టెక్స్ట్ ఫైల్ చదవండి
వచనం , తప్పు := ioutil . రీడ్ ఫైల్ ( 'Languages.txt' )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
fmt . ప్రింట్ఎఫ్ ( 'ఫైల్ యొక్క కంటెంట్: \n \n ' )
fmt . Println ( స్ట్రింగ్ ( వచనం ))
} లేకపోతే {
లాగ్ . ఫటాల్ఫ్ ( 'ఫైల్ రీడ్ లోపం: %v' , తప్పు )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ ఫైల్‌ని లైన్ వారీగా చదివాడు
గోలాంగ్ యొక్క “బుఫియో” ప్యాకేజీని లైన్ ద్వారా ఫైల్ కంటెంట్‌ని చదవడానికి ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్‌లో, ఫైల్‌ని చదవడానికి ఆబ్జెక్ట్‌ని సృష్టించడానికి bufio.NewScanner() ఉపయోగించబడింది. తరువాత, ఫైల్ యొక్క ప్రతి పంక్తిని చదవడానికి మరియు ప్రింట్ చేయడానికి లూప్‌తో స్కాన్() ఫంక్షన్ ఉపయోగించబడుతుంది.
//ప్రధాన ప్యాకేజీని జోడించండిప్యాకేజీ ప్రధాన
//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'నువ్వు'
'బుఫియో'
)
ఫంక్ ప్రధాన () {
//చదవడానికి టెక్స్ట్ ఫైల్‌ను తెరవండి
ఎఫ్ హెచ్ , తప్పు := మీరు . తెరవండి ( 'Languages.txt' )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
//ఫైల్ కంటెంట్‌ను స్కాన్ చేయండి
చదవండి := బుఫియో . న్యూ స్కానర్ ( ఎఫ్ హెచ్ )
//ఫైల్‌ని లైన్ వారీగా చదవండి
కోసం చదవండి . స్కాన్ చేయండి () {
fmt . Println ( చదవండి . వచనం ())
}
} లేకపోతే {
fmt . Println ( తప్పు )
}
//ఫైల్‌ను మూసివేయండి
వాయిదా వేయండి ఎఫ్ హెచ్ . దగ్గరగా ()
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ ఫైల్‌కి వ్రాయండి
ది మీరు గోలాంగ్ యొక్క ప్యాకేజీని వ్రాయడం కోసం ఫైల్‌ని తెరవడానికి ఉపయోగించబడుతుంది రైట్ స్ట్రింగ్() ఫైల్‌లో కంటెంట్‌ను వ్రాయడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. మూడు పంక్తుల టెక్స్ట్ ఫైల్‌ను సృష్టించడం మరియు వ్రాయడం అనే పద్ధతిని ఉపయోగించడం మీరు ప్యాకేజీ.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'నువ్వు'
)
ఫంక్ ప్రధాన () {
//రాయడం కోసం ఫైల్‌ను తెరవండి
ఎఫ్ హెచ్ , తప్పు1 := మీరు . సృష్టించు ( 'items.txt' )
//ఫైల్ సృష్టి లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు1 == శూన్యం {
//ఫైల్‌లో వ్రాయండి
_ , తప్పు2 := ఎఫ్ హెచ్ . రైట్ స్ట్రింగ్ ( 'పెన్ \n పెన్సిల్ \n పాలకుడు \n ' )
//ఫైల్ రైటింగ్ లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు2 != శూన్యం {
fmt . Println ( 'ఫైల్ రైటింగ్ లోపం సంభవించింది. \n ' )
}
} లేకపోతే {
fmt . Println ( 'ఫైల్ సృష్టి లోపం సంభవించింది. \n ' )
}
//ఫైల్‌ను మూసివేయండి
వాయిదా వేయండి ఎఫ్ హెచ్ . దగ్గరగా ()
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. అంశాలు.txt ఫైల్ విజయవంతంగా సృష్టించబడిందని అవుట్‌పుట్ చూపుతుంది.
ఫైల్ ఉందో లేదో గోలాంగ్ తనిఖీ చేస్తుంది
ది మీరు ఫైల్ ఉనికిని తనిఖీ చేయడానికి గోలాంగ్ ప్యాకేజీని ఉపయోగించవచ్చు. కింది స్క్రిప్ట్‌లో, ఫైల్ పాత్ స్క్రిప్ట్ నుండి తీసుకోబడుతుంది. పాత్ ఉనికిలో లేకుంటే os.State() ఫంక్షన్ anని అందిస్తుంది os.ErrNotExist లోపం.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌ను దిగుమతి చేయండి
దిగుమతి (
'తప్పులు'
'fmt'
'నువ్వు'
)
ఫంక్ ప్రధాన () {
ఉంది ఫైల్‌పాత్ స్ట్రింగ్
fmt . ప్రింట్ఎఫ్ ( 'ఇప్పటికే ఉన్న ఫైల్ పేరును నమోదు చేయండి:' )
//యూజర్ నుండి ఫైల్ పాత్‌ను తీసుకోండి
fmt . స్కాన్ చేయండి ( & ఫైల్‌పాత్ )
//ఫైల్ పాత్‌ని తనిఖీ చేయండి
_ , లోపం := మీరు . గణాంకాలు ( ఫైల్‌పాత్ )
//os.Stat అవుట్‌పుట్‌ని తనిఖీ చేయండి
ఉంటే ! లోపాలు . ఉంది ( లోపం , మీరు . ErrNotExist ) {
fmt . Println ( 'ఫైల్ కనుగొనబడింది.' )
} లేకపోతే {
fmt . Println ( 'ఫైల్ కనుగొనబడలేదు.' )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలన్ csv
ది “ఎన్‌కోడింగ్/csv” CSV ఫైల్ యొక్క కంటెంట్‌ను చదవడానికి గోలాంగ్‌లో ప్యాకేజీ ఉపయోగించబడుతుంది. ది csv.NewReader() CSV ఫైల్‌ను చదవడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఈ ఉదాహరణ యొక్క స్క్రిప్ట్‌ను అమలు చేయడానికి ముందు CSV ఫైల్‌ను సృష్టించండి. ఇక్కడ, ది వినియోగదారులు.csv CSV ఫైల్‌ను చదివే విధానాన్ని చూపించడానికి ఫైల్ ఉపయోగించబడింది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'ఎన్‌కోడింగ్/csv'
'fmt'
'నువ్వు'
)
ఫంక్ ప్రధాన () {
//చదవడానికి CSV ఫైల్‌ను తెరవండి
ఎఫ్ హెచ్ , తప్పు := మీరు . తెరవండి ( 'customers.csv' )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
fmt . Println ( తప్పు )
} లేకపోతే {
//CSV ఫైల్‌ను చదవడానికి ఒక వస్తువును సృష్టించండి
స్కానర్ := csv . న్యూ రీడర్ ( ఎఫ్ హెచ్ )
//CSV ఫైల్ యొక్క అన్ని రికార్డులను చదవండి
రికార్డులు , _ := స్కానర్ . అన్నీ చదవండి ()
//CSV ఫైల్‌ని లైన్ వారీగా చదవండి
కోసం _ , ఆర్ := పరిధి రికార్డులు {
కోసం _ , సి := పరిధి ఆర్ {
fmt . ప్రింట్ఎఫ్ ( '%s,' , సి )
}
fmt . Println ()
}
}
//ఫైల్‌ను మూసివేయండి
వాయిదా వేయండి ఎఫ్ హెచ్ . దగ్గరగా ()
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ యమ్ల్
ది యమల్.మార్షల్() yaml డేటా యొక్క కంటెంట్‌ను చదవడానికి గోలాంగ్‌లో ఫంక్షన్ ఉపయోగించబడుతుంది. మీరు డౌన్‌లోడ్ చేసుకోవాలి యమల్ ఉపయోగించడానికి ప్యాకేజీ యమల్.మార్షల్() . హోమ్ డైరెక్టరీకి వెళ్లి డౌన్‌లోడ్ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి యమల్ ప్యాకేజీ.
$ వెళ్ళి పొందండి < a href = 'http://gopkg.in/yaml.v2' > gopkg.in / yaml.v2 a >కింది స్క్రిప్ట్‌లో, నాలుగు మూలకాల యొక్క స్ట్రక్చర్ వేరియబుల్ ప్రకటించబడింది, అది డేటాతో యామల్ ఆబ్జెక్ట్‌ను నిర్వచించడానికి తర్వాత ఉపయోగించబడింది. తరువాత, yaml.Marshal() ఫంక్షన్ yaml డేటాను యాక్సెస్ చేయడానికి ఉపయోగించబడింది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'gopkg.in/yaml.v2'
)
//4 మూలకాల నిర్మాణాన్ని ప్రకటించండి
రకం పుస్తకం నిర్మాణం {
శీర్షిక స్ట్రింగ్
రచయిత స్ట్రింగ్
ప్రచురణ స్ట్రింగ్
ధర స్ట్రింగ్
}
ఫంక్ ప్రధాన () {
//నిర్మాణం యొక్క వస్తువును సృష్టించండి
పుస్తకం1 := పుస్తకం {
శీర్షిక : 'లెర్నింగ్ గో' ,
రచయిత : 'జాన్ బోడ్నర్' ,
ప్రచురణ : 'ఓ'రెల్లీ' ,
ధర : '$39' ,
}
//స్ట్రక్ట్ ఆధారంగా yaml డేటాను చదవండి
y_డేటా , తప్పు := యమల్ . మార్షల్ ( &పుస్తకం1 )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
//యామల్ డేటాను ప్రింట్ చేయండి
fmt . Println ( స్ట్రింగ్ ( y_డేటా ))
} లేకపోతే {
fmt . ప్రింట్ఎఫ్ ( 'మార్షలింగ్‌లో లోపం. %v' , తప్పు )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ http అభ్యర్థన
ది నికర/http వెబ్‌సైట్‌కి http అభ్యర్థనలను పంపడానికి గోలాంగ్ ప్యాకేజీ ఉపయోగించబడుతుంది. అభ్యర్థనను పంపడానికి http.Get() ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది సైట్ నుండి ప్రతిస్పందనను లేదా దోష సందేశాన్ని అందిస్తుంది. వెబ్‌సైట్‌కి http అభ్యర్థనను పంపే విధానం, https://example.com క్రింది స్క్రిప్ట్‌లో చూపబడింది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'నెట్/http'
)
ఫంక్ ప్రధాన () {
//ఒక వెబ్‌సైట్‌కి GET అభ్యర్థనను పంపండి
res , తప్పు := http . పొందండి ( 'https://example.com' )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు == శూన్యం {
//వెబ్‌సైట్ పంపిన ప్రతిస్పందనను ప్రింట్ చేయండి
fmt . Println ( res )
} లేకపోతే {
//దోష సందేశాన్ని ముద్రించండి
fmt . Println ( తప్పు )
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ కమాండ్ లైన్ వాదనలు
స్క్రిప్ట్ అమలు సమయంలో ఆమోదించబడిన విలువలను కమాండ్-లైన్ ఆర్గ్యుమెంట్ విలువలు అంటారు. గోలాంగ్‌లో కమాండ్ లైన్ ఆర్గ్యుమెంట్ విలువలను చదవడానికి os ప్యాకేజీ ఉపయోగించబడుతుంది. ఆర్గ్యుమెంట్ విలువలు Args[] శ్రేణిలో నిల్వ చేయబడతాయి. ప్రతి పంక్తిలో స్క్రిప్ట్ పేరు లేకుండా ఆర్గ్యుమెంట్ విలువలను ప్రింట్ చేయడానికి స్క్రిప్ట్‌లో పరిధితో లూప్ ఉపయోగించబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేస్తుంది
దిగుమతి (
'fmt'
'నువ్వు'
)
ఫంక్ ప్రధాన () {
fmt . Println ( 'అన్ని ఆర్గ్యుమెంట్ విలువలు:' )
//అన్ని ఆర్గ్యుమెంట్ విలువలను స్క్రిప్ట్ పేరుతో ముద్రించండి
fmt . Println ( మీరు . ఆర్గ్స్ )
fmt . Println ( 'వాదన విలువలు:' )
//స్క్రిప్ట్ పేరు లేకుండా అన్ని ఆర్గ్యుమెంట్ విలువలను ముద్రించండి
కోసం లో , _ := పరిధి మీరు . ఆర్గ్స్ {
ఉంటే లో == 0 {
కొనసాగుతుంది
}
fmt . Println ( మీరు . ఆర్గ్స్ [ లో ])
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
గోలాంగ్ లోపం నిర్వహణ
గోలాంగ్‌కి ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల వలె ట్రై-క్యాచ్ బ్లాక్ లేదు. అయితే, ది లోపాలు స్క్రిప్ట్‌లోని లోపాలను నిర్వహించడానికి గోలాంగ్‌లో ప్యాకేజీని ఉపయోగించవచ్చు. కింది స్క్రిప్ట్‌లో, వినియోగదారు నుండి పూర్ణాంకం సంఖ్య తీసుకోబడుతుంది. వినియోగదారు ప్రతికూల సంఖ్యను తీసుకుంటే, దోష సందేశం ముద్రించబడుతుంది. ది లోపాలు.కొత్త() లోపం సందేశాన్ని రూపొందించడానికి ఫంక్షన్ ఇక్కడ ఉపయోగించబడింది.
ప్యాకేజీ ప్రధాన//అవసరమైన ప్యాకేజీలను దిగుమతి చేయండి
దిగుమతి (
'తప్పులు'
'fmt'
)
ఫంక్ ప్రధాన () {
ఉంది n int
fmt . ప్రింట్ఎఫ్ ( 'సంఖ్యను నమోదు చేయండి:' )
fmt . స్కాన్ చేయండి ( & n )
//ఇన్‌పుట్ విలువను తనిఖీ చేయండి
ఫలితం , తప్పు := అనుకూల ( n )
//తప్పు కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
fmt . Println ( తప్పు )
} లేకపోతే {
fmt . ప్రింట్ఎఫ్ ( '%d %s \n ' , n , ఫలితం )
}
}
///పాజిటివ్ సంఖ్యను తనిఖీ చేయడానికి ఫంక్షన్‌ను నిర్వచించండి
ఫంక్ అనుకూల ( ఒకదానిపై int ) ( స్ట్రింగ్ , లోపం ) {
ఉంటే సంఖ్య < 0 {
తిరిగి '' , లోపాలు . కొత్తది ( 'పాజిటివ్ సంఖ్యను టైప్ చేయండి.' )
} లేకపోతే {
తిరిగి 'సంఖ్య సానుకూలంగా ఉంది.' , శూన్యం
}
}
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది.
ముగింపు:
గోలాంగ్ అనేది ఇప్పుడు పైథాన్ ప్రోగ్రామింగ్ లాంగ్వేజ్ వంటి అనేక ఉపయోగకరమైన ప్యాకేజీలను కలిగి ఉన్న ఒక ప్రసిద్ధ ప్రోగ్రామింగ్ భాష. ఏదైనా అనుభవం లేని వినియోగదారు గోలాంగ్‌ను మొదటి ప్రోగ్రామింగ్ భాషగా నేర్చుకోవచ్చు ఎందుకంటే ఇది నేర్చుకోవడం చాలా సులభం. ప్రాథమిక 30 గోలాంగ్ ఉదాహరణలు ఈ ట్యుటోరియల్‌లో మొదటి నుండి గోలాంగ్ నేర్చుకోవడానికి వివరించబడ్డాయి మరియు అభ్యాసకులు గోలాంగ్‌లో ప్రోగ్రామ్‌లను వ్రాయగలరు. ఈ భాష యొక్క ప్రధాన పరిమితులలో ఒకటి, ఇది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క లక్షణాలను కలిగి ఉండదు కానీ నిర్మాణాత్మక ప్రోగ్రామింగ్ నేర్చుకోవడం మంచిది.