რა არის პატკის ტიპიზაცია?

Duck typing — ეს არის დინამიური ტიპიზაციის სტილი, სადაც ობიექტის ან ცვლადის ტიპი განსაზღვრულია არა მისი მემკვიდრეობის ან ინტერფეისის რეალიზაციის საფუძველზე, არამედ მისი მეთოდების ან თვისებების არსებობით. თუ ობიექტი "მოძრაობს როგორც დათვი და ყვირის როგორც დათვი", მაშინ მას დათვი მიიჩნევა.

Go-ში დაკის ტიპიზაცია განახორციელებულია მიუთითო ინტერფეისებით. სტრუქტურა ან სხვა მონაცემთა ტიპი არ უნდა მიუთითოს პირდაპირ, რომ ის რეალიზებს გარკვეულ ინტერფეისს. საკმარისია, რომ მონაცემთა ტიპმა განახორციელოს ინტერფეისში განსაზღვრული ყველა მეთოდი.

მაგალითი:

package main

import "fmt"

// განსაზღვრეთ Speaker ინტერფეისი
type Speaker interface {
	Speak()
}

// განსაზღვრეთ Dog სტრუქტურა
type Dog struct{}

// Dog რეალიზებს Speak() მეთოდს
func (d Dog) Speak() {
	fmt.Println("გავ!")
}

// განსაზღვრეთ Cat სტრუქტურა
type Cat struct{}

// Cat რეალიზებს Speak() მეთოდს
func (c Cat) Speak() {
	fmt.Println("მია!")
}

// ფუნქცია, რომელიც იღებს Speaker ტიპის არგუმენტს
func MakeItSpeak(s Speaker) {
	s.Speak()
}

func main() {
	d := Dog{}
	c := Cat{}

	// ორივე ობიექტი, Dog და Cat, შეიძლება გადაეცეს MakeItSpeak-ს,
	// რადგან ორივე არადამკვიდრებლად რეალიზებს Speaker-ს.
	MakeItSpeak(d)
	MakeItSpeak(c)
}

ამ მაგალითში Dog და Cat პირდაპირ არ მიუთითებენ, რომ ისინი რეალიზებენ Speaker-ს. თუმცა, რადგან ორივეს აქვს Speak() მეთოდი, რომელიც შეესაბამება Speaker ინტერფეისის სიგნატურას, ისინი შეიძლება გამოყენებულ იქნას იქ, სადაც საჭიროია Speaker ტიპი.

Go-ში დაკის ტიპიზაციის უპირატესობები:

• გლუვობა: ადვილია მოდულური და გაფართოებადი სისტემების შექმნა.
• მკაცრი იერარქიის გარეშე: მემკვიდრეობა ან ინტერფეისების პირდაპირი რეალიზაცია საჭირო არ არის.
• არსებული ტიპების მარტივი გამოყენება: ნებისმიერი ტიპი, რომელსაც აქვს საჭირო მეთოდები, შეიძლება შეესაბამებოდეს ინტერფეისს, მიუხედავად იმისა, რომ ის არ იყო ამისთვის განკუთვნილი.