07-type关键字、结构体 | 小T1an's Blog

07-type关键字、结构体

发布于 2026-08-20

07-type关键字、结构体

type关键字

type的写法不同，表示的含义也不同

类型别名（type A = B）
定义新类型（type A B），无等号

1、类型别名（type A = B）

go

type MyInt = int

MyInt 和 int 完全等价、互通，本质只是换个名字，二者可以互相赋值、无需转换。编译器层面没有新类型，只是别名

go

type MyInt = int
var i MyInt
fmt.Printf("%T", i) _// int_

2、定义新类型（type A B），无等号

基于已有的类型，自定义一个新的类型

go

type MyInt int

创建全新独立类型，和原类型不能直接互转。只能显式强制转换：MyInt(123)，可以给它绑定专属方法，原类型不会拥有

可以非常方便的在类型上添加方法

例如：我给MyInt新增一个toString方法

这里的func (mi MyInt) toString() string {}，叫方法接收者。等价于其他语言里的 this / self，调用这个方法的实例本身会复制一份传给 mi

interface（后面会细说）

结构体struct

1、定义和初始化

结构体和其他语言的class类一样

定义

初始化

方法1是省略写法，但是参数必须都写齐。方法2可以选择只初始化部分内容

示例：写法非常灵活

也可以对单个属性赋值，没有赋值的内容为零值

2、匿名结构体

3、结构体嵌套

这两种方式，在初始化的时候，都必须写一个完整的结构体，不能像：

如果像上面那样使用了name，而嵌套的Person也有name，就会把Person的name覆盖掉

4、给结构体绑定方法

语法：

使用：

4.1、值传递

语法中：(变量1 结构体名称)部分，是值传递。p.xx()方法中使用到的p.name、p.age其实本质类似xx(p)这样的参数调用，和函数参数一样，是值传递，那么p.name的改变，不会影响外部。

例如：

控制台打印的结果不同

4.2、引用传递

上面说的是值传递，要使用引用传递，需要用到指针。只需要在**(变量1 结构体名称)部分**，改为(变量1 *****结构体名称)部分，添加一个*号就行

当函数中需要改变外部的p值或者person值很大，数据较大的时候考虑使用指针方式（引用传递方式）

4.3、其他

下面无论是使用结构体定义变量还是指针结构体定义变量，都是可以使用到给结构体/结构体指针绑定的方法的

go

package main

import (
    "fmt"
    "strconv"
)

type MyInt int

func (mi MyInt) toString() string {
    _// 因为mi是MyInt类型，所以需要int()转为int类型_
_    _return strconv.Itoa(int(mi))
}

func main() {
    var count MyInt
    fmt.Printf("count = %s, 类型为 %T\n", count.toString(), count.toString()) _// count = 0, 类型为 string_
}

go

var a interface{} = "abc"
_// a.(type) 是语法糖，只能用在 switch 里，作用：提取接口变量的底层类型，依次匹配 case。_
switch a.(type) {
case string:
    _// a.(string)断言，直接转换成string类型_
_    _fmt.Println(a.(string)) _// abc_
}

go

func main() {
    // 方法1
    p1 := Person{"tian", 18, "上海", 1.80}
    fmt.Println(p1) _// {tian 18 上海 1.8}_
    fmt.Println(p1.name)
    // 方法2
    p2 := Person{
        name:    "John Smith",
        age:     20,
        address: "Jane Smith",
        height:  70.0,
    }
}

go

address := struct {
    province string
    city     string
    address  string
}{
    province: "上海市",
    city:     "上海市",
    address:  "浦东新区",
}
fmt.Println(address.province)

go

package main

import "fmt"

type Person struct {
    name    string
    age     int
    address string
    height  float32
}

type Student struct {
    _// 嵌套方式1_
_    _p Person
    _// 嵌套方式2：匿名嵌套_
_    _Person
    score float32
}

func main() {
    s := Student{
       _// 嵌套方式1初始化_
_       _Person{
          name: "tian",
       },
       _// 嵌套方式2初始化（匿名）_
_       _Person{
          name: "tian",
       },
       100,
    }
    fmt.Println(s.p.name)
    fmt.Println(s.name) _// 是从匿名嵌套方式中获取的_
}

go

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (p Person) Say(msg string) string {
    _// 通过p可以获取到结构体本身（类似class的this）_
_    _fmt.Printf("%s says %s\n", p.name, msg)
    return msg
}

func main() {
    var p Person = Person{
       name: "tian",
    }
    p.Say("Hello") _// tian says Hello_
}

go

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (p Person) Say(msg string) string {
    _// 通过p可以获取到结构体本身（类似class的this）_
_    _p.age = 18
    fmt.Println(p.age, "内部打印p.age")
    fmt.Printf("%s says %s\n", p.name, msg)
    return msg
}

func main() {
    var p Person = Person{
       name: "tian",
    }
    p.Say("Hello") _// tian says Hello_
_    _fmt.Println(p.age, "外部打印p.age")
}

go

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (p *Person) Say(msg string) string {
    p.age = 18
    fmt.Println(p.age, "内部打印p.age")
    return msg
}

func main() {
    var p Person = Person{
       name: "tian",
    }
    p.Say("Hello")
    fmt.Println(p.age, "外部打印p.age")
}

go

package main

type Person struct {
    name string
    age  int
}

func (p Person) Say(msg string) string {
    return msg
}

func main() {
    p := Person{
       name: "tian",
    }
    p.Say("hello")
    p2 := &Person{
       name: "tian",
    }
    p2.Say("hello")
}