როგორ შეიძლება დაწეროთ ზოგადი კოდი Go-ში?

Go-да жалпы කේත ලිවීමේ මූලික ක්‍රම කිහිපයක් ඇත:

• අතුරුමුහුණත් (Interfaces): මෙය ඔබට ක්‍රමලේඛයන් ලිවිය හැකිවෙයි, ඒවා විවිධ වර්ග සමඟ වැඩ කිරීමට හැකි වන අතර, නියමිත ක්‍රම මාලාවකට අදාළ වේ.

  // Reader අතුරුමුහුණත නිර්වචනය
  type Reader interface {
      Read(p []byte) (n int, err error)
  }
  
  // Reader ක්‍රමලේඛය අනුගමනය කරන ඕනෑම වර්ගයක් සමඟ වැඩ කරන ක්‍රමලේඛය
  func ProcessData(r Reader) error {
      // Reader-ගෙන් දත්ත කියවීම
      return nil
  }
  

• හිස් අතුරුමුහුණත් (interface{}): සාමාන්‍ය වර්ගයක්, ඕනෑම අගයක් නියෝජනය කළ හැකිය. භාවිතයට පෙර වර්ගය පරිවර්තනය කළ යුතුය.

  func PrintAnything(v interface{}) {
      // වර්ගය පරීක්ෂා කිරීම සහ පරිවර්තනය
      if s, ok := v.(string); ok {
          fmt.Println("මෙය පේළිය:", s)
      } else if i, ok := v.(int); ok {
          fmt.Println("මෙය සම්පූර්ණ සංඛ්‍යාව:", i)
      }
  }
  

• ජෙනරික (Generics) / වර්ග පරාමිතීන් (type parameters): මෙය ක්‍රමලේඛයන් සහ වර්ග ලිවිය හැකිවෙයි, ඒවා විවිධ වර්ග සමඟ වැඩ කිරීමට හැකි වන අතර, නිවේදනයේදී සඳහන් වේ. Go 1.18 සමඟ එකතු කරන ලදි.

  // T වර්ගයේ කොටස් සමඟ වැඩ කරන ක්‍රමලේඛය
  func PrintSlice[T any](s []T) {
      for _, v := range s {
          fmt.Println(v)
      }
  }
  
  // T1 සහ T2 වර්ග පරාමිතීන් සමඟ පොදු Pair වර්ගය
  type Pair[T1, T2 any] struct {
      First T1
      Second T2
  }
  

• ප්‍රතිපල (reflect): වර්ග සහ අගයන් පරීක්ෂා කිරීමට සහ අන්තර්ක්‍රියාවන් කළ හැකිවෙයි, ක්‍රියාත්මක වේලාවේ. සාමාන්‍යයෙන් සංකීර්ණ දෘශ්‍යයන් සඳහා භාවිතා වේ, නමුත් අඩු කාර්යක්ෂම හා ආරක්ෂිත විය හැක.

  import "reflect"
  
  func GetTypeName(v interface{}) string {
      return reflect.TypeOf(v).Name()
  }
  

තෝරාගැනීම විශේෂිත කාර්යය සහ නියමිත මට්ටම මත පදනම්ව වේ. ජෙනරිකස් නවීන Go-හි පොදු අල්ගොරිතම් සහ දත්ත ව්‍යුහ නිර්මාණය සඳහා හොඳම ක්‍රම වේ. අතුරුමුහුණත් මූලික මැකනිස්මක් වන අතර, බහුමාර්ගීකරණය සහ හැසිරවීම නිර්වචනය කිරීම සඳහා භාවිතා වේ. හිස් අතුරුමුහුණත් සහ ප්‍රතිපල භාවිතා වේ විශේෂ අවස්ථා සඳහා.