GO 基础语法加强1

已于 2022-05-19 15:31:58 修改
阅读量470 收藏
点赞数
分类专栏： Go 文章标签： golang 中间件 开发语言
于 2022-05-16 16:41:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hualaoshuan/article/details/124801472
版权

本篇概要：


概要：

  • 设计模式 web、中间件（consul、etcd、tidb）、偏底层（docker、k8s）
  • httpserver、rpc \ grpc、http3（quic）、go-micro、gokit
  • 模板、nginx、gin、gin++

IDE 配置：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1. type 关键字；

# 进入 /Users/go/go2/
go mod init goplus

在这里插入图片描述

  • 文件 /Users/go/go2/src/String/String.go
package String

type String string 	//自己定义的 string

// 返回自定义的 String
func From(str string) (String) {
	// String 强制转化，本质是一样的
	return String(str)
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/String"
)

func main() {
	s := String.From("abc")
	fmt.Println(s)
}

2. 定制的 String、类型方法、int 变 string；

  • 文件 /Users/go/go2/src/String/String.go
package String

import (
	"fmt"
)

type String string 	//自己定义的 string

// 实现类似于类方法的函数
// 返回长度
func (this String) Len() (int) {
	return len(this)
}


// 返回自定义的 String
func From(str string) (String) {
	// String 强制转化，本质是一样的
	return String(str)
}

func FromInt(n int) (String) {
	// 当成 string 转，直接会当成 ASCII 码值
	// 所以调用方法会返回 "{"，ASCII 123 对应的符号
	// return String(n)

	// 第一种写法：内置转化方法
	// return String(strconv.Itoa(n))

	// 第二种写法
	return String(fmt.Sprintf("%d", n))

}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/String"
)

func main() {
	// s := String.From("abc")
	s := String.FromInt(123)
	fmt.Println(s)
	fmt.Println(s.Len())	//类方法
}

3. 定制的 String：遍历字符串、Each；

  • 文件 /Users/go/go2/src/String/String.go
package String

import (
	"fmt"
)

type String string 	//自己定义的 string

// 实现类似于类方法的函数
// 返回长度
func (this String) Len() (int) {
	return len(this)
}

// ！！遍历（函数里的参数是可以传函数的）
func (this String) Each(f func(item string)) {
	for i :=0; i < len(this); i++ {
		// fmt.Println(i, ", ",fmt.Sprintf("%c", this[i]))
		f(fmt.Sprintf("%c", this[i]))

	}
}

// 返回自定义的 String
func From(str string) (String) {
	// String 强制转化，本质是一样的
	return String(str)
}

func FromInt(n int) (String) {
	// 当成 string 转，直接会当成 ASCII 码值
	// 所以调用方法会返回 "{"，ASCII 123 对应的符号
	// return String(n)

	// 第一种写法：内置转化方法
	// return String(strconv.Itoa(n))

	// 第二种写法
	return String(fmt.Sprintf("%d", n))

}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/String"
)

func main() {
	s := String.From("abcde")
	// s := String.FromInt(123)

	// 遍历
	for i :=0; i < len(s); i++ {
		// 打印出 ASCII 码
		// fmt.Println(i, ", ",s[i])

		// go 没有 char 类型
		// %c 打印 char
		// fmt.Println(i, ", ",fmt.Sprintf("%c", s[i]))
	}

	// 调用遍历
	s.Each(func(item string) {
		fmt.Println(item)	// 返回 abcde
	})

}

4. 定制的 String：遍历字符串（带中文）；

  • 文件 /Users/go/go2/src/String/String.go
package String

import (
	"fmt"
)

type String string 	//自己定义的 string

// 实现类似于类方法的函数
// 返回长度
func (this String) Len() (int) {
	return len(this)
}

// 遍历（函数里的参数是可以传函数的）
func (this String) Each(f func(item string)) {
	for i :=0; i < len(this); i++ {
		// fmt.Println(i, ", ",fmt.Sprintf("%c", this[i]))
		f(fmt.Sprintf("%c", this[i]))

	}
}

// ！！遍历中文
func (this String) EachC(f func(item string)) {
	for _, c := range this {
		f(fmt.Sprintf("%c", c))

	}
}

// 返回自定义的 String
func From(str string) (String) {
	// String 强制转化，本质是一样的
	return String(str)
}

func FromInt(n int) (String) {
	// 当成 string 转，直接会当成 ASCII 码值
	// 所以调用方法会返回 "{"，ASCII 123 对应的符号
	// return String(n)

	// 第一种写法：内置转化方法
	// return String(strconv.Itoa(n))

	// 第二种写法
	return String(fmt.Sprintf("%d", n))

}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/String"
)

func main() {
	s := String.From("我123")

	// 返回
	//0   我
	//3   1
	//4   2
	//5   3
	//for index,c := range s {
	//	fmt.Println(index, " ", fmt.Sprintf("%c", c))
	//}

	s.EachC(func(item string) {
		fmt.Println(item)	// 返回 "我123"
	})
}

5. 从字符串中再认识下 byte、rune；

  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/String"
)

func main() {
	s := String.From("我123")

	for i:=0; i<len(s); i++ {
		// fmt.Println(i, "", s[i])	// 打印原始字节
		// fmt.Println(i, "", fmt.Sprintf("%T", s[i]))	// 打印字节的类型（无符号int8）
	}

	// 网络编程和数据传输的时候都是使用"字节" byte
	// 字符串的本质就是字节，虽然表达形式不同

	// uint 类型就是 byte 型，代表 ASCII 码字符集的一个字符
	// 当处理中文、日文、韩文等符合字符时，使用 rune 就是 int 32，也就是 Unicode 字符集（utf8 是编码规则）

	fmt.Println([]byte(s))	// [230 136 145 49 50 51]
	fmt.Println([]int32(s))	// [25105 49 50 51]
	fmt.Println([]rune(s))	// int32 的别名 rune，[25105 49 50 51]
	fmt.Printf("%c", 25105)	// 我

	for _, c :=range s {
		//25105
		//49
		//50
		//51
		fmt.Println(c)	// 字符串遍历，是 unicode 字符集
	}
}

6. 自定义 struct、所谓的构造函数；

在这里插入图片描述

  • 文件 /Users/go/go2/src/Object/User.go
package Object

type User struct {
	Id, Gender int
	Name string
}

func NewUser() (User) {
	return User{}
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Object"
)

// u 形参参数名
func change(u Object.User) {
	u.Id = 202
}

// 有效，但是一般代码不会这么写，都会用指针
func change2(u Object.User) Object.User {
	u.Id = 202
	return u
}

func main() {
	u := Object.NewUser()
	// fmt.Println(u)	// 默认打印每一项属性的 0 值（初始值）：{0 0 }
	//fmt.Printf("%v", u)	// 和上面结果一样
	//fmt.Printf("%+v", u)	// 显示 属性的名称：{Id:0 Gender:0 Name:}

	// 修改属性
	u.Id = 101
	//change(u) 	//   修改无效
	//u = change2(u)	// 修改有效：{Id:202 Gender:0 Name:}{
	//fmt.Printf("%+v", u)

	fmt.Printf("%p", &u)	// 看地址：0xc0000a6020
}

7. 使用指针 struct；

常见的方式是：一律采用指针对 struct 进行初始化

  • 文件 /Users/go/go2/src/Object/User.go
package Object

type User struct {
	Id, Gender int
	Name string
}

func NewUser() (*User) {
	return new (User)
	// return &User{}
}

//func NewUser() (User) {
//	return User{}
//}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Object"
)


func change(u *Object.User) {
	u.Id = 202
	fmt.Printf("%p\n", u)
}


func main() {
	//uu := Object.User{}
	//fmt.Println(uu)	// {0 0 }
	//
	//u := Object.NewUser()
	//fmt.Println(u)	// &{0 0 }
	//
	//
	//var u1 Object.User	// 如此定义， 已经开辟了值
	//var u2 *Object.User	// 定义指针变量，得进行初始化
	//fmt.Println(u1, u2)	// {00 }	<nil>

	u := Object.NewUser()

	change(u)	// 0xc00000c060
	fmt.Printf("%p\n", u)	// 0xc00000c060
	fmt.Println(u)	// &{202 0 }

	// struct 传参尽量使用指针，仅仅是地址的值，不会是 struct 里的 内容
	// go 里面是按值传递，就算传的是指针，不会复制 struct 本身内容，但是会复制地址的值
	// 地址的值对应的地址是不一样的

}

8. 构造函数技巧：任意设置属性值；

  • 文件 /Users/go/go2/src/Object/User.go
package Object

type User struct {
	Id, Gender int
	Name string
}

// 有选择性的对 Id 进行赋值
func NewUser(f func(u *User)) (*User) {
	u := new (User)
	f(u)
	return u
}

// 用来构造上面的 f 函数
//仅仅返回 function 而不是执行结果
func WithUserId(id int) (f func(u *User)) {
	return func(u *User) {
		u.Id = id
	}
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Object"
)

func main() {
	u := Object.NewUser(
		Object.WithUserId(120),
		)
	fmt.Println(u)	// 	&{120 0 }

}

9. 构造函数技巧：可变参数；

  • 文件 /Users/go/go2/src/Object/User.go
package Object

type User struct {
	Id int
	Name string
	Gender byte
}

// 有选择性的进行赋值（可变参数，参数类型是 function）
func NewUser(fs  ...func(u *User)) (*User) {
	u := new (User)
	for _, f := range fs {
		f(u)
	}

	return u
}
  • 文件 /Users/go/go2/src/Object/UserAttrs.go
package Object

func WithUserId(id int) (f func(u *User)) {
	return func(u *User) {
		u.Id = id
	}
}

func WithUserName(name string) (f func(u *User)) {
	return func(u *User) {
		u.Name = name
	}
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Object"
)

func main() {
	u := Object.NewUser(
		Object.WithUserId(120),
		Object.WithUserName("hua"),
		)
	fmt.Println(u)

}

10. 构造函数技巧：进一步封装；

  • 文件 /Users/go/go2/src/Object/UserAttrs.go
package Object

// type UserAttrFunc func(u *User)

type UserAttrFunc func(*User)	// 用来设置 User 属性的函数类型，参数可省略

type UserAttrFuncs []UserAttrFunc

// 类方法
//func (this UserAttrFunc) apply (u *User){
//	this(u)
//}

func (this UserAttrFuncs) apply (u *User){
	for _, f := range this {
		f(u)
	}
}

func WithUserId(id int) (UserAttrFunc) {
	return func(u *User) {
		u.Id = id
	}
}

func WithUserName(name string) (UserAttrFunc) {
	return func(u *User) {
		u.Name = name
	}
}
  • 文件 /Users/go/go2/src/Object/User.go
package Object

type User struct {
	Id int
	Name string
	Gender byte
}

// 有选择性的进行赋值（可变参数，参数类型是 function）
func NewUser(fs  ...UserAttrFunc) (*User) {
	u := new (User)
	//for _, f := range fs {
	//	f.apply(u)
	//}

	UserAttrFuncs(fs).apply(u)

	// fmt.Printf("%T", fs)	// 查看类型

	return u
}

11. map强化、基本使用、模拟 User 实体的创建；

在这里插入图片描述

  • 文件 /Users/go/go2/src/Map/User.go
package Map

// 自定义类型

type User map[string]string

func NewUser() (User) {
	// 初始化 map
	return make(map[string]string)
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Map"
)

// 几个类型： map、chan、slice
func change(u Map.User) {
	u["id"] = "404"
}

func main() {
	//var user map[string]string
	//
	 初始化map
	//user = make(map[string]string)
	//
	//user["id"] = "101"
	//
	//fmt.Println(user)

	u := Map.NewUser()
	u["id"] = "202"
	u["name"] = "hua"

	change(u)	// 可以改值

	//  map 引用类型、传参数传的是所对应地址的值（go都是按值传递）
	fmt.Println(u)

}

12. 设置值、链式调用；

  • 文件 /Users/go/go2/src/Map/User.go
package Map

// 自定义类型

type User map[string]interface{}

func (this User) With(k string, v interface{}) (User){
	this[k] = v
	return this
}

func NewUser() (User) {
	// 初始化 map
	return make(map[string]interface{})
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Map"
)

func main() {
	u := Map.NewUser()
	//u.With("id", "212")
	//u.With("name", "hua")

	// 链式调用
	u.With("id", 212).
		With("name", "hua")

	fmt.Println(u)
}

13. 遍历 map、按格式打印 map；

  • 文件 /Users/go/go2/src/Map/User.go
package Map

import "fmt"

// 自定义类型

type User map[string]interface{}

func (this User) With(k string, v interface{}) (User){
	this[k] = v
	return this

}

//func (this User) String()  {
//	for k, v := range this {
//		fmt.Printf("%v->%v\n", k, v)
//	}
//}

// 没有 string 方法，有默认的打印值
// 有 string 方法 直接调用
// 并不是每次按顺序打印
func (this User) String() string {
	str := ""
	for k, v := range this {
		str +=fmt.Sprintf("%v->%v\n", k, v)
	}
	return str
}

func NewUser() (User) {
	// 初始化 map
	return make(map[string]interface{})
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Map"
)

func main() {
	u := Map.NewUser()

	// 链式调用
	u.With("id", 212).
		With("name", "hua")

	//fmt.Println(u)	// map[id:212 name:hua]
	// u.String()	// id->212name->hua

	fmt.Println(u)	// 有定义的string方法，则打印出：id->212name->hua
}

14. 排序 Map Key、Sort 包的初步使用；

  • 文件 /Users/go/go2/src/Map/User.go
package Map

import (
	"fmt"
	"sort"
)

// 自定义类型

type User map[string]interface{}

func (this User) With(k string, v interface{}) (User){
	this[k] = v
	return this

}


func (this User) String() string {
	str := ""
	for index, k := range this.Fields() {
		str +=fmt.Sprintf("%d、%v->%v\n", index+1, k, this[k])
	}
	return str
}

// 返回切片
func (this User) Fields() ([]string) {
	keys := []string{}
	for k, _ := range this{
		keys = append(keys, k)
	}
	// sort.Strings(sort.StringSlice(keys))	// 正排序
	// sort.Strings(keys)	// 正排序
	// sort.Sort(sort.StringSlice(keys))	// 正排序
	sort.Sort(sort.Reverse(sort.StringSlice(keys)))	// 倒叙（全写）
	return keys
	//1、age->27
	//2、gender->male
	//3、id->212
	//4、name->hua
}


func NewUser() (User) {
	// 初始化 map
	return make(map[string]interface{})
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Map"
)

func main() {
	u := Map.NewUser()

	// 链式调用
	u.With("id", 212).
		With("name", "hua").
		With("gender", "male").
		With("age", 27)

	fmt.Println(u)
}

15. 多个 map 之间的排序方法；

  • 文件 /Users/go/go2/src/Map/User.go
package Map

import "sort"

// 自定义类型

type User map[string]interface{}

func (this User) With(k string, v interface{}) (User){
	this[k] = v
	return this

}


//func (this User) String() string {
//	str := ""
//	for index, k := range this.Fields() {
//		str +=fmt.Sprintf("%d、%v->%v\n", index+1, k, this[k])
//	}
//	return str
//}

// 返回切片
func (this User) Fields() ([]string) {
	keys := []string{}
	for k, _ := range this{
		keys = append(keys, k)
	}
	// sort.Strings(sort.StringSlice(keys))	// 正排序
	// sort.Strings(keys)	// 正排序
	// sort.Sort(sort.StringSlice(keys))	// 正排序
	sort.Sort(sort.Reverse(sort.StringSlice(keys)))	// 倒叙（全写）
	return keys
	//1、age->27
	//2、gender->male
	//3、id->212
	//4、name->hua
}


func NewUser() (User) {
	// 初始化 map
	return make(map[string]interface{})
}
  • 文件 /Users/go/go2/src/main.go
package main

import (
	"fmt"
	"goplus/src/Map"
	"sort"
)

func main() {
	u1 := Map.NewUser()
	u1.With("id", 212).
		With("name", "hua").
		With("age", 33)

	u2 := Map.NewUser()
	u2.With("id", 12).
		With("name", "zhang").
		With("age", 27)

	u3 := Map.NewUser()
	u3.With("id", 121).
		With("name", "wang").
		With("age", 50)

	users := []Map.User{}
	users = append(users, u1, u2, u3)

	sort.Slice(users, func(i, j int) bool {
		age1 := users[i]["age"]. (int)	// 断言，针对 interface
		age2 := users[i]["age"]. (int)
		return age1>age2
	})

	fmt.Println(users)	// [map[age:33 id:212 name:hua] map[age:27 id:12 name:zhang] map[age:50 id:121 name:wang]]
}
来斤华子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go关键字--go
架构师实战感悟
07-08 8271
go 轻松开启高并发，一直都是golang语言引以为豪的功能点。golang通过goroutine实现高并发，而开启goroutine的钥匙正是go关键字。开启并发执行的语法格式是： go funcName() 在调用函数后，只需要在被调用的函数前边加上go关键字，就可以轻松的开启并发执行。下边请看示例代码： package main import ( &quot;fmt&quot; ...
Go type关键字
weixin_40123451的博客
12-24 329
定义新的类型： package main import "fmt" type myint int type mystring string func main() { var a myint a = 100 fmt.Println(a) // 100 fmt.Printf("%T\n", a) // main.myint } 类型别名： 注意：在main包不能定义类型别名的新方法，可以通过定义为新类型在添加方法 package main import
go的type关键字
liulanba的博客
08-09 2613
在 Go 语言中，reflect 包提供了更详细的反射机制，可以用于获取变量的类型、值等更多信息。在 Go 语言中，type 关键字用于定义自定义数据类型（类型别名、结构体、接口等），以及获取某个变量的类型信息。在上面的示例中，通过 shape.(type) 进行类型选择，判断具体是哪种类型的形状，并分别调用其 Area() 方法。在上面的示例中，使用 s.(Shape) 进行类型断言，判断变量 s 是否实现了 Shape 接口。在 Go 语言中，自定义类型的零值是该类型的初始值。
Golang通脉之类型定义
羌
10-25 280
自定义类型 在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， Go语言中可以使用type关键字来定义自定义类型。 type是Go语法里的重要而且常用的关键字，type绝不只是对应于C/C++中的typedef。搞清楚type的使用，就容易理解go语言中的核心概念struct、interface、函数等的使用。 类型定义 定义结构体 使用type 可以定义结构体类型： //1、定义结构体 //结构体定义 type person struct { name string /
GO语言-type关键字
qq522044637的博客
06-21 435
GO语言-type关键字
go语言基础语法代码整合
03-22
本资源"Go语言基础语法代码整合"是针对初学者或对Go语言无基础的开发者准备的一个学习材料，它通过一系列独立的Go代码文件，详细展示了Go语言的核心语法。 在Go语言中，语法简洁明了，易于理解和学习。以下是一些...
GO语言基础
11-01
**GO语言基础** Go语言，又称为Golang，是由Google公司于2009年推出的一种静态类型的、编译型的、并发型的、垃圾回收的编程语言。它旨在提高开发者的生产力和软件运行的效率，特别适合构建大规模的网络服务和分布式...
Go语言案例分析和练习
最新发布
05-26
1. **基础语法**：Go语言的基础语法简洁明了，包括变量声明、类型定义、控制结构（如if、for、switch）以及函数定义等。在实践中，你可以看到如何使用`:=`简写语法来声明并初始化变量，以及如何利用Go的多值返回来...
16、go语言type关键字
weixin_36020178的博客
05-09 213
go语言type关键字1、定义结构体2、类型等价定义3、结构体内嵌匿名成员4、定义接口5、定义函数类型综合示例 文章来源：https://studygolang.com/articles/17179?fr=sidebar 1、定义结构体 type person struct { name string age int } func main() { p := person{ name:"tony", age: 18,} fmt.Println(p.name) } 2、类型等价定义 类型重命名 //
【Go自学】一文搞懂Go中Type关键字的用法
Weber's blog
04-06 1657
一文搞懂Go中Type关键字的用法
go语言type关键字的基本用法
z6y6t的博客
04-18 298
文章目录type作用使用type定义新类型基本语法声明类型定义函数类型创建类型别名注意 type 作用 定义接口，定义结构体，定义一个新的类型 使用type定义新类型 基本语法 type type_name Type (type加名字加类型) 声明类型 例如 package main import "fmt" func main() { var i1 mystr fmt.Printf("类型一：%T\n",i1) var name mystr name = "李狗蛋" fmt.Print
Go语言基础篇--10.Go语言之【type关键字+error】
木易进
06-22 506
1.type关键字 1.1 type myint int type myint2 = int 对于type myint int这句代码来说，其含义是重新定义一个新的类型为myint，在下述代码当中，如果讲a赋值给a1就会报错cannot　use　a(type　int)as　type　myint　in　assignment\color{red}{cannot　use　a (type　int) as　 type 　myint　 in 　assignment}cannot　use　a(type　int)as　t
Go内置关键字分析（一）
sinat_24568041的博客
07-03 1160
Go语言中总共有25个，如下所示：Go关键字按类型不同做如下区分(注：图片来自网络，若有侵权，请联系删除)：1. 基本结构类1.1变量与常量(1) Var作用：定义变量举例：var x int=4 or x:=4注意：a.在函数中，:= 简洁赋值语句在明确类型的前提下，可以用于替代 var 定义。b.:= 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始。演示：package main ...
Go：保留关键字及基本数据类型
aaron_ye的专栏
01-30 4050
1 命名规范     在Go中几乎所有的东西都是有名字或标识符的（类似于C家族语言），且它们是对大小写敏感的。相应的规则如下： 必须以字符开头（所有Unicode UTF-8中的字符 或 下划线“_”）后面可以跟0或多个字符或数字，如：x56, _x32等。不能以数字开头或系统保留关键字和操作符。如：1ab, case, a+b。下划线"_"本身在Go中是一个特殊的标识符，
Go 学习笔记（27）— type 关键字（类型定义、类型别名、类型查询、定义接口、定义结构体）
wohu1104的专栏
05-05 2666
1. 类型别名定义 定义类型别名的写法为： type TypeAlias = Type 类型别名规定： TypeAlias 只是 Type 的别名，本质上 TypeAlias 与 Type 是同一个类型，就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。 2. 类型定义 类型定义语法如下： type newType Type 其中 new...
Go关键字--type
热门推荐
架构师实战感悟
07-08 1万+
type type有如下几种用法： 1. 定义结构体 2. 定义接口 3. 类型定义 4. 类型别名 5. 类型查询 定义结构体 结构体是用户自定义的一种抽象的数据结构，golang中struct类似于java语言中的class， 在程序设计中，有着举足轻重的地位。结构体的用法，将会在struct关键字中详细的介绍。下边来看一下定义一个结构体的语法格式： type nam...
Golang中的type关键字
jianming21的博客
07-07 2115
文章目录定义结构体定义接口自定义类型类型定义类型开关 原文链接 type有几种用法：定义结构体，定义接口， 类型别名， 类型定义， 类型开关 定义结构体 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。类似Java 的类，我们可以把Go中的struct看作是不支持继承行为的轻量级的“类”。 我们来看看使用type怎么定义结构体： //定义一个 Books结构体 type Books struct { title string author string subject str
Go语言type关键字（类型别名）
保暖透气大裤衩LeoLee的博客
12-26 994
前言 在讨论type关键字之前，先了解一下type关键字的意义。类型别名是 Go 1.9 版本添加的新功能，主要用于解决代码升级、迁移中存在的类型兼容性问题。Go语言难免和C/C++进行比较，在 C/C++语言中，代码重构升级可以使用宏快速定义一段新的代码，Go语言中没有选择加入宏，而是解决了重构中最麻烦的类型名变更问题。由于工作之后没有进行过任何C语言编程开发，这里不做详细讨论，主要是为了说...
Go编程语言基础教程 - Donovan & Kernighan
"《Go编程语言》Donovan & Kernighan，这是一本英文的Go语言基础教程，适合初学者，可提供给需要学习IT的朋友下载。" 在编程领域，Go语言，通常简称为Golang，由Google在2009年推出，是一种静态类型的、编译式的、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值