Типове и интерфейси

Въпрос за мъфин #1

Как увеличаваме броя елементи в един масив? Можем ли да сравняваме масиви с оператора "==" ?

Не може да променяме големината на масиви (само на slices)
Да, можем да сравняваме с ==

Въпрос за мъфин #2

arr := [6]float64{1, 2, 3, 4, 5, 6}
x := arr[1:]
y := append(x, 4)

Какви типове имат arr, x, y?
Какво ще върнат len(x), cap(x), len(y), cap(y)?

[6]float64
[]float64
[]float64
5
5
6
10

Въпрос за мъфин #3

Кои от следните типове са допустими ключове на map?

string
[5]int
[]int
struct{int}
*[]int

Въпрос за мъфин #3

Отговор:

Всички без []int
...да, *[]int допустим ключ, макар и не много полезен:

package main

import (
	"fmt"
)

func main() {
    slice := []int{1, 2, 3}
    fmt.Printf("%+v\n", map[*[]int]int{&slice: 5})
}

Въпрос за мъфин #4

Каква е разликата между new() и make(), кога се ползва едното и кога другото и какво връщат?

new само заделя памет и я нулира, за разлика от make, което инициализира обекта
new ползваме за наши типове (структури), а make за вградени типове като slices и maps
new връща указател, make връща стойност

Въпрос за мъфин #5

Как инициализираме thread-safe slice или map?

Няма такова животно
Трябва сами да се погрижим за thread-safe достъп до тях

Собствени типове

От всеки тип в езика можем да създаваме наши типове
Не се различават по нищо от вградените

type integer int
type float float64
type chars string

Не особено полезно, на пръв поглед
Но те могат и повече

Нека разгледаме функцията Abs

func Abs(i integer) integer {
    switch {
    case i < 0:
        return -i
    case i == 0:
        return 0
    default:
        return i
    }
}

var number integer = -42
positiveInteger := Abs(number)

Така се дефинира обикновена функция Abs, която се извиква като ѝ се подаде integer като аргумент
Това не е "обектно-ориентираният" начин да се направи подобно нещо

"Обектно-ориентираният" начин да се направи подобно нещо

func (i integer) Abs() integer {
    switch {
    case i < 0:
        return -i
    case i == 0:
        return 0
    default:
        return i
    }
}

var number integer = -42
number.Abs()

Какво точно е метод?

Методите се изпълняват върху конкретен тип
Той се нарича receiver
Методите могат да се дефинират само върху типове, дефинирани в същия пакет
Като следствие от горното правило, методите имат достъп до private полетата в типа
На практика, дефинират държанието на типа

Що е то receiver-а?

Няма фиксирана ключова дума за това.
Има просто конвенция (първата/ите букви от името на типа)
Той може да бъде по стойност, както и указател

По стойност

Работи се върху копие на обекта
Това може да е скъпа операция за големи обекти

Като указател

Работи се върху копие на указателя към обект
Всяка промяна в метода се отразява на оригиналния обект

Няма различен синтаксис за използването на двата вида receiver-и.

Пример

package main

import "fmt"

type integer int

func (i integer) Abs() integer {
    switch {
    case i < 0:
        return -i
    case i == 0:
        return 0
    default:
        return i
    }
}

func (i *integer) Increment() {
    *i++
}

func main() {
    var number integer
    number = -42

    number.Increment()
    fmt.Println(number.Abs())
}

nil обекти

Извикването на методи работи дори с nil pointers към обекти:

package main

import "fmt"

type integer int

func (i *integer) Increment() {
    fmt.Println("Incrementing...")
    *i++
}

func main() {
    var number *integer
    number.Increment()
    fmt.Println(number)
}

Внимавайте с тях :)

struct

Същите неща могат да се правят и върху композитни типове
Полета и методи с малка буква са private
Нека си дефинираме типове за триъгълник и правоъгълник

type Rectangle struct {
    X, Y int
}

type Triangle struct {
    X, Y, Z int
}

Методи за тези типове

func (r *Rectangle) Area() float64 {
    return float64(r.X * r.Y)
}

func (r *Rectangle) Circumference() int {
    return 2 * (r.X + r.Y)
}

func (t *Triangle) Area() float64 {
    p := float64(t.Circumference() / 2)
    return math.Sqrt(p * (p - float64(t.X)) * (p - float64(t.Y)) * (p - float64(t.Z)))
}

func (t *Triangle) Circumference() int {
    return t.X + t.Y + t.Z
}

"Завързани" методи

package main

import "fmt"

type greeter struct {
    Name string
}

func (g *greeter) SayHi(name string) {
    fmt.Printf("Hi, %s! I am %s (%p)\n", name, g.Name, g)
}

func main() {
    var p = &greeter{Name: "p"}
    pGreeter := p.SayHi

    fmt.Printf("Calling p.SayHi:\n")
    p.SayHi("Pesho")

    fmt.Printf("Calling pGreeter:\n")
    pGreeter("Pesho") // The same as p.SayHi("Pesho")

    unboundGreeter := (*greeter).SayHi
    fmt.Printf("Calling unboundGreeter:\n")
    unboundGreeter(p, "Gosho")

    unboundGreeter(&greeter{Name: "other"}, "Maria")
}

Интерфейси

Какво правим, ако искаме да имаме списък от геометрични фигури, на които ще търсим обиколка или лице?
Тези типове нямат общ "родител"
Няма нужда и да са в един пакет
Това в Go се постига с интерфейси
Интерфейсите са както съвкупност от методи, така и тип от езика
Общият интерфейс на двете фигури са методите Circumference() и Area()
Нашите фигури нямат представа, че такъв интерфейс съществува

Stringer

type Stringer interface {
    String() string
}

Това е интерфейс от стандартната библиотека, дефиниран в пакета fmt.

Ако имплементираме този интефейс за наш тип, може да променим начина, по който fmt.Printf() го принтира чрез %s.

package main

import (
	"fmt"
	"strconv"
)

type myint uint64

func (i myint) String() string {
    return "myint in binary is " + strconv.FormatUint(uint64(i), 2)
}

func main() {
    var i myint
    i = 5
    fmt.Printf("Value: %s\n", i)
}

Структура

type Binary uint64

По-подробно обяснение може да намерите тук: research.swtch.com/interfaces

Дефиниция на интерфейс

type Shape interface {
    Area() float64
    Circumference() int
}

Това е нов абстрактен тип, от който не можем да създаваме обекти, но можем да имаме променливи от него
Всеки тип, който има методите Circumference и Area със същата сигнатура, имплементира Shape
Двата типа Triangle и Rectangle имплицитно го имплементират
Променливите от тип интерфейс са първокласни обекти в Go

Пример

package main

import (
	"fmt"
	"math"
)

// start interface OMIT
type Shape interface {
	Area() float64
	Circumference() int
}

// end interface OMIT

// start types OMIT
type Rectangle struct {
	X, Y int
}

type Triangle struct {
	X, Y, Z int
}

// end types OMIT

// start methods OMIT
func (r *Rectangle) Area() float64 {
	return float64(r.X * r.Y)
}

func (r *Rectangle) Circumference() int {
	return 2 * (r.X + r.Y)
}

func (t *Triangle) Area() float64 {
	p := float64(t.Circumference() / 2)
	return math.Sqrt(p * (p - float64(t.X)) * (p - float64(t.Y)) * (p - float64(t.Z)))
}

func (t *Triangle) Circumference() int {
	return t.X + t.Y + t.Z
}

// end methods OMIT

func sumOfCircumferences(shapes ...Shape) int {
    sum := 0
    for _, shape := range shapes {
        sum += shape.Circumference()
    }
    return sum
}

func biggestArea(shapes ...Shape) (result float64) {
    for _, shape := range shapes {
        area := shape.Area()
        if area > result {
            result = area
        }
    }
    return result
}

func main() {
    rect := &Rectangle{X: 12, Y: 64}
    tr := &Triangle{X: 12, Y: 64, Z: 50}
    fmt.Println(sumOfCircumferences(rect, tr))
    fmt.Println(biggestArea(rect, tr))
}

Вложени типове

Можем да накараме един тип да присвои държанието на друг тип
Това не е наследяване в смисъла на OOP
Влагащият тип не е от тип вложения (демек няма is-a релация)
Просто получава всички негови полета и методи
Има два начина да ги използваме

Композиция

Конструираме един тип, комбинирайки няколко прости други типa.

* Пример:
Искаме да си направим smartphone. Не откриваме топлата вода, а просто го наблъскваме с каквито джаджи се сетим.

type Smartphone struct {
    phone     BasicPhone
    camera    CameraModule
    wifi      WiFiModule
    screen    MultiTouchScreen
    battery   DamnHugeBattery
    gyroscope SmallGyroscope
    gps       GPSModule
    secret    CanOpener
}

Всеки един от тези типове отговаря за точно едно нещо и може да бъде използвано самостоятелно.

Квази-Наследяване

Вярваме, че знаете как работи то. Дори сме сигурни, че сте правили хора и студенти:

package main

import "fmt"

type Person struct {
    firstName, lastName string
}

func (p Person) Name() string {
    return p.firstName + " " + p.lastName
}

type Student struct {
    Person
    facultyNumber int16
}

func main() {
    s := Student{Person{"Иван", "Иванов"}, 123}
    fmt.Printf("We have a student with name %s and FN %d", s.Name(), s.facultyNumber)
}

Вложеният тип Person е анонимен, което присвоява всичките му методи и атрибути на базовия тип.

Множествено "наследяване"

Да, имате право на много анонимни вложени типа.

Не, това не е яко.

Да, не очакваме да го ползвате често.

Duck typing

Всеки обект имплементира празния интерфейс:

interface{}

Съответно на променлива от такъв тип може да присвоим всякаква стойност!

Но с нея не можем да правим абсолютно нищо :)

Това може да звучи безполезно, но не е, тъй като имаме...

Type Assertion

package main

import "fmt"

func main() {
    var value interface{}
    value = 20
    value = "asd"

    if str, ok := value.(string); ok {
        fmt.Printf("We have a %T: %v\n", str, str)
    } else {
        fmt.Println("Oops, not a string")
    }
}

В str ще имаме стойността на value, ако тя наистина е била от тип string.

Type Switch

package main

import "fmt"

type mystruct struct{ a, b int }

func (m mystruct) String() string {
    return fmt.Sprintf("mystruct(%d, %d) yo!", m.a, m.b)
}

func stringify(value interface{}) string {
    switch s := value.(type) {
    case string:
        return s
    case fmt.Stringer:
        return s.String()
    case int, uint:
        return fmt.Sprintf("%06d", s) // leftpad
    default:
        return "No clue, mate :)"
    }
}

func main() {
    fmt.Printf("%#v\n", stringify(mystruct{1, 2}))
}

Така може да правим различни неща въз основа на типа на променлива.

JSON

package main

import (
	"encoding/json"
	"fmt"
)

type Rectangle struct {
    X, Y int
}

func main() {
    var empty interface{}
    emptyRect := new(Rectangle)

    rect := &Rectangle{X: 12, Y: 64}

    marshalledRect, _ := json.Marshal(rect)
    fmt.Printf("%s\n", marshalledRect)

    json.Unmarshal(marshalledRect, emptyRect)
    fmt.Printf("%#v\n", emptyRect)

    json.Unmarshal(marshalledRect, &empty)
    fmt.Printf("%#v\n", empty)
}

JSON

type Marshaler interface {
    MarshalJSON() ([]byte, error)
}

type Unmarshaler interface {
    UnmarshalJSON([]byte) error
}

JSON

package main

import (
	"encoding/json"
	"fmt"
)

type Triangle struct {
	X, Y, Z int
}

func (t *Triangle) MarshalJSON() ([]byte, error) {
    return json.Marshal(struct {
        X, Y, Z int
        Shape   string
    }{
        X:     t.X,
        Y:     t.Y,
        Z:     t.Z,
        Shape: "Триъгълник",
    })
}

func main() {
    tr := &Triangle{X: 12, Y: 64, Z: 50}
    marshalledTr, _ := json.Marshal(tr)
    fmt.Printf("%s\n", marshalledTr)
}

Type Aliases

type integerAlias = int

Не създава нов тип, a псевдоним на вече съществуващ тип

package main

type integer int

func isPositive(a integer) bool {
    return a > 0
}

type integerAlias = int

func isPositive1(a integerAlias) bool {
    return a > 0
}

func main() {
    a := 5
    isPositive(a) // cannot use a (type int) as type integer in argument to isPositive
    isPositive1(a)
}

Типове и интерфейси

31.10.2018

Но преди това...

Въпрос за мъфин #1

Въпрос за мъфин #2

Въпрос за мъфин #3

Въпрос за мъфин #3

Въпрос за мъфин #4

Въпрос за мъфин #5