GO--重要操作：接口

最新推荐文章于 2024-10-05 22:12:27 发布
最新推荐文章于 2024-10-05 22:12:27 发布
阅读量344 收藏
点赞数
文章标签： go golang 运维开发 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhuan303/article/details/124297639
版权

目录

1，接口定义

2，多态

3，系统接口调用

4，接口嵌套

5，类型断言

6，链表使用

示例：发现输出哪里不同

package main
​
import "fmt"
​
//父结构体cart
type cart struct {
    weight int
    color  string
}
​
//父结构体方法
func (c cart) run() {
    fmt.Println("running")
}
​
//定义子结构体train
type train struct {
    //继承cart
    cart
    wheel int
}
​
//子结构体方法
func (t train) String() string {
    str := fmt.Sprintf("color:[%s],weight:[%d],wheel:[%d]", t.color, t.weight, t.wheel)
    return str
}
​
func main() {
    var train train
    train.color = "绿色"
    train.weight = 140000
    train.wheel = 16
    fmt.Println(train)
    train.run()
    fmt.Printf("%s\n", train)
}
[Running] go run "f:\goProject\src\dev_code\day20\example7\main\main.go"
color:[绿色],weight:[140000],wheel:[16]  //并没有调用子结构体的方法，实际使用了方法，内部
//实际是使用了接口的功能，调用了子接口的方法
running
color:[绿色],weight:[140000],wheel:[16]
​
[Done] exited with code=0 in 0.563 seconds

1，接口定义

概念: Interface类型可以定义一组方法， 不需要实现，并且不能包含任何变量，称之为接口。

接口不需要显示的实现，只需要一个变量， 含有接类型中的所有方法，那么这个变量就实现了这个接口，如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。

语法：

type example interface{
Method1(参数列表)返回值列表
Method2(参数列表)返回值列表
   ...
}

示例：空接口使用

package main
​
import "fmt"
​
//接口定义
type Test interface{}
​
func main() {
    var t Test
    fmt.Printf("t的类型:%T,值：%v\n", t, t)
    var a interface{} //也是一种定义接口形式
    var b int
    a = b
    fmt.Printf("a的类型:%T,值：%v\n", a, a)
​
}
[Running] go run "f:\goProject\src\dev_code\day20\example8\main\main.go"
t的类型:<nil>,值：<nil>  //接口就是相当于空指针
a的类型:int,值：0        //把什么东西赋给空接口，空接口就成了什么
​
[Done] exited with code=0 in 0.573 seconds

示例：结构体使用接口打印信息

package main
​
import "fmt"
​
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//定义接口:功能的抽象表现，不需要实现
type Test interface {
    print()
}
​
//接口的实现
func (s student) print() {
    fmt.Printf("name:[%s]\n", s.name)
    fmt.Printf("age:[%d]\n", s.age)
    fmt.Printf("name:[%f]\n", s.score)
}
func main() {
    //申明接口变量
    var t Test
    //结构体初始化
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 100,
    }
    var stu1 student = student{
        name:  "lisi",
        age:   25,
        score: 20,
    }
    stu.print() //也可以输出只代表个体stu
    //结构体赋值
    t = stu
    //接口功能
    t.print()
    //结构体赋值
    t = stu1
    //接口功能
    t.print()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example1\main\main.go"
name:[zhangsan]
age:[20]
name:[100.000000]
name:[zhangsan]
age:[20]
name:[100.000000]
name:[lisi]
age:[25]
name:[20.000000]
​
[Done] exited with code=0 in 0.539 seconds

传指针

package main
​
import "fmt"
​
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//定义接口:功能的抽象表现，不需要实现
type Test interface {
    print()
}
​
//接口的实现  传指针
func (s *student) print() {
    fmt.Printf("name:[%s]\n", s.name)
    fmt.Printf("age:[%d]\n", s.age)
    fmt.Printf("name:[%f]\n", s.score)
}
func main() {
    //申明接口变量
    var t Test
    //结构体初始化
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 100,
    }
    var stu1 student = student{
        name:  "lisi",
        age:   25,
        score: 20,
    }
    stu.print() //也可以输出只代表个体
    //结构体赋值
    t = &stu
    //接口功能
    t.print()
    //结构体赋值
    t = &stu1
    //接口功能
    t.print()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example1\main\main.go"
name:[zhangsan]
age:[20]
name:[100.000000]
name:[zhangsan]
age:[20]
name:[100.000000]
name:[lisi]
age:[25]
name:[20.000000]

接口中多方法的实现

示例：

package main
​
import "fmt"
​
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//定义接口:功能的抽象表现，不需要实现
//接口中包含多个方法，如果要使用这个接口，这个接口中的所有方法都要使用
type Test interface {
    print()
    sleep()
}
​
//接口的实现  传指针
func (s *student) print() {
    fmt.Printf("name:[%s]\n", s.name)
    fmt.Printf("age:[%d]\n", s.age)
    fmt.Printf("name:[%f]\n", s.score)
}
​
func (s student) sleep() {
    fmt.Println("正在睡觉")
}
func main() {
    //申明接口变量
    var t Test
    //结构体初始化
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 100,
    }
​
    //结构体赋值
    t = &stu
    //接口功能
    t.print()
    t.sleep()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example2\main\main.go"
name:[zhangsan]
age:[20]
name:[100.000000]
正在睡觉
​
[Done] exited with code=0 in 0.557 seconds

接口功能可以不使用方法一定要有

package main
​
import "fmt"
​
//定义结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//定义接口:功能的抽象表现，不需要实现
//接口中包含多个方法，如果要使用这个接口，这个接口中的所有方法都要使用
type Test interface {
    print()
    sleep()
}
​
//接口的实现  传指针
func (s *student) print() {
    fmt.Printf("name:[%s]\n", s.name)
    fmt.Printf("age:[%d]\n", s.age)
    fmt.Printf("name:[%f]\n", s.score)
}
func (s student) sleep() {
    fmt.Println("正在睡觉")
}
func main() {
    //申明接口变量
    var t Test
    //结构体初始化
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 100,
    }
​
    //结构体赋值
    t = &stu
    //接口功能
    t.print()
    // t.sleep()
​
}
​
[Running] go run "f:\goProject\src\dev_code\day21\example2\main\main.go"
name:[zhangsan]
age:[20]
name:[100.000000]
​
[Done] exited with code=0 in 0.557 seconds

2，多态

示例:为不同数据类型的实体提供统一的接口。

package main
​
import "fmt"
​
//定义父结构体
type person struct {
    name string
    age  int
}
​
//定义结构体学生
type student struct {
    person //继承
    score  float32
}
​
//定义结构体老师
type teacher struct {
    person //继承
    class  string
}
​
//定义接口:功能的抽象表现，不需要实现
//接口中包含多个方法，如果要使用这个接口，这个接口中的所有方法都要使用
type Test interface {
    print()
    sleep()
}
​
//学生接口的实现 
func (s student) print() {
    fmt.Printf("name:[%s]\n", s.name)
    fmt.Printf("age:[%d]\n", s.age)
    fmt.Printf("name:[%f]\n", s.score)
}
func (s student) sleep() {
    fmt.Println("正在睡觉")
}
​
//教师接口实现
func (t teacher) print() {
    fmt.Printf("name:[%s]\n", t.name)
    fmt.Printf("age:[%d]\n", t.age)
    fmt.Printf("name:[%s]\n", t.class)
}
func (t teacher) sleep() {
    fmt.Println("正在睡觉")
}
func main() {
    //申明接口变量
    var t Test
    //结构体初始化学生
    var stu student
    stu.name = "zhangsan"
    stu.age = 20
    stu.score = 100
    //结构体初始化教师
    var tea teacher
    tea.name = "lisi"
    tea.age = 50
    tea.class = "一班"
​
    //学生使用接口功能
    t = stu
    //接口功能
    t.print()
    t.sleep()
    fmt.Println("---------------------")
    //教师使用接口功能
    t = tea
    //接口功能
    t.print()
    t.sleep()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example3\main\main.go"
name:[zhangsan]
age:[20]
name:[100.000000]
正在睡觉
---------------------
name:[lisi]
age:[50]
name:[一班]
正在睡觉
​
[Done] exited with code=0 in 0.553 seconds

示例：

package main
​
import "fmt"
​
//电脑的usb接口有三个功能分别是存储，鼠标，风扇功能
type computer struct {
    name string
}
type USB interface {
    mouse()
    cunchu()
    fengshan()
}
​
func (c computer) mouse() {
    fmt.Println("正在使用鼠标功能")
}
func (c computer) cunchu() {
    fmt.Println("正在使用u盘存储功能")
}
func (c computer) fengshan() {
    fmt.Println("正在使用风扇功能")
}
func main() {
    var u USB
    var com computer = computer{
        name: "usb接口",
    }
    fmt.Println(com)
​
    u = com
    u.mouse()
    u.cunchu()
    u.fengshan()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example4\main\main.go"
{usb接口}
正在使用鼠标功能
正在使用u盘存储功能
正在使用风扇功能

多接口实现

package main
​
import "fmt"
​
//多接口实现
//接口1
type test interface {
    print()
}
​
//接口2
type test1 interface {
    sleep()
}
​
//结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//接口1方法实现
func (s student) print() {
    fmt.Printf("name:[%s]\n", s.name)
}
​
//接口2的方法实现
func (s student) sleep() {
    fmt.Println("正在睡觉")
}
​
func main() {
    //接口1变量
    var t test
    //接口2变量
    var t1 test1
    //初始化结构体
    var stu student = student{
        name:  "zhangsan",
        age:   20,
        score: 100,
    }
    //调用接口实现功能
    t = stu
    t.print()
    t1 = stu
    t1.sleep()
​
}
[Running] go run "f:\goProject\src\dev_code\day21\example5\main\main.go"
name:[zhangsan]
正在睡觉
​
[Done] exited with code=0 in 0.539 seconds

3，系统接口调用

示例:使用接口进行排序。 结构体切片插入

package main
​
import (
    "fmt"
    "math/rand"
    "sort"
    "time"
)
​
//声明结构体
type student struct {
    name  string
    age   int
    score float32
}
​
//声明一个切片
type studentarray []student
​
//实现sort排序接口
func (sa studentarray) Len() int {
    return len(sa) //返回长度
}
func (sa studentarray) Less(i, j int) bool {
    return sa[i].name > sa[j].name //成立是true
}
func (sa studentarray) Swap(i, j int) {
    sa[i], sa[j] = sa[j], sa[i] //交换数值
}
​
func main() {
    rand.Seed(time.Now().Unix()) //时间种子随机函数
    //student切片
    var stus studentarray
​
    //生成10个结构体放入切片中
    for i := 0; i < 10; i++ {
        var stu student = student{
            name:  fmt.Sprintf("stu%d", rand.Intn(100)),
            age:   rand.Intn(120), //随机数
            score: rand.Float32() * 100,
        }
        //结构体元素存入切片中
        stus = append(stus, stu)
    }
    //遍历
    for _, v := range stus {
        fmt.Println(v)
    }
    //排序
    fmt.Println("--------------------------")
    sort.Sort(stus)
    //遍历
    for _, v := range stus {
        fmt.Println(v)
    }
}
​
[Running] go run "f:\goProject\src\dev_code\day21\example6\main\main.go"
{stu41 39 24.372263}
{stu11 95 7.653611}
{stu49 60 62.645496}
{stu62 43 63.027138}
{stu36 36 89.42971}
{stu36 58 18.596565}
{stu12 63 39.70508}
{stu71 4 74.418434}
{stu62 45 42.58918}
{stu23 78 8.72018}
--------------------------
{stu71 4 74.418434}
{stu62 45 42.58918}
{stu62 43 63.027138}
{stu49 60 62.645496}
{stu41 39 24.372263}
{stu36 36 89.42971}
{stu36 58 18.596565}
{stu23 78 8.72018}
{stu12 63 39.70508}
{stu11 95 7.653611}
​
[Done] exited with code=0 in 0.54 seconds

4，接口嵌套

示例：文件读写测试

package main
​
import "fmt"
​
//接口嵌套
//定义reader接口
type Reader interface {
    read()
}
​
//定义writer接口
type Writer interface {
    writer()
}
​
//定义嵌套的读写接口
type Readerwriter interface {
    Reader //直接调用子接口的名称
    Writer //直接调用子接口的名称
}
​
//定义结构体
type File struct{}
​
//接口的实现  值类型传递一般使用指针传递
func (f *File) read() {
    fmt.Println("正在使用读功能")
}
func (f *File) writer() {
    fmt.Println("正在使用写功能")
}
​
//定义读写操作函数
func Test(rw Readerwriter) {
    rw.read()
    rw.writer()
}
func main() {
    //初始化文件
    var f File
    Test(&f)
}
[Running] go run "f:\goProject\src\dev_code\day22\example7\main\main.go"
正在使用读功能
正在使用写功能
​
[Done] exited with code=0 in 0.766 seconds

5，类型断言

作用:因为接口是一般类型， 需要明确具体类型的时候就需要使用类型断言。

package main
​
import "fmt"
​
//类型断言
func main() {
    var a interface{}
    var b int
    a = b
    fmt.Printf("a的类型：%T,a的结构%v\n", a, a)
    //类型断言赋值
    c := a.(int)
    fmt.Printf("c的类型：%T,c的结构%v\n", c, c)
    //处理过程称为断言处理
}
[Running] go run "f:\goProject\src\dev_code\day22\example2\main\main.go"
a的类型：int,a的结构0
c的类型：int,c的结构0
​
[Done] exited with code=0 in 0.576 seconds

可以做判断

package main
​
import "fmt"
​
//类型断言
func main() {
    var a interface{}
    var b string
    a = b
    fmt.Printf("a的类型：%T,a的结构%v\n", a, a)
    //类型断言赋值
    c, err := a.(int)
    if err == true {
​
        fmt.Printf("c的类型：%T,c的结构%v\n", c, c)
    } else {
        fmt.Println("不属于int类型")
    }
    //处理过程称为断言处理
}
[Running] go run "f:\goProject\src\dev_code\day22\example2\main\main.go"
a的类型：string,a的结构
不属于int类型
​
[Done] exited with code=0 in 0.556 seconds

示例：断言判断

package main
​
import "fmt"
​
func Test(p interface{}) {
    v, err := p.(int)
    if err == false {
        fmt.Println("type is not int")
        return
    }
    v += 2
    fmt.Println(v)
}
func main() {
    Test(10)
    Test("hello")
}
[Running] go run "f:\goProject\src\dev_code\day22\example2\main\main.go"
12
type is not int
​
[Done] exited with code=0 in 0.577 seconds

示例：多类型判断

package main
​
import "fmt"
​
//多数据类型判断处理  长度不固定，类型不固定知道类型可以用切片
func classfile(items ...interface{}) {
    //遍历复杂集合
    for i, v := range items {
        //switch...type结合类型判断
        switch v.(type) {
        case bool:
            fmt.Printf("第%d个数据类型是bool\n", i)
        case int, int8, int16, int32, int64:
            fmt.Printf("第%d个数据类型是int\n", i)
        case float32, float64:
            fmt.Printf("第%d个数据类型是float\n", i)
        case string:
            fmt.Printf("第%d个数据类型是string\n", i)
        default:
            fmt.Printf("第%d个数据类型是其他类型\n", i)
        }
    }
}
func main() {
    classfile("zhangsan", 25, 93.52, true, nil)
}
[Running] go run "f:\goProject\src\dev_code\day22\example3\main\main.go"
第0个数据类型是string
第1个数据类型是int
第2个数据类型是float
第3个数据类型是bool
第4个数据类型是其他类型
​
[Done] exited with code=0 in 0.591 seconds

6，链表使用

示例：

package main
​
import "fmt"
​
//使用接口实现链表插入
//定义节点结构体
type Linknode struct {
    data interface{}
    next *Linknode
}
​
//链表结构体
type Link struct {
    head *Linknode
    tail *Linknode
}
​
//头部插入
func (k *Link) inserthead(data interface{}) {
    var node *Linknode = &Linknode{
        data: data,
        next: nil,
    }
    if k.head == nil && k.tail == nil {
        k.head = node
        k.tail = node
        return
    }
    //节点平移
    node.next = k.head
    k.head = node
​
}
​
//尾部插入
func (k *Link) inserttail(data interface{}) {
    var node *Linknode = &Linknode{
        data: data,
        next: nil,
    }
    if k.head == nil && k.tail == nil {
        k.head = node
        k.tail = node
        return
    }
    //节点平移
    k.tail.next = node
    k.tail = node
}
​
//遍历
func (p *Link) Req() {
    lp := p.head
    for lp != nil {
        fmt.Println(*lp)
        lp = lp.next
    }
}
​
func main() {
    var L Link
    for i := 0; i < 10; i++ {
        L.inserthead(i)
        L.inserttail(i)
    }
    //遍历
    L.Req()
}
[Running] go run "f:\goProject\src\dev_code\day22\example5\main\main.go"
{9 0xc0000961e0}
{8 0xc0000961b0}
{7 0xc000096180}
{6 0xc000096150}
{5 0xc000096120}
{4 0xc0000960f0}
{3 0xc0000960c0}
{2 0xc000096090}
{1 0xc000096060}
{0 0xc000096078}
{0 0xc0000960a8}
{1 0xc0000960d8}
{2 0xc000096108}
{3 0xc000096138}
{4 0xc000096168}
{5 0xc000096198}
{6 0xc0000961c8}
{7 0xc0000961f8}
{8 0xc000096228}
{9 <nil>}
​
[Done] exited with code=0 in 0.538 seconds

LiuHuan303
关注
kube-pokeapi-arena::joystick:要抓住他们所有！
04-05
Go语言在这里的作用至关重要。作为项目的主要实现语言，Go提供了强大的并发模型和标准库，使得“kube-pokeapi-arena”能够高效地处理Kubernetes API的调用和事件处理。Go的接口和结构体设计也使得代码更易于理解和...
go-doc-zh：Go标准库学习笔记
02-04
标准库作为Go语言的重要组成部分，包含了大量预定义的包和函数，覆盖了网络编程、文件操作、并发处理、数据格式化等多个领域，为开发者提供了丰富的功能支持。 这篇笔记主要分为以下几个部分： 1. **基础包**： -...
Go-go-admin:基于golang快速搭建后台管理中心
08-13
Golang，又称Go语言，是Google于2009年推出的开源编程语言，以其简洁的语法、高效的性能和并发特性深受开发者喜爱。在Web开发领域，Golang凭借其内置的HTTP库和轻量级线程（goroutine）机制，成为了构建高并发Web...
quarentena-golang-crud中的代码：源代码golang do crud do quarentena中的代码
02-17
在本项目"quarentena-golang-crud"中，我们主要关注的是使用Go语言实现CRUD（Create, Read, Update, Delete）操作的源代码。Go语言，也被称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾...
The-Go-Standard-Library-Src-Analysis:Go语言标准库源码剖析
03-10
《Go语言标准库源码剖析》是一份深入探讨Go（Golang）编程语言标准库的资源，旨在帮助开发者更深入地理解Go的核心机制和最佳实践。标准库是Go语言生态系统的重要组成部分，它提供了丰富的功能，涵盖了网络通信、文件...
go基础面试题汇总第一弹
weixin_43683432的博客
10-01 827
通常作为程序执行前包的初始化，例如mysql redis 等中间件的初始化。
mysql设置表的某一个字段每天定时清零
GoppViper的博客
10-04 608
这里的STARTS指定了事件开始的时间，‘2024 - 10 - 05 00:00:00’ 是一个示例时间，表示从 2024 年 10 月 5 日开始执行这个每天一次的操作。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。2.检查和开启事件调度器（如果尚未开启）
Golang | Leetcode Golang题解之第447题回旋镖的数量
weixin_66442839的博客
09-30 417
Golang | Leetcode Golang题解之第447题回旋镖的数量
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 909
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
go语言&protoc的详细用法与例子
ruanjianxueyuan113的博客
10-04 390
讲解protoc怎么把某一个目录上的proto文件转成指定目录上的go文件，
GO语言环境搭建和字符说明
qq_43556680的博客
09-28 1401
Go的三种安装方式Go有多种安装方式，你可以选择自己喜欢的。：这是一种标准的软件安装方式。对于经常使用Unix类系统的用户，尤其对于开发者来说，从源码安装是最方便而熟悉的。：Go提供了方便的安装包，支持Windows、Linux、Mac等系统。这种方式适合初学者，可根据自己的系统位数下载好相应的安装包，一路next就可以轻松安装了。：目前有很多方便的第三方软件包工具，例如Ubuntu的apt-get、Mac的homebrew等。这种安装方式适合那些熟悉相应系统的用户。
【LeetCode】每日一题 2024_10_2 准时到达的列车最小时速（二分答案）
Locky136的博客
10-02 558
【LeetCode】每日一题 2024_10_2 准时到达的列车最小时速（二分答案）
使用apipost工具导入通过swag生成的golang接口文档步骤
zhoupenghui168的博客
09-29 454
使用apipost工具导入通过swag生成的golang接口文档步骤
Go基础学习10-原子并发包sync.atomic的使用：CSA、Swap、atomic.Value......
FLJS_T的博客
10-02 890
原子操作sync.atomic以及原子变量atomic.Value详细介绍。go中原生的支持原子操作的函数支持的变量类型int32、int64、uint32、uint64、uintptr，以及unsafe包中的Pointer。对于上述原子操作类型中的每一个，可以支持的数据类型有：==int32、int64、uint32、uint64、uintptr，以及unsafe包中的Pointer。但是否sync.Mutex变量能够保证操作的原子性。atomic.Value类型是开箱即用的，我们声明一个该类型的变量
golang小项目1-家庭收支记账系统
技术卷的博客
09-30 1573
用面向对象的方式实现基于命令行界面的《家庭收支记账系统》，该软件能实现注册、登录、记录家庭的收入与支出、打印收支明细表、转账、注销、修改密码等功能。其中收支明细表显示所有交易记录，一条交易记录由交易类型（收入/支出）、用户余额（交易后）、交易金额、备注组成。所有数据都存在本地的 TXT 文件中，软件要实现对文件数据的读和写。
go dlv idea 远程调试-入门级
h799710的博客
09-29 573
用idea远程调试go程序的入门级教程、笔记
【go入门】流程控制语句
最新发布
liuzhehao的博客
10-05 429
if..else，for循环，switch和case，goto
使用Buildpacks构建Docker镜像
niwoxiangyu的博客
10-05 806
通过这样做，他们提供了一种控制的平衡，最小化了最初的生产时间，减少了开发者的操作负担，并支持大规模管理应用程序的企业运营商。在构建过程中，stacks的构建镜像成为执行Buildpack的环境，其运行镜像成为最终应用程序镜像的基础。构建是对应用程序的源代码执行一个或多个buildpacks构建包以生成可运行的OCI镜像的过程。分析：CNB 会在应用的生命周期中运行多次，在这一步骤里会对前一次的打包内容进行分析，分析过程会对文件的变更进行优化，从而减少构建时间和文件传输。后续的构建将利用各种形式的缓存。
【go入门】常量
liuzhehao的博客
09-29 1105
定义，const用于枚举，iota
Cortex-M4 Devices 技术手册：USB OTG 库指南
3. 应用程序编程接口（API）：简化开发过程，提供标准函数调用来操作硬件。 4. 调试工具支持：如JTAG和SWD接口，便于调试和优化代码。 开发者使用这些资源时，应当注意遵循ARM和STMicroelectronics提供的开发工具和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值