Go-知识泛型

Go-知识泛型

  • 1. 认识泛型
    • 1.1 不使用泛型
    • 1.2 使用泛型
  • 2. 泛型的特点
    • 2.1 函数泛化
    • 2.2 类型泛化
  • 3. 类型约束
    • 3.1 类型集合
    • 3.2 interface 类型集合
      • 3.2.1 内置interface类型集合
      • 3.2.2 自定义interface类型集合
        • 3.2.2.1 任意类型元素
        • 3.2.2.2 近似类型元素
        • 3.2.2.3 联合类型元素
      • 3.2.3 interface类型集合运算
      • 3.2.4 基于操作的类型集合
  • 4. 小例子
    • 4.1 map.Keys 获取map的全部key
    • 4.2 Set
    • 4.3 排序 Sort
  • 5. 总结

泛型是程序设计语言的一种风格或范式，允许程序员在编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。
Java,C++等多种编程语言都支持泛型，Go语言从1.18版本起也开始支持泛型。

1. 认识泛型

1.1 不使用泛型

实现两个函数对map的value值进行累加，一个是int64类型的值，一个是float64类型的值

func SumInt64(m map[string]int64) int64 {var sum int64for _, v := range m {sum += v}return sum
}func SumFloat64(m map[string]float64) float64 {var sum float64for _, v := range m {sum += v}return sum
}

接着使用两个函数

func TestSum(t *testing.T) {ints := map[string]int64{"one":   234,"two":   6755,"three": 78675,}floats := map[string]float64{"one":   123.456,"two":   7865.9658,"three": 87906.865,}t.Logf("sum ints : %v , floats : %v", SumInt64(ints), SumFloat64(floats))
}

执行如下：
在这里插入图片描述

实现同样的功能，就因为处理的数据类型不一样，就需要为每种类型编写类似的重复代码。

1.2 使用泛型

泛型函数，就是吧函数的参数和返回值“泛化”，使逻辑通用。 通用并不是对所有类型都使用，所以在声明泛型函数时，需要声明适用的“参数类型”(类型约束).

func SumValue[K comparable, V int64 | float64](m map[K]V) V {var sum Vfor _, v := range m {sum += v}return sum
}

SumValue泛型函数通过[K comparable, V int64|fload64]声明了两个类型参数K,V，供函数参数和返回值使用。
类型参数K的类型必须为comparable类型，因为被用作map的key值，在Go语言中map的key值必须是可比较的类型。
类型参数V的类型可以是int64或float64，在声明时使用|组合支持的类型。
普通参数m 表示一个泛化的map，相应的返回值也是一个泛化的类型。
使用：

func TestSumValue(t *testing.T) {ints := map[string]int64{"one":   234,"two":   6755,"three": 78675,}floats := map[string]float64{"one":   123.456,"two":   7865.9658,"three": 87906.865,}t.Logf("sum ints : %v , floats : %v", SumValue(ints), SumValue[string, float64](floats))
}

执行结果
在这里插入图片描述

在调用泛型函数的地方，编译器会将泛型函数实例化，即使用真实的类型来替换类型参数，在调用时有两种方式：

  • 隐式调用： 调用泛型函数时使用缺省类型参数，让编译器根据实际的参数进行推导。(SumValue(ints))
  • 显示调用： 调用泛型函数时显式的指明类型参数。(SumValuestring, float64)

需要注意的是，编译器之所以能够推导出参数类型是因为函数存在入参，编译器通过传入的变量和函数的参数声明可以推导出参数类型，但对于没有函数参数的泛型函数来说，编译器
无法进行推导，也就无法实例化泛型函数，此时必须显式地调用并指定类型参数。
比如：
在这里插入图片描述

就无法推导出来返回值的类型了
而且显式调用，必须全部指定，不能指定部分类型
在这里插入图片描述

2. 泛型的特点

泛型的英文表述为generic，即一般化，泛化，具体来讲就是函数和类型的泛化。在泛型被引入之前一个函数所能接收的参数类型及
所能处理的数据类型是确定的，但泛型函数却能接受和处理多种类型，对于类型也是同样的道理。
泛型主要包含三方面的内容：

  1. 函数的泛化
  2. 类型的泛化
  3. 接口的扩展

2.1 函数泛化

为了支持泛型，Go语言函数扩展为可以接受一个使用方括弧表示的类型参数；
func SumValue1[K comparable, V int64 | float64, T int64 | float64](m map[K]V) T
同普通的函数参数类似，类型参数中的每个参数也有一个类型，比如参数K,V的类型分别为 comparable(伴随泛型而引入的内置interface类型，表示可比类型)
和int64|float64(表示int64或float64)。
函数中的类型参数是可选的，没有类型参数的函数是传统的函数，带有类型参数的函数则是泛型函数。
即便Go 1.18 引入了泛型并且扩展了函数，但仍然保持兼容(在这里小小的谴责一下 python 和 scala )。
类型参数中的类型正式的名称是类型约束，用来约束类型的范围。 上面额函数可以接受多种类型的map为参数，考虑到所有的map的key的类型都是comparable类型，
那么只要一个map的值类型是int64或float64就能调用泛型函数。
比如： map[int]int64,map[int64]int64,map[float64]float64,...

2.2 类型泛化

泛型同样扩展了类型的表示方法，允许在创建自定义类型时也能接受一个使用方括弧表示的类型参数。
type arr[T int|int64] []T
声明arr类型，可以容纳int或者int64的切片。
这种声明中带有类型参数的类型被称为泛型类型。
泛型类型必须通过类型参数实例化后才可以使用。
var arrInt arr[int]
var arrInt64 arr[int64]
但是当实例化允许范围之外的类型时，会编译异常
在这里插入图片描述

在实例化一个泛型类型时，必须指定类型参数(编译器无法自动推导)

泛型类型同普通类型一样，同样允许定义方法，但是其类型必须带上类型参数：

func (a *arr[T]) add(x T) {*a = append(*a, x)
}
func TestArrAdd(t *testing.T) {var a arr[int]a.add(3)a.add(4)t.Logf("res : %v", a)
}

执行结果
在这里插入图片描述

未泛型类型定义方法时，必须指定类型参数，但参数名可以与泛型类型声明不同。

func (a *arr[X]) add1(x X) {*a = append(*a, x)
}

定义时使用T，但是在使用的时候，可以与声明时的名字不同。
如果方法体中并未使用类型参数，甚至可以使用_省略

func (a *arr[_]) add2(x _) {*a = append(*a, x)
}

但是不管是换个名字还是使用_并没有任何好处，反而降低了可读性。

3. 类型约束

无论函数和类型如何泛化，都需要类型参数来限定其泛化的范围，类型参数使用类型的集合表示范围。

3.1 类型集合

func SumValue1[K comparable, V int64 | float64, T int64 | float64](m map[K]V) T
该函数的类型参数中K的类型限定为comparable，V 的类型限定为int64或float64。
comparable是interface类型，int64|float64是组合类型，都代表一个类型集合，用于约束泛化的范围。
使用|来组合多个类型，从而形成一个类型集合。

3.2 interface 类型集合

在泛型特性被引入之前，interface仅表示一个方法集合，实现了该方法结合的所有类型都可认为实现了这个interface。
在泛型的设计中，对interface进行了扩展，interface将不在仅仅表示方法集合，它还可用于表示类型集合，同理，集合内所有类型都可认为实现了这个interface。

3.2.1 内置interface类型集合

comparable就是跟随泛型被引入的内置interface类型
在这里插入图片描述

除了comparable还有any。
comparable表示可比较类型的集合，仅能用于类型参数中。
any不仅在类型参数中表示任意类型的集合，还可以在非泛型场景中作为interface{}的别名使用。

3.2.2 自定义interface类型集合

除了内置的comparable和any两种类型可作为类型约束使用，用户还可以使用interface来定义类型集合。
在泛型之前，interface类型中仅允许包含方法或内嵌interface两种元素，引入泛型后，interface类型将允许使用另外三种元素以表示一个类型集合：

  1. 任意类型元素(如 int)
  2. 近似类型元素(使用表示法，如int)
  3. 联合类型元素(使用|表示法，如int|int64)

需要注意的是，如果interface类型中使用了这三种元素的任意一种，那么这个interface只能用于泛型的类型参数

3.2.2.1 任意类型元素

任意类型(包含interface类型)都可以出现在一个新的interface类型中，用于表示一个仅用于类型参数的集合

type Mint interface {int
}func addMint[M Mint](m1, m2 M) M {return m1 + m2
}
func TestMint(t *testing.T) {t.Log(addMint(3, 4))
}

在这里插入图片描述

此时该interface表示的数据集仅包含一种类型，且仅能用于泛型场景中的类型参数中。
interface类型和自定义类型都可以出现在interface中从而表示一个类型集合。
可以定义新的泛型interface，不能使用泛型interface定义interface 方法集合
interface泛型用于interface
在这里插入图片描述

但是不能将interface泛型用于interface方法集合
在这里插入图片描述

但是如果显式的声明了泛型，那么就可以使用
在这里插入图片描述

并且该interface的方法集合也能像之前一样实现
在这里插入图片描述

因为在定义interface泛型的时候，限定是int，所以只有int类型才算是实现了方法
在这里插入图片描述

这样来看，使用interface泛型类型，可以限定什么样的方法算是实现。

如果将float64加入到interface泛型中，那么float64的方法也算是实现
在这里插入图片描述

3.2.2.2 近似类型元素

在使用 interface声明类型集合时，可以使用~<type>来制定一组类型，只要其底层类型为同一类型即包含在这个集合中。
因为在Go中，可以通过type取别名，而泛型又时通用这个含义。
比如创建一个string的泛型函数，但是因为使用了type对string取了别名，结果别名类型就无法使用泛型函数。
近似类型元素就是可以让type取了别名的类型也能使用
不使用近似类型
在这里插入图片描述

使用近似类型
在这里插入图片描述

只要底层类型相同，就能使用泛型函数

需要注意的是，~之后的类型必须是某个底层类型，换句话说，一个类型的底层类型不是自身就不能使用~。
在这里插入图片描述

另外，interface 自身也不能用于定义近似类型集合，因为interface的底层类型并不确定。

3.2.2.3 联合类型元素

前面使用~定义的元素集合仅能包括一组底层类型一致的类型，又是可能需要联合多种类型，甚至联合多种底层类型一致的类型，此时可以用
|定义一个更宽泛的类型集合

type MInteger interface {int | int8 | int16 | int32 | int64
}

但是上述定义仅能支持底层类型，不支持别名
更进一步，可以把所有底层类型也包含进来

type MAnyInteger interface {~int | ~int8 | ~int16 | ~int32 | ~int64
}

这样即使是别名类型，也能支持。

3.2.3 interface类型集合运算

前面使用interface声明类型集合时，均使用一行代码制定一个集合(一个子集)，事实上interface支持按行制定多个自己和，这些自己和取交集形成最终的集合

type NewString interface {~stringstring
}

NewString的类型集合由两个子集组成，一个是所有底层类型为string的集合，另一个是string单一类型，两个子集取交集，最终的类型集合将只包含string单一类型
在这里插入图片描述

3.2.4 基于操作的类型集合

假设顶一个泛型函数来比较元素大小

type Ordered interface {~int|~int8|~int16|~int32|~int64|~uint|~uint8|~uint16|~uint32|~uint64|~float32|~float64|~string
}func Equals[T Ordered](a, b T) bool {if a == b {return true}return false
}

定义的Ordered泛型类型是全部可以使用==比较的底层类型，并且包含别名类型，泛型函数限定了Ordered泛型类型。
copmarable和Ordered类似，范围更大。

4. 小例子

4.1 map.Keys 获取map的全部key

将map中的所有key取出来，然后存入切片中返回

func Keys[K comparable, V any](m map[K]V) []K {res := make([]K, 0, len(m))for k, _ := range m {res = append(res, k)}return res
}

类型参数K被用于声明了一个泛型的切片，然后把遍历到的key添加到切片中并返回。
任意的map都能使用Keys泛型函数

func TestKeys(t *testing.T) {t.Log(Keys(map[string]struct{}{"one":   {},"tow":   {},"three": {},}))t.Log(Keys(map[int]int{1: 1,2: 2,3: 3,}))
}

在这里插入图片描述

4.2 Set

Set可以存储一组不重复的数据，广泛用于需要去重的场景。很多编程语言比如Java,C++都提供了相应的实现，但是在Go语言中并没有Set类型。
有了泛型可以自己实现了

// 定义 Set
type Set[T comparable] map[T]struct{}// 创建 Set
func MakeSet[T comparable]() Set[T] {return make(Set[T])
}// 添加元素
func (s Set[T]) Add(k T) {s[k] = struct{}{}
}// 删除元素
func (s Set[T]) Delete(k T) {delete(s, k)
}// 判断是否包含
func (s Set[T]) Contains(k T) bool {_, ok := s[k]return ok
}// 返回长度
func (s Set[T]) Len() int {return len(s)
}// 遍历
func (s Set[T]) Iterate(f func(T)) {for k := range s {f(k)}
}func TestSet(t *testing.T) {set := MakeSet[int]()set.Add(1)set.Add(2)set.Add(1)set.Add(3)t.Log(set.Len()) // 预期 3t.Log(set.Contains(2)) // 预期 trueset.Delete(1) t.Log(set.Len()) // 预期 2t.Log(set.Contains(1)) // 预期 falsesum := 0set.Iterate(func(i int) {sum += i})t.Log(sum) // 预期 5
}

在这里插入图片描述

使用泛型实现的Set可适用于任意的可比较类型，行为与其他语言实现的Set基本类似，但是只能函数调用，不能使用下标操作访问元素。
上面实现的Set底层使用一个map实现，并不是线程安全的，还可以进一步使用自定义扩展

type SyncSet[C comparable] struct {l sync.RWMutexm map[C]struct{}
}

在读操作的时候，加读锁，在写操作的时候加写锁。

4.3 排序 Sort

要对切片中的元素进行排序，在标准库提供sort.Slice之前，每种类型的切片都需要实现sort.Interface接口中的三个方法
在这里插入图片描述

然后使用sort.Sort方法进行排序，即便后来标准库中引入了sort.Slice，但是使用时仍然需要提供一个排序函数。
使用泛型实现一个针对切片的通用排序函数

type Ordered interface {~int | ~int8 | ~int16 | ~int32 | ~int64 |~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |~float32 | ~float64 |~string
}type orderSlice[O Ordered] []Ofunc (o orderSlice[O]) Len() int {return len(o)
}
func (o orderSlice[O]) Less(i, j int) bool {return o[i] < o[j]
}
func (o orderSlice[O]) Swap(i, j int) {o[i], o[j] = o[j], o[i]
}
func OrderSlice[O Ordered](s []O) {// s 被转换为 []Ordered 类型，也就是 orderSlice，然后排序// 因为 orderSlice已经实现了排序的接口，不需要额外实现了sort.Sort(orderSlice[O](s))
}
func TestOrder(t *testing.T) {is := []int{3, 4, 5, 1, 2}OrderSlice(is)t.Log(is)ss := []string{"he", "ww", "ss"}OrderSlice(ss)t.Log(ss)
}

在这里插入图片描述

使用泛型实现排序幻术也有一定的局限性，因为不容易处理复杂的符合类型，比如自定义的struct类型。

5. 总结

反形式衡量编程语言技术完备度的一个重要参考指标，但是也是一个比较争议的技术。
泛型的缺失导致开发者不得不编写重复的代码，或者编写相对通用但缺少类型安全的代码，甚至有些项目使用代码自动生成技术来摆脱编写
重复代码的烦恼，从这方面来看，Go确实需要泛型。
但是引入泛型也是有一定成本的，比如泛型的三个困局：

  • 没有泛型(C语言)会降低程序员的生产力，但不会增加语言的复杂度
  • 泛型会增加编译器的负担(C++)，可能会编译出很多冗余的代码，进而拖慢编译时间
  • 泛型会降低运行时的性能(Java)，避免编译大量冗余代码的后果是增加运行时的开销

Go语言早在1.17版本时就推出了试用版本，但在1.18中还是用了极大的篇幅说明泛型的种种风险。
https://golang.google.cn/doc/go1.18#generics

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/450311.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Windows上安装Go并配置环境变量(图文步骤)

Windows上安装Go并配置环境变量(图文步骤)

前言 1. 本文主要讲解的是在windows上安装Go语言的环境和配置环境变量&#xff1b; Go语言版本&#xff1a;1.23.2 Windows版本&#xff1a;win11&#xff08;win10通用&#xff09; 下载Go环境 下载go环境&#xff1a;Go下载官网链接(https://golang.google.cn/dl/) 等待…
阅读更多...
Windows的一些技巧

Windows的一些技巧

一、如何去掉桌面程序图标的小箭头 1、使用WIN + R 快捷键调出运行窗口 2、在运行 窗口输入 regedit，打开注册表编辑器 3、在注册表编辑器 中找到 HKEY_CLASSES_ROOT\lnkfile 4、在右侧窗格中找到 IsShortcut 项，右键 删除 二、WIN10如何打开图片查看器 1、使用WIN + R 快…
阅读更多...
kali——hping3的使用

kali——hping3的使用

目录 前言 ping测试 端口扫描 ​编辑 源IP伪造 修改TTL值 洪水攻击 ​编辑 前言 hping命令行工具主要用于构造和发送自定义的 TCP/IP 数据包。它是一个非常强大的工具&#xff0c;用于网络测试、安全审计和防火墙测试。 ping测试 hping3 -1 目标IP //此命令…
阅读更多...
Node.js基础与应用

Node.js基础与应用

目录 1.要求 2.创建第一个Node.js代码 2.1 安装 VSCode 和所需插件 2.2 安装 Node.js 和 Yarn 2.3 创建 Node.js 项目 2.3.1 在 VSCode 中打开一个新文件夹 2.3.2 初始化 Node.js 项目 2.3.3 安装 Express 2.4 编写 Node.js 应用 2.4.1 创建主文件 2.4.2 运行应用 …
阅读更多...
Golang | Leetcode Golang题解之第475题供暖器

Golang | Leetcode Golang题解之第475题供暖器

题目&#xff1a; 题解&#xff1a; func findRadius(houses, heaters []int) (ans int) {sort.Ints(houses)sort.Ints(heaters)j : 0for _, house : range houses {dis : abs(house - heaters[j])for j1 < len(heaters) && abs(house-heaters[j]) > abs(house-…
阅读更多...
【vue+printJs】前端打印, 自定义字体大小, 自定义样式, 封装共享样式

【vue+printJs】前端打印, 自定义字体大小, 自定义样式, 封装共享样式

效果示例 思维导图 目录 1,基本使用1, 依赖下载2, 页面导入3, 修改字体大小(可行但不推荐) 2, 自定义样式,字体大小1, 修改字体大小(推荐)2, 自定义样式3, 封装共享样式 3, 去除页面页脚内容4, 测试案例demo, 直接cv可用5, print-js的其他参数说明 1,基本使用 1, 依赖下载 …
阅读更多...
Java 小游戏《超级马里奥》

Java 小游戏《超级马里奥》

文章目录 一、效果展示二、代码编写1. 素材准备2. 创建窗口类3. 创建常量类4. 创建动作类5. 创建关卡类6. 创建障碍物类7. 创建马里奥类8. 编写程序入口 一、效果展示 二、代码编写 1. 素材准备 首先创建一个基本的 java 项目&#xff0c;并将本游戏需要用到的图片素材 image…
阅读更多...
小马识途海外媒体推广有何优势？

小马识途海外媒体推广有何优势？

互联网让地球变得像一个村子一样&#xff0c;信息可以瞬间变得人尽皆知&#xff0c;商品和服务也同样习惯了跨国合作。中国不少物美价廉的产品在世界各地都很受欢迎&#xff0c;国内小资群体对国外的服饰和美妆更是偏爱有加。小马识途营销顾问认为&#xff0c;中国品牌不出走国…
阅读更多...
“趋势买点”，智能捕捉市场底部的工具指标

“趋势买点”，智能捕捉市场底部的工具指标

“趋势买点”&#xff0c;智能捕捉市场底部的工具指标 分享的这个指标包含副图与主图&#xff0c;不含未来函数&#xff0c;旨在通过分析市场波动找到可靠的买点信号&#xff0c;以便在底部进行抄底操作。 "趋势买点"的副图信号作为判断市场底部的重要依据&#xff0…
阅读更多...
只想简单跑个 AI 大模型，却发现并不简单

只想简单跑个 AI 大模型，却发现并不简单

之前我用 Ollama 在本地跑大语言模型&#xff08;可以参考《AI LLM 利器 Ollama 架构和对话处理流程解析》&#xff09;。这次想再捣鼓点进阶操作&#xff0c;比如 fine-tuning。 我的想法是&#xff1a;既然有现成的大模型&#xff0c;为什么不自己整理些特定领域的数据集&am…
阅读更多...
6云图书管理系统-图书展示

6云图书管理系统-图书展示

1 /src/store中新增userInfo.js&#xff0c;用于保存用户的登录信息 import { defineStore } from "pinia" import { ref } from vueexport const userInfoStore defineStore(userInfo, () > {//1.定义用户信息const info ref({})const isAdmin ref(false)//2…
阅读更多...
css 仿微信朋友圈图片自适应九宫格

css 仿微信朋友圈图片自适应九宫格

不好用请移至评论区揍我 原创代码，请勿转载，谢谢！ 示例效果 1 ~ 5张图与5 ~ 9张图 代码实现 <view style="
阅读更多...
卸载Python

卸载Python

1、查看安装框架位置并删除 Sudo rm -rf /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8 2、查看应用并删除 在 /Applications/Python 3.x 看是否存在&#xff0c;如果存在并删除。 3、删除软连接 ls -l /usr/bin/py* 或 ls -…
阅读更多...
什么是分布式锁？Redis的分布式锁又是什么？

什么是分布式锁？Redis的分布式锁又是什么？

什么是分布式锁&#xff1f; 分布式锁是一种用于解决分布式系统中多节点对共享资源并发访问问题的机制。在分布式系统中&#xff0c;多个服务器实例或服务进程可能同时操作某个共享资源&#xff08;如数据库记录、缓存条目、文件等&#xff09;&#xff0c;导致数据不一致或竞…
阅读更多...
千鹿 AI：强大的抠图神器，让你的工作效率飙升99%

千鹿 AI：强大的抠图神器，让你的工作效率飙升99%

宝子们&#xff0c;今天一定要给大家分享一款超厉害的抠图工具 —— 千鹿 AI。千鹿 AI 用起来真的是极其方便&#xff0c;仅仅上传一张图片&#xff0c;短短几秒钟的时间&#xff0c;就能够获得一张边缘超级清晰的抠图成品&#xff0c;实在是令人惊叹。 鹿 AI 的厉害之处有很多…
阅读更多...
【Linux系统编程】环境基础开发工具使用

【Linux系统编程】环境基础开发工具使用

目录 1、Linux软件包管理器yum 1.1 什么是软件包 1.2 安装软件 1.3 查看软件包 1.4 卸载软件 2、Linux编辑器-vim 2.1 vim的概念 2.2 vim的基本操作 2.3 vim的配置 3、Linux编译器-gcc/g 3.1 gcc编译的过程​编辑​编辑​编辑 3.2 详解链接 动态链接 静态链接 4…
阅读更多...
二百六十九、Kettle——ClickHouse清洗ODS层原始数据增量导入到DWD层表中

二百六十九、Kettle——ClickHouse清洗ODS层原始数据增量导入到DWD层表中

一、目的 清洗ClickHouse的ODS层原始数据&#xff0c;增量导入到DWD层表中 二、实施步骤 2.1 newtime select( select create_time from hurys_jw.dwd_statistics order by create_time desc limit 1) as create_time 2.2 替换NULL值 2.3 clickhouse输入 2.4 字段选择 2.5 …
阅读更多...
UDP反射放大攻击防范手册

UDP反射放大攻击防范手册

UDP反射放大攻击是一种极具破坏力的恶意攻击手段。 一、UDP反射放大攻击的原理 UDP反射放大攻击主要利用了UDP协议的特性。攻击者会向互联网上大量的开放UDP服务的服务器发送伪造的请求数据包。这些请求数据包的源IP地址被篡改为目标受害者的IP地址。当服务器收到这些请求后&…
阅读更多...
『网络游戏』服务器启动逻辑【16】

『网络游戏』服务器启动逻辑【16】

新建Visual Studio工程命名为NetGameServer 重命名为ServerStart.cs 创建脚本&#xff1a; 编写脚本&#xff1a;ServerRoot.cs 编写脚本&#xff1a;ServerStart.cs 新建文件夹 调整脚本位置 新建文件夹 新建文件夹网络服务 创建脚本&#xff1a;NetSvc.cs 编写脚本&#xff1…
阅读更多...
【word】文章里的表格边框是双杠

【word】文章里的表格边框是双杠

日常小伙伴们遇到word里插入的表格&#xff0c;边框是双杠的&#xff0c;直接在边框和底纹里修改边框的样式就可以&#xff0c;但我今天遇到的这个有点特殊&#xff0c;先看看表格在word里的样式是怎么样&#xff0c;然后我们聊聊如何解决。 这个双杠不是边框和底纹的设置原因…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023