தொகுதி பாடங்கள் (2/5)
பல வருமானங்கள் மற்றும் பெயரிடப்பட்ட வருமானங்கள்
Go இல், ஒரு செயல்பாடு பல மதிப்புகளை வழங்கும். அது தான் பொறிமுறை
நீங்கள் ஏற்கனவே பார்த்த (value, error) வடிவத்தை செயல்படுத்துகிறது மற்றும் அது பரவுகிறது
முழு நிலையான நூலகம்.
பல வருமானங்கள்
காற்புள்ளியால் பிரிக்கப்பட்ட அடைப்புக்குறிகளுக்கு இடையே திரும்பும் வகைகள் செல்கின்றன:
func divmod(a, b int) (int, int) {
return a / b, a % b
}
q, r := divmod(17, 5) // q=3, r=2அவை பல பணிகளால் சிதைக்கப்படுகின்றன. அவற்றில் ஒன்றை நிராகரிக்க
மதிப்புகள் _:
_, r := divmod(17, 5) // solo il restoநியமன (T, error) பேட்டர்ன்
கிட்டத்தட்ட அனைத்து stdlibகளும் இதைப் பின்பற்றுகின்றன. error எப்போதும் கடைசி:
func read(path string) ([]byte, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("read %q: %w", path, err)
}
return data, nil
}பெயரிடப்பட்ட வருமானம்
திரும்பும் மதிப்புகளுக்கு நீங்கள் பெயரிடலாம்: அவை முன்கூட்டியே அறிவிக்கப்பட்ட மாறிகளாக மாறும்
பூஜ்ஜியத்திற்கு துவக்கப்பட்டது, மேலும் return எந்த வாதங்களும் இல்லாமல் அவற்றை ("நிர்வாணமாக) வழங்கும்
திரும்ப"):
func divmod(a, b int) (q, r int) {
q = a / b
r = a % b
return // naked: ritorna q, r
}பெயரிடப்பட்ட வருமானங்கள் ஆவணப்படுத்தல் உதவிக்குறிப்புகளிலும் தோன்றும், எனவே அவை பயனுள்ளதாக இருக்கும் சிக்கலான செயல்பாடுகளுக்கான இன்லைன் ஆவணங்கள் ஒரு வடிவமாக - மட்டும் அல்ல நிர்வாணமாக திரும்புவதற்கு.
இரண்டுக்கும் மேற்பட்ட வருமானம்?
(int, int, int, error) இலிருந்து எதுவும் உங்களைத் தடுக்காது, ஆனால் நீங்கள் தேவை என உணர்ந்தால்
நீங்கள் ஒரு கட்டமைப்பை திரும்பப் பெற வேண்டும் என்பதற்கான அறிகுறியாக இது எப்போதும் இருக்கும்:
type Result struct {
Sum int
Avg float64
Max int
}
func analyze(nums []int) (Result, error) { ... }முயற்சி செய்து பாருங்கள்
பங்கு மற்றும் மீதியை வழங்கும் divmod(a, b int) (int, int) ஐ வரையறுக்கவும்.
குறிப்பைக் காட்டு
அடைப்புக்குறிகளுக்கு இடையே திரும்பும் வகைகள்: `(int, int)`.
3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்
SafeDiv(a, b int) (int, error): b == 0 return என்றால் (0, errors. New('divisione per zero')), இல்லையெனில் (a/b, nil).
குறிப்பைக் காட்டு
எப்பொழுதும் கடைசி மதிப்பாக பிழை. பிழையில்: பூஜ்ஜிய மதிப்பு + பிழை.
3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்
பெயரிடப்பட்ட வருமானத்தைப் பயன்படுத்தி இந்த நிரல் எதை அச்சிடுகிறது?
func f() (a, b int) {
a = 1
b = 2
return
}
x, y := f()
fmt.Println(x, y)மறுபரிசீலனை
- அடைப்புக்குறிக்குள் பல மதிப்புகள்:
func f() (T1, T2, error). - மாநாடு:
errorஎப்போதும் கடைசி மதிப்பாக; பிழையில், பூஜ்ஜிய மதிப்பு + பிழை. - பெயரிடப்பட்ட வருமானங்கள் மாறிகளை முன்கூட்டியே அறிவிக்கின்றன மற்றும் நிர்வாண வருமானத்தை செயல்படுத்துகின்றன.
- மிகக் குறுகிய செயல்பாடுகளில் மட்டுமே நிர்வாணமாகத் திரும்புகிறது; அதையும் தாண்டி, வாசிப்புத்திறன் பாதிக்கப்படுகிறது.
- 2-3க்கும் அதிகமான வருமானம்? ஒருவேளை நீங்கள் ஒரு கட்டமைப்பை விரும்புகிறீர்கள்.