ஜெனரிக்ஸ் (Go 1.18+)

Go 1.18 (மார்ச் 2022) முதல், வகை அளவுருக்கள் உள்ளன: செயல்பாடுகள் மற்றும் வகைகளை வகைகளின் அடிப்படையில் அளவுருவாக மாற்றலாம். அவை உங்களை Map, Filter, Set[T], LinkedList[T] ஆகியவற்றை நகல் குறியீடு இல்லாமல் மற்றும் interface{} + இயக்க நேர வகை வலியுறுத்தல்கள் இல்லாமல் எழுத அனுமதிக்கின்றன.

பொதுவான செயல்பாடு: தொடரியல்

func Map[T, U any](s []T, f func(T) U) []U {
    out := make([]U, len(s))
    for i, v := range s {
        out[i] = f(v)
    }
    return out
}

doubled := Map([]int{1, 2, 3}, func(n int) int { return n * 2 })
// doubled is []int{2, 4, 6}

மூன்று புதிய கூறுகள்:

• [T, U any] பெயருக்குப் பின்: வகை அளவுருக்களை அவற்றின் கட்டுப்பாடுகளுடன் அறிவிக்கிறது.
• any = எந்த வகையையும் ஏற்கும் கட்டுப்பாடு (கோ 1.18 முதல் interface{} இன் மாற்றுப்பெயர்).
• ** அனுமானம்**: Map([]int{...}, ...) ஐ அழைக்கும் நீங்கள் Map[int, int](...) என்று எழுத வேண்டியதில்லை: தொகுப்பி T=int, U=int ஐ ஊகிக்கிறது.

சில நேரங்களில் அனுமானம் போதுமானதாக இருக்காது (எ.கா., T வாதங்கள் இல்லாத கட்டமைப்பாளர்கள்) மற்றும் வெளிப்படையான உடனடி தேவை: New[*Server]().

உள்ளமைக்கப்பட்ட கட்டுப்பாடுகள்

comparable சமத்துவத்தை அனுமதிக்கிறது ஆனால் இல்லை < அல்லது >.

func Index[T comparable](s []T, x T) int {
    for i, v := range s {
        if v == x { return i }
    }
    return -1
}

</>க்கு உங்களுக்கு தனிப்பயன் கட்டுப்பாடு தேவை.

தனிப்பயன் கட்டுப்பாடு: வகை தொழிற்சங்கங்கள்

கட்டுப்பாடு என்பது "வகை உறுப்பு" உட்பிரிவுகளைக் கொண்ட இடைமுகம்:

type Ordered interface {
    ~int | ~int64 | ~float64 | ~string
}

func Min[T Ordered](a, b T) T {
    if a < b { return a }
    return b
}

• | = யூனியன்: பட்டியலிடப்பட்ட வகைகளில் ஏதேனும் ஒன்றை ஏற்றுக்கொள்கிறது.
• ~int = "int அல்லது type X int என வரையறுக்கப்பட்ட எந்த வகையும்" (அதே அடிப்படை வகையுடன்). ~ இல்லாமல், சரியான int மட்டுமே.

ஒரு தடையானது ** முறைகள் மற்றும் வகை கூறுகளை கலக்கலாம்**:

type Stringable interface {
    ~string
    Len() int
}

பொதுவான வகைகள்

செயல்பாடுகள் மட்டுமல்ல: கட்டமைப்புகள் மற்றும் இடைமுகங்கள் வகை அளவுருக்களையும் கொண்டிருக்கலாம்.

type Set[T comparable] struct {
    m map[T]struct{}
}

func NewSet[T comparable]() *Set[T] {
    return &Set[T]{m: make(map[T]struct{})}
}

func (s *Set[T]) Add(v T) { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool { _, ok := s.m[v]; return ok }

s := NewSet[string]()
s.Add("ada")

முறைகள் வகைக்கு அப்பால் வகை அளவுருக்களை சேர்க்க முடியாது: func (s *Set[T]) MapTo[U any](...) தொகுக்கவில்லை (வேண்டுமென்றே வடிவமைப்பு வரம்பு).

ஜெனரிக்ஸை எப்போது பயன்படுத்த வேண்டும்

ஆம் எப்போது:

• தர்க்கம் உண்மையாகவே பல வகைகளுக்கு ஒரே மாதிரி (சேகரிப்புகள், அல்காரிதம்கள், Map/Filter/Reduce போன்ற உதவியாளர்கள்).
• மாற்று குறியீடு நகல் அல்லது interface{} + வகை வலியுறுத்தல்களைப் பயன்படுத்துதல் (வகை பாதுகாப்பை இழக்கிறது).

இல்லை எப்போது:

• ஒன்று அல்லது இரண்டு முறைகளைக் கொண்ட இடைமுகம் போதுமானது மற்றும் படிக்கக்கூடியது (io.Reader, fmt.Stringer).
• நீங்கள் "உங்களால் முடியும்": ஒரு ஒற்றை பயன்பாட்டு வழக்கு → அதன் உறுதியான பதிப்பை உருவாக்கவும்.

பயிற்சிகள்

func Index[T ???](s []T, x T) int { ... }