Go-ல் செயல்பாடுகள் மற்றும் பல மீட்டெடுக்கும் மதிப்புகள் எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

Go செயல்பாடுகள் `func` உடன் அறிவிக்கப்படுகின்றன, மேலும் ஒரு தனிச்சிறப்பு `**பல மீட்டெடுக்கும் மதிப்புகள்** — ஒரு செயல்பாடு பல மதிப்புகளை ஒரே நேரத்தில் மீட்டெடுக்கலாம். இது பரவலாகப் பயன்படுத்தப்படுகிறது, குறிப்பாக `(result, error)` idiom-க்கு, இது Go-வின் பிழை கையாளுதல் முறையை வரையறுக்கிறது.

## அடிப்படை செயல்பாடு

```go
func add(a int, b int) int {     // params with types, then the return type
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// shorthand for same-typed params: func add(a, b int) int
```

## பல மீட்டெடுக்கும் மதிப்புகள் — வரையறுக்கும் பண்பு

```go
func divide(a, b int) (int, error) {     // returns BOTH a result AND an error
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil    // nil error = success
}

// callers handle both — the ubiquitous Go error pattern
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)       // handle the error
}
fmt.Println(result)
```

`(value, error)` ஐ மீட்டெடுப்பது Go-வில் பிழை கையாளுதலுக்கான IDIOM ஆகும் — விதிவிலக்குகளுக்குப் பதிலாக, செயல்பாடுகள் பிழைகளை மதிப்புகளாக மீட்டெடுக்கின்றன, அவை அழைப்பாளர்கள் வெளிப்படையாக சரிபார்க்க வேண்டும். இது பிழை கையாளுதலை தெரியக்கூடிய மற்றும் மெளனமாக புறக்கணிக்க முடியாத வகையாக ஆக்குகிறது.

## comma-ok முறை

```go
// many built-ins return (value, ok) — a boolean for "did it work?"
value, ok := myMap["key"]   // ok = false if the key is missing
if ok { ... }

v, ok := someInterface.(string)   // type assertion with ok
```

## பெயரிடப்பட்ட மீட்டெடுக்கும் மதிப்புகள்

```go
func split(sum int) (x, y int) {   // named returns
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — returns the named values
}
```

## Variadic செயல்பாடுகள்

```go
func sum(nums ...int) int {     // accepts any number of ints
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)          // 6
sum(nums...)          // spread a slice into args
```

## செயல்பாடுகள் முதல்-வகுப்பு

```go
var op func(int, int) int = add   // assign functions to variables
func apply(fn func(int) int, x int) int { return fn(x) }  // pass as arguments
```

## ஏன் முக்கியமாக இருக்கிறது

Go செயல்பாடுகள் மையமாக இருக்கின்றன, மற்றும் **பல மீட்டெடுக்கும் மதிப்புகள்** மொழியின் வரையறுக்கும் பண்புகளில் ஒன்று — இவை `(result, error)` idiom-ஐ செயல்படுத்துகின்றன, இது Go-வின் பிழை கையாளுதல் முறையாகும் (விதிவிலக்குகளுக்குப் பதிலாக வெளிப்படையான பிழை-எனக் கூறப்படும் மூல்य சரிபார்ப்பு).

இந்த முறை, ஏறக்குறைய ஒவ்வொரு Go நிரலிலும் பயன்படுத்தப்படுகிறது, பிழை கையாளுதலை தெரியக்கூடிய மற்றும் நோக்கமுள்ள வகையாக ஆக்குகிறது.

சம்பந்தப்பட்ட comma-ok idiom (`value, ok :=`) எல்லா இடங்களிலும் தோன்றுகிறது (map அணுகல், type assertions, channel receives).

பல மீட்டெடுக்கும் மதிப்புகள், பிழை முறை, பெயரிடப்பட்ட மீட்டெடுக்கும் மதிப்புகள், variadic செயல்பாடுகள் மற்றும் முதல்-வகுப்பு செயல்பாடுகளைப் புரிந்துகொள்வது idiomatik Go ஐ படிக்கவும் எழுதவும் அவசியம் — மற்றும் பிழை-எனக் கூறப்படும் மூல்য தத்துவம் Go மற்றும் விதிவிலக்கு-அடிப்படை மொழிகளுக்கு இடையேயான மிக முக்கியமான கருத்துச் செயல் வேறுபாடுகளில் ஒன்றாகும்.