முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்
தொகுதி 3 · பாடம் 2 இன் 5பாடத்திட்டத்தில் 12/50~12 min
தொகுதி பாடங்கள் (2/5)

பல வருமானங்கள் மற்றும் பெயரிடப்பட்ட வருமானங்கள்

Go இல், ஒரு செயல்பாடு பல மதிப்புகளை வழங்கும். அது தான் பொறிமுறை நீங்கள் ஏற்கனவே பார்த்த (value, error) வடிவத்தை செயல்படுத்துகிறது மற்றும் அது பரவுகிறது முழு நிலையான நூலகம்.

பல வருமானங்கள்

காற்புள்ளியால் பிரிக்கப்பட்ட அடைப்புக்குறிகளுக்கு இடையே திரும்பும் வகைகள் செல்கின்றன:

Go
func divmod(a, b int) (int, int) {
    return a / b, a % b
}

q, r := divmod(17, 5) // q=3, r=2

அவை பல பணிகளால் சிதைக்கப்படுகின்றன. அவற்றில் ஒன்றை நிராகரிக்க மதிப்புகள் _:

Go
_, r := divmod(17, 5) // solo il resto

நியமன (T, error) பேட்டர்ன்

கிட்டத்தட்ட அனைத்து stdlibகளும் இதைப் பின்பற்றுகின்றன. error எப்போதும் கடைசி:

Go
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 எந்த வாதங்களும் இல்லாமல் அவற்றை ("நிர்வாணமாக) வழங்கும் திரும்ப"):

Go
func divmod(a, b int) (q, r int) {
    q = a / b
    r = a % b
    return       // naked: ritorna q, r
}

பெயரிடப்பட்ட வருமானங்கள் ஆவணப்படுத்தல் உதவிக்குறிப்புகளிலும் தோன்றும், எனவே அவை பயனுள்ளதாக இருக்கும் சிக்கலான செயல்பாடுகளுக்கான இன்லைன் ஆவணங்கள் ஒரு வடிவமாக - மட்டும் அல்ல நிர்வாணமாக திரும்புவதற்கு.

இரண்டுக்கும் மேற்பட்ட வருமானம்?

(int, int, int, error) இலிருந்து எதுவும் உங்களைத் தடுக்காது, ஆனால் நீங்கள் தேவை என உணர்ந்தால் நீங்கள் ஒரு கட்டமைப்பை திரும்பப் பெற வேண்டும் என்பதற்கான அறிகுறியாக இது எப்போதும் இருக்கும்:

Go
type Result struct {
    Sum  int
    Avg  float64
    Max  int
}

func analyze(nums []int) (Result, error) { ... }

முயற்சி செய்து பாருங்கள்

உடற்பயிற்சி#go.m3.l2.e1
முயற்சிகள்: 0ஏற்றுகிறது…

பங்கு மற்றும் மீதியை வழங்கும் divmod(a, b int) (int, int) ஐ வரையறுக்கவும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

அடைப்புக்குறிகளுக்கு இடையே திரும்பும் வகைகள்: `(int, int)`.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

உடற்பயிற்சி#go.m3.l2.e2
முயற்சிகள்: 0ஏற்றுகிறது…

SafeDiv(a, b int) (int, error): b == 0 return என்றால் (0, errors. New('divisione per zero')), இல்லையெனில் (a/b, nil).

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

எப்பொழுதும் கடைசி மதிப்பாக பிழை. பிழையில்: பூஜ்ஜிய மதிப்பு + பிழை.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

Quiz#go.m3.l2.e3
தயார்

பெயரிடப்பட்ட வருமானத்தைப் பயன்படுத்தி இந்த நிரல் எதை அச்சிடுகிறது?

Go
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க்கும் அதிகமான வருமானம்? ஒருவேளை நீங்கள் ஒரு கட்டமைப்பை விரும்புகிறீர்கள்.