2.5 جاسازی تایپ (type embedding)

2.5 جاسازی تایپ (type embedding)

در زبان گو برای ساختار و اینترفیس امکان جاسازی تایپ وجود دارد. یعنی شما می‌توانید یک ساختار یا یک اینترفیس را داخل ساختار دیگر جاسازی کنید و یا داخل اینترفیس یک اینترفیس دیگر را جاسازی کنید.


type animal interface {
    breathe()
    walk()
}

type human interface {
    animal
    speak()
}

type base struct {
    num int
}

type container struct {
	human
    base
    str string
}

در بالا ما اینترفیس animal را در اینترفیس human جاسازی کردیم و در ادامه داخل ساختار container اینترفیس human و ساختار base را جاسازی کردیم.

با اینکار ما به متدهای اینترفیس human و animal و همچنین به فیلدهای ساختار base دسترسی داریم و می توانیم از متدها و فیلدهای جاسازی با استفاده از ساختار container استفاده کنیم.

توجه کنید شما نمی‌توانید یک ساختار را داخل اینترفیس جاسازی کنید.

2.5.1 جاسازی ساختار #

شما می‌توانید هر چندتا ساختاری که دارید داخل یک ساختاری جاسازی و به هرکدام از فیلدهای ساختارهای جاسازی شده دسترسی دارید.

به مثال زیر توجه کنید :

package main

import "fmt"

type base struct {
    num int
}

func (b base) describe() string {
    return fmt.Sprintf("base with num=%v", b.num)
}

type container struct {
    base
    str string
}

func main() {

    co := container{
        base: base{
            num: 1,
        },
        str: "some name",
    }

    fmt.Printf("co={num: %v, str: %v}\n", co.num, co.str)

    fmt.Println("also num:", co.base.num)

    fmt.Println("describe:", co.describe())

    type describer interface {
        describe() string
    }

    var d describer = co
    fmt.Println("describer:", d.describe())
}

2.5.1.1 جاسازی اینترفیس در ساختار #

همانطور که گفتیم یک اینترفیس می‌‌تواند داخل یک ساختار جاسازی شود و همه متدهای اینترفیس به واسطه ساختار مورد قابل دسترس است و می‌توانید هر یک از متدها را استفاده کنید.

package main

import "fmt"

type animal interface {
    breathe()
    walk()
}

type dog struct {
    age int
}

func (d dog) breathe() {
    fmt.Println("Dog breathes")
}

func (d dog) walk() {
    fmt.Println("Dog walk")
}

type pet1 struct {
    a    animal
    name string
}

type pet2 struct {
    animal
    name string
}

func main() {
    d := dog{age: 5}
    p1 := pet1{name: "Milo", a: d}

    fmt.Println(p1.name)
    // p1.breathe()
    // p1.walk()
    p1.a.breathe()
    p1.a.walk()

    p2 := pet2{name: "Oscar", animal: d}
    fmt.Println(p1.name)
    p2.breathe()
    p2.walk()
    p1.a.breathe()
    p1.a.walk()
}

2.5.2 جاسازی اینترفیس #

شما همانند ساختارها می‌توانید اینترفیس‌ها را جاسازی کنید و فقط کافیه اینترفیس‌ها را داخل دیگر اینترفیس‌ها جاسازی کنید تا متدهای اینترفیس‌های جاسازی شده دسترسی داشته باشید.

package main

import "fmt"

type animal interface {
	breathe()
	walk()
}

type human interface {
	animal
	speak()
}

type employee struct {
	name string
}

func (e employee) breathe() {
	fmt.Println("Employee breathes")
}

func (e employee) walk() {
	fmt.Println("Employee walk")
}

func (e employee) speak() {
	fmt.Println("Employee speaks")
}

func main() {
	var h human

	h = employee{name: "John"}
	h.breathe()
	h.walk()
	h.speak()
}

یکی دیگه از مثال‌هایی که می‌توانیم بزنیم پکیج io اینترفیس ReadWriter هست که ۲ تا اینترفیس Reader و Writer داخل این اینترفیس جاسازی شده است.