Ի՞նչ է տափակագեղձի տիպավորումը։

Duck typing (քչկչալու տիպավորում) — դա դինամիկ տիպավորման ոճ է, որի ժամանակ օբյեկտի կամ փոփոխականի տիպը որոշվում է ոչ թե նրա բացահայտ ժառանգության կամ ինտերֆեյսի իրականացման հիման վրա, այլ նրա որոշ մեթոդների կամ հատկությունների առկայության հիման վրա։ Եթե օբյեկտը "քչկչում է ինչպես խոզուկ և քչքչում է ինչպես խոզուկ", ապա այն համարվում է խոզուկ։

Go-ում duck typing-ը իրականացնում է անհայտ ինտերֆեյսների միջոցով։ Կառուցվածքը կամ ցանկացած այլ տվյալների տիպ պետք չէ բացահայտ նշել, որ այն իրականացնում է որոշակի ինտերֆեյս։ Պարզապես բավարար է, որ տվյալների տիպը իրականացնում է ինտերֆեյսում սահմանված բոլոր մեթոդները։

Օրինակ՝

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("Մյաու!")
}

// Ֆունկցիան ընդունում է argument տիպի 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։

Առավելություններ՝ duck typing-ի՝ Go-ում.

• Լկտություն: Հեշտացնում է մոդուլային և ընդլայնվող համակարգերի ստեղծումը։
• Անհրաժեշտ չէ խիստ ժառանգականություն: Դիզայնի ժամանակ անհրաժեշտ չէ ժառանգել կամ բացահայտորեն իրականացնել ինտերֆեյսներ։
• Հեշտ օգտագործում՝ առկա տիպերի: Յուրաքանչյուր տիպ, որը ունի անհրաժեշտ մեթոդները, կարող է բավարարել ինտերֆեյսին, նույնիսկ եթե այն մշակվել է առանց դրա մասին մտածելու։