В чем разница между объявлением типа и определением типа в Golang?

Question

Объявление типа:

type A = string

Определение типа:

type A string

В чем разница между ними? Я не могу понять из spe c

Answer 1

Форма type A = string создает псевдоним между двумя, они не могут быть расширены на этом этапе. Какую цель это решает? Ну, для golang они помогают в некоторых вещах, таких как рефакторинг и исправление кодовой базы, и здесь есть отличная статья: https://talks.golang.org/2016/refactor.article.

Определение типа позволяет вам расширить тип с помощью некоторого дополнительного поведения, если вам это требуется, обычно это тот, который наиболее полезен в качестве разработчика, когда вы хотите создавать пользовательские типы данных из базовых c типов данных.

Answer 2

Для ясности в терминах, это оба объявления типа .

type A = string

Это называется объявлением псевдонима. Т.е. вы создаете псевдоним для типа. По сути, нет никакой разницы между типом и псевдонимом. Вы можете определить методы для псевдонима, и они будут доступны для начальных экземпляров типов. Пример :

type A struct {}

type B = A

func (B) print() {
    fmt.Println("B")
}

func main() {
    a := A{}
    b := B{}

    a.print()  // OUTPUT: B
    b.print()  // OUTPUT: B
}

Хотя, в вашем конкретном примере type A = string вы не можете определить методы для него, потому что строка имеет нелокальный тип (было предложение чтобы добавить возможность создавать методы для нелокальных типов, но он был отклонен).

Ваш второй случай type A string - это определение типа. По сути, это создание нового типа, который имеет все поля исходного типа, но не его методы. Пример :

type A struct {}

func (A) print() {
    fmt.Println("A")
}

type B A

func (B) print() {
    fmt.Println("B")
}

func main() {
    a := A{}
    b := B{}

    a.print()  // OUTPUT: A
    b.print()  // OUTPUT: B
}

Answer 3

type A = string создает псевдоним для string. Всякий раз, когда вы используете A в своем коде, он работает так же, как string. Так, например, вы не можете определить методы для него.

type A string определяет новый тип, который имеет то же представление, что и string. Вы можете конвертировать между A и string при нулевой стоимости (потому что они одинаковы), но вы можете определить методы для вашего нового типа, и рефлексия узнает о типе A.

Например (на детской площадке )

package main

import (
    "fmt"
)

type A = string
type B string

func main() {
    var a A = "hello"
    var b B = "hello"
    fmt.Printf("a is %T\nb is %T\n", a, b)
}

Вывод:

a is string
b is main.B