class

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 4, 2026 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func F取POST参数

func F取POST参数(r *http.Request, 参数名 string) string

F取POST参数 从 HTTP 请求中解析并获取 POST 表单参数值。

参数:

  • r: *http.Request
  • 参数名: POST 参数名称

返回:

  • string: 参数值,解析失败或不存在则返回空字符串

func F取查询参数

func F取查询参数(r *http.Request, 参数名 string) string

F取查询参数 从 HTTP 请求中获取 URL 查询参数值。

参数:

  • r: *http.Request
  • 参数名: 查询参数名称

返回:

  • string: 参数值,不存在则返回空字符串

func F响应HTML

func F响应HTML(w http.ResponseWriter, 状态码 int, html string)

F响应HTML 便捷方法:向客户端写入 HTML 响应。

参数:

  • w: http.ResponseWriter
  • 状态码: HTTP 状态码
  • html: HTML 内容

func F响应JSON

func F响应JSON(w http.ResponseWriter, 状态码 int, 数据 interface{})

F响应JSON 便捷方法:向客户端写入 JSON 响应。 自动设置 Content-Type 为 application/json。

参数:

  • w: http.ResponseWriter
  • 状态码: HTTP 状态码(如 200)
  • 数据: 要序列化为 JSON 的数据

func F响应文本

func F响应文本(w http.ResponseWriter, 状态码 int, 文本 string)

F响应文本 便捷方法:向客户端写入纯文本响应。

参数:

  • w: http.ResponseWriter
  • 状态码: HTTP 状态码
  • 文本: 要返回的文本内容

func F解析JSON请求体

func F解析JSON请求体(r *http.Request, 目标 interface{}) error

F解析JSON请求体 从 HTTP 请求体中解析 JSON 到目标对象。

参数:

  • r: *http.Request
  • 目标: 用于接收解析结果的对象指针

返回:

  • error: 解析失败时返回错误

Types

type L_HTTP服务端

type L_HTTP服务端 struct {
	// contains filtered or unexported fields
}

L_HTTP服务端 HTTP 服务端,基于标准库 net/http 封装,支持路由注册、中间件、静态文件服务。 提供中文 API 风格的 HTTP 服务器构建方法。

使用示例:

s := &class.L_HTTP服务端{}
s.T注册路由("GET", "/hello", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})
s.Q启动(8080)

func (*L_HTTP服务端) J静态文件服务

func (s *L_HTTP服务端) J静态文件服务(URL前缀 string, 本地目录 string)

J静态文件服务 注册静态文件服务,将指定目录映射到 URL 路径前缀。

参数:

  • URL前缀: URL 路径前缀(如 "/static/")
  • 本地目录: 本地文件目录路径(如 "./public")

func (*L_HTTP服务端) Q取启动地址

func (s *L_HTTP服务端) Q取启动地址() string

Q取启动地址 获取服务监听地址。

返回:

  • string: 监听地址

func (*L_HTTP服务端) Q启动

func (s *L_HTTP服务端) Q启动(端口 int) error

Q启动 启动 HTTP 服务端,监听指定端口。

参数:

  • 端口: 监听端口号(如 8080)

返回:

  • error: 启动失败时返回错误

func (*L_HTTP服务端) Q启动带地址

func (s *L_HTTP服务端) Q启动带地址(地址 string) error

Q启动带地址 启动 HTTP 服务端,指定完整监听地址。

参数:

  • 地址: 监听地址(如 ":8080" 或 "0.0.0.0:8080")

返回:

  • error: 启动失败时返回错误

func (*L_HTTP服务端) S是否运行中

func (s *L_HTTP服务端) S是否运行中() bool

S是否运行中 检查服务是否正在运行。

返回:

  • bool: true 表示运行中

func (*L_HTTP服务端) T停止

func (s *L_HTTP服务端) T停止() error

T停止 停止 HTTP 服务端,等待已有请求处理完毕(5秒超时)。

返回:

  • error: 停止失败时返回错误

func (*L_HTTP服务端) T注册路由

func (s *L_HTTP服务端) T注册路由(方法 string, 路径 string, 处理函数 http.HandlerFunc)

T注册路由 注册 HTTP 路由处理函数。

参数:

  • 方法: HTTP 方法(如 "GET", "POST", "PUT", "DELETE" 等)
  • 路径: URL 路径(如 "/api/hello")
  • 处理函数: 标准 http.HandlerFunc 处理函数

func (*L_HTTP服务端) T注册通用路由

func (s *L_HTTP服务端) T注册通用路由(路径 string, 处理函数 http.HandlerFunc)

T注册通用路由 注册不区分 HTTP 方法的通配路由。 所有 HTTP 方法匹配该路径时均触发处理函数。

参数:

  • 路径: URL 路径(如 "/hello")
  • 处理函数: 标准 http.HandlerFunc 处理函数

func (*L_HTTP服务端) Z中间件

func (s *L_HTTP服务端) Z中间件(中间件函数 func(http.HandlerFunc) http.HandlerFunc)

Z中间件 添加全局中间件函数。 中间件按添加顺序执行。

参数:

  • 中间件函数: 接受 http.HandlerFunc 返回 http.HandlerFunc 的包装函数

func (*L_HTTP服务端) Z中间件CORS

func (s *L_HTTP服务端) Z中间件CORS()

Z中间件CORS 快捷添加 CORS 跨域中间件,允许所有来源访问。 支持 GET/POST/PUT/DELETE/OPTIONS/PATCH 方法及常用请求头。

func (*L_HTTP服务端) Z中间件日志

func (s *L_HTTP服务端) Z中间件日志()

Z中间件日志 快捷添加请求日志中间件。 记录每个请求的方法、路径、耗时。

type L_TCP客户端

type L_TCP客户端 struct {
	S收到数据回调 func(数据 []byte)
	D断开回调   func()
	// contains filtered or unexported fields
}

L_TCP客户端 TCP 客户端,支持连接服务端、收发数据。 使用 bufio 以换行符作为消息分隔符。

使用示例:

c := &class.L_TCP客户端{}
c.S收到数据回调 = func(数据 []byte) { fmt.Println(string(数据)) }
c.L连接("127.0.0.1:8888")
c.F发送文本("hello")

func (*L_TCP客户端) D断开

func (c *L_TCP客户端) D断开()

D断开 断开与 TCP 服务端的连接。

func (*L_TCP客户端) F发送数据

func (c *L_TCP客户端) F发送数据(数据 []byte) error

F发送数据 向服务端发送数据(自动追加换行符)。

参数:

  • 数据: 要发送的字节数据

返回:

  • error: 发送失败时返回错误

func (*L_TCP客户端) F发送文本

func (c *L_TCP客户端) F发送文本(文本 string) error

F发送文本 向服务端发送文本数据。

参数:

  • 文本: 要发送的文本

返回:

  • error: 发送失败时返回错误

func (*L_TCP客户端) L连接

func (c *L_TCP客户端) L连接(地址 string) error

L连接 连接到 TCP 服务端。 连接成功后启动接收 goroutine,通过 S收到数据回调 通知上层。

参数:

  • 地址: 服务端地址(格式 "IP:端口",如 "127.0.0.1:8888")

返回:

  • error: 连接失败时返回错误

func (*L_TCP客户端) Q取本地地址

func (c *L_TCP客户端) Q取本地地址() string

Q取本地地址 获取本地连接地址。

返回:

  • string: 本地地址

func (*L_TCP客户端) S是否已连接

func (c *L_TCP客户端) S是否已连接() bool

S是否已连接 检查是否已连接服务端。

返回:

  • bool: true 表示已连接

type L_TCP服务端

type L_TCP服务端 struct {
	S收到数据回调  func(客户端地址 string, 数据 []byte)
	K客户端连接回调 func(客户端地址 string)
	K客户端断开回调 func(客户端地址 string)
	// contains filtered or unexported fields
}

L_TCP服务端 TCP 服务端,支持多客户端并发连接、消息收发和广播。 基于 net.ListenTCP 实现,每个客户端连接在独立 goroutine 中处理。

使用示例:

s := &class.L_TCP服务端{}
s.S收到数据回调 = func(客户端地址 string, 数据 []byte) {
    fmt.Println("收到:", string(数据))
}
s.Q启动(8888)

func (*L_TCP服务端) F发送数据

func (s *L_TCP服务端) F发送数据(客户端地址 string, 数据 []byte) error

F发送数据 向指定客户端发送数据(自动追加换行符作为分隔符)。

参数:

  • 客户端地址: 客户端地址(如 "192.168.1.1:12345")
  • 数据: 要发送的字节数据

返回:

  • error: 发送失败时返回错误

func (*L_TCP服务端) F发送文本

func (s *L_TCP服务端) F发送文本(客户端地址 string, 文本 string) error

F发送文本 向指定客户端发送文本数据。

参数:

  • 客户端地址: 客户端地址
  • 文本: 要发送的文本

返回:

  • error: 发送失败时返回错误

func (*L_TCP服务端) G广播数据

func (s *L_TCP服务端) G广播数据(数据 []byte)

G广播数据 向所有已连接客户端广播数据。

参数:

  • 数据: 要广播的字节数据

func (*L_TCP服务端) G广播文本

func (s *L_TCP服务端) G广播文本(文本 string)

G广播文本 向所有已连接客户端广播文本。

参数:

  • 文本: 要广播的文本

func (*L_TCP服务端) Q取客户端列表

func (s *L_TCP服务端) Q取客户端列表() []string

Q取客户端列表 获取所有已连接客户端的地址列表。

返回:

  • []string: 客户端地址列表

func (*L_TCP服务端) Q取客户端数量

func (s *L_TCP服务端) Q取客户端数量() int

Q取客户端数量 获取当前连接的客户端数量。

返回:

  • int: 客户端数量

func (*L_TCP服务端) Q启动

func (s *L_TCP服务端) Q启动(端口 int) error

Q启动 启动 TCP 服务端,监听指定端口。 每个客户端连接在独立 goroutine 中处理,通过回调函数通知上层。

参数:

  • 端口: 监听的端口号(如 8888)

返回:

  • error: 启动失败时返回错误

func (*L_TCP服务端) T停止

func (s *L_TCP服务端) T停止()

T停止 停止 TCP 服务端,关闭所有连接。

type L_WS客户端

type L_WS客户端 struct {
	S收到文本回调 func(文本 string)
	S收到字节回调 func(数据 []byte)
	D断开回调   func()
	// contains filtered or unexported fields
}

L_WS客户端 WebSocket 客户端,支持连接服务端、收发文本和二进制消息。

使用示例:

c := &class.L_WS客户端{}
c.S收到文本回调 = func(文本 string) { fmt.Println(文本) }
c.L连接("ws://127.0.0.1:8080/ws")
c.F发送文本("hello")

func (*L_WS客户端) D断开

func (c *L_WS客户端) D断开()

D断开 断开与 WebSocket 服务端的连接。

func (*L_WS客户端) F发送JSON

func (c *L_WS客户端) F发送JSON(数据 interface{}) error

F发送JSON 向服务端发送 JSON 格式消息(自动序列化)。

参数:

  • 数据: 要发送的数据(将自动 JSON 序列化)

返回:

  • error: 发送失败时返回错误

func (*L_WS客户端) F发送字节

func (c *L_WS客户端) F发送字节(数据 []byte) error

F发送字节 向服务端发送二进制消息。

参数:

  • 数据: 要发送的字节数据

返回:

  • error: 发送失败时返回错误

func (*L_WS客户端) F发送文本

func (c *L_WS客户端) F发送文本(文本 string) error

F发送文本 向服务端发送文本消息。

参数:

  • 文本: 要发送的文本

返回:

  • error: 发送失败时返回错误

func (*L_WS客户端) L连接

func (c *L_WS客户端) L连接(URL string) error

L连接 连接到 WebSocket 服务端。 连接成功后启动接收 goroutine,通过回调函数通知上层。

参数:

  • URL: WebSocket 地址(如 "ws://127.0.0.1:8080/ws")

返回:

  • error: 连接失败时返回错误

func (*L_WS客户端) Q取远程地址

func (c *L_WS客户端) Q取远程地址() string

Q取远程地址 获取远程服务端地址。

返回:

  • string: 远程地址

func (*L_WS客户端) S是否已连接

func (c *L_WS客户端) S是否已连接() bool

S是否已连接 检查是否已连接到服务端。

返回:

  • bool: true 表示已连接

type L_WS服务端

type L_WS服务端 struct {
	S收到文本回调  func(客户端ID string, 文本 string)
	S收到字节回调  func(客户端ID string, 数据 []byte)
	K客户端连接回调 func(客户端ID string)
	K客户端断开回调 func(客户端ID string)
	// contains filtered or unexported fields
}

L_WS服务端 WebSocket 服务端,支持多客户端并发连接、文本/二进制消息收发和广播。 基于 gorilla/websocket 库实现,可同时处理文本和二进制消息。

使用示例:

s := &class.L_WS服务端{}
s.S收到文本回调 = func(客户端ID string, 文本 string) { fmt.Println("收到:", 文本) }
s.Q启动(8080, "/ws")

func (*L_WS服务端) F发送字节

func (s *L_WS服务端) F发送字节(客户端ID string, 数据 []byte) error

F发送字节 向指定客户端发送二进制消息。

参数:

  • 客户端ID: 客户端的远程地址标识
  • 数据: 要发送的字节数据

返回:

  • error: 发送失败时返回错误

func (*L_WS服务端) F发送文本

func (s *L_WS服务端) F发送文本(客户端ID string, 文本 string) error

F发送文本 向指定客户端发送文本消息。

参数:

  • 客户端ID: 客户端的远程地址标识
  • 文本: 要发送的文本

返回:

  • error: 发送失败时返回错误

func (*L_WS服务端) G广播字节

func (s *L_WS服务端) G广播字节(数据 []byte)

G广播字节 向所有已连接客户端广播二进制消息。

参数:

  • 数据: 要广播的字节数据

func (*L_WS服务端) G广播文本

func (s *L_WS服务端) G广播文本(文本 string)

G广播文本 向所有已连接客户端广播文本消息。

参数:

  • 文本: 要广播的文本

func (*L_WS服务端) Q取客户端列表

func (s *L_WS服务端) Q取客户端列表() []string

Q取客户端列表 获取所有已连接客户端的 ID 列表。

返回:

  • []string: 客户端 ID 列表

func (*L_WS服务端) Q取客户端数量

func (s *L_WS服务端) Q取客户端数量() int

Q取客户端数量 获取当前连接的客户端数量。

返回:

  • int: 客户端数量

func (*L_WS服务端) Q启动

func (s *L_WS服务端) Q启动(端口 int, 路径 string) error

Q启动 启动 WebSocket 服务端,监听指定端口和路径。 客户端连接 ws://host:port/path 即可建立 WebSocket 连接。

参数:

  • 端口: 监听端口号(如 8080)
  • 路径: WebSocket 路径(如 "/ws")

返回:

  • error: 启动失败时返回错误

func (*L_WS服务端) Q启动带地址

func (s *L_WS服务端) Q启动带地址(地址 string, 路径 string) error

Q启动带地址 启动 WebSocket 服务端,指定完整监听地址和路径。

参数:

  • 地址: 监听地址(如 ":8080" 或 "0.0.0.0:8080")
  • 路径: WebSocket 路径(如 "/ws")

返回:

  • error: 启动失败时返回错误

func (*L_WS服务端) T停止

func (s *L_WS服务端) T停止()

T停止 停止 WebSocket 服务端,关闭所有连接。

type L_临界许可

type L_临界许可 struct {
	// contains filtered or unexported fields
}

L_临界许可 互斥锁封装,用于保护临界区代码。 基于 sync.Mutex 实现,确保同一时刻只有一个 goroutine 进入临界区。

使用示例:

lock := &L_临界许可{}
lock.J进入许可区()
// 临界区代码,同一时刻只有一个 goroutine 执行
lock.T退出许可区()

func (*L_临界许可) C尝试进入

func (l *L_临界许可) C尝试进入() bool

C尝试进入 尝试获取互斥锁而不阻塞。 如果锁当前可用则获取并返回 true,否则立即返回 false。

返回:

  • bool: true 表示成功获取锁,false 表示锁已被占用

func (*L_临界许可) J进入许可区

func (l *L_临界许可) J进入许可区()

J进入许可区 获取互斥锁,进入临界区。 如果锁已被其他 goroutine 持有,则阻塞等待。 必须与 T退出许可区 配对使用,否则会导致死锁。

func (*L_临界许可) T退出许可区

func (l *L_临界许可) T退出许可区()

T退出许可区 释放互斥锁,退出临界区。 必须与 J进入许可区 配对使用。

type L_正则表达式

type L_正则表达式 struct {
	Count          int
	SubmatchCount2 int
	// contains filtered or unexported fields
}

L_正则表达式 正则表达式封装类,提供正则匹配和子表达式提取功能。 创建时编译正则表达式并执行匹配,后续可通过方法获取匹配结果。

使用示例:

re, ok := New正则表达式类(`(\d+)-(\d+)`, "abc 123-456 def")
if ok {
    count := re.Q取匹配数量()
    text := re.Q取匹配文本(0)
    sub := re.Q取子匹配文本(0, 1)
}

func New正则表达式类

func New正则表达式类(正则表达式文本 string, 被搜索的文本 string) (*L_正则表达式, bool)

New正则表达式类 创建并初始化正则表达式对象。 编译正则表达式文本,并在被搜索文本中执行匹配。

参数:

  • 正则表达式文本: 正则表达式模式字符串
  • 被搜索的文本: 要执行匹配的目标文本

返回:

  • *L_正则表达式: 正则表达式对象
  • bool: true 表示至少有一个匹配,false 表示无匹配

func (*L_正则表达式) E创建

func (this *L_正则表达式) E创建(正则表达式文本 string, 被搜索的文本 string) bool

E创建 编译正则表达式并执行匹配。 如果匹配成功,Count 和 SubmatchCount2 会被赋值。

参数:

  • 正则表达式文本: 正则表达式模式字符串
  • 被搜索的文本: 要执行匹配的目标文本

返回:

  • bool: true 表示至少有一个匹配,false 表示无匹配

func (*L_正则表达式) GetResult

func (this *L_正则表达式) GetResult() [][]string

GetResult 获取所有匹配结果的原始二维字符串数组。 外层为匹配索引,内层为子表达式索引。

返回:

  • [][]string: 所有匹配结果

func (*L_正则表达式) Q取匹配数量

func (this *L_正则表达式) Q取匹配数量() int

Q取匹配数量 获取正则匹配到的结果数量。

返回:

  • int: 匹配到的结果数量

func (*L_正则表达式) Q取匹配文本

func (this *L_正则表达式) Q取匹配文本(匹配索引 int) string

Q取匹配文本 获取指定索引的完整匹配文本。 索引 0 表示第一个匹配结果的完整文本。

参数:

  • 匹配索引: 匹配结果的索引(从 0 开始)

返回:

  • string: 完整匹配文本;索引越界时可能 panic

func (*L_正则表达式) Q取子匹配数量

func (this *L_正则表达式) Q取子匹配数量() int

Q取子匹配数量 获取每个匹配结果中子表达式的数量(含完整匹配)。

返回:

  • int: 子表达式数量

func (*L_正则表达式) Q取子匹配文本

func (this *L_正则表达式) Q取子匹配文本(匹配索引 int, 子表达式索引 int) string

Q取子匹配文本 获取指定匹配结果中某个子表达式的匹配文本。 子表达式索引 0 为完整匹配,1 为第一个捕获组,以此类推。

参数:

  • 匹配索引: 匹配结果的索引(从 0 开始)
  • 子表达式索引: 子表达式的索引(从 0 开始,0 为完整匹配)

返回:

  • string: 子匹配文本;索引越界时返回空串

type L_读写锁

type L_读写锁 struct {
	// contains filtered or unexported fields
}

L_读写锁 读写锁封装,基于 sync.RWMutex 实现。 读共享:多个 goroutine 可以同时获取读锁,适合读多写少的场景。 写独享:写锁会阻塞所有读锁和其他写锁,保证数据一致性。

使用示例:

lock := &L_读写锁{}
lock.K开始读()
// 读取共享数据...
lock.J结束读()
lock.K开始写()
// 修改共享数据...
lock.J结束写()

func (*L_读写锁) J结束写

func (l *L_读写锁) J结束写()

J结束写 释放写锁。 必须与 K开始写 配对使用,否则会导致死锁。

func (*L_读写锁) J结束读

func (l *L_读写锁) J结束读()

J结束读 释放读锁。 必须与 K开始读 配对使用,否则会导致死锁。

func (*L_读写锁) K开始写

func (l *L_读写锁) K开始写()

K开始写 获取写锁。 写锁是独占的,获取写锁时会阻塞所有读锁和其他写锁。

func (*L_读写锁) K开始读

func (l *L_读写锁) K开始读()

K开始读 获取读锁。 多个 goroutine 可以同时持有读锁,但写锁被持有时会阻塞。

type L_队列

type L_队列 struct {
	// contains filtered or unexported fields
}

L_队列 先入先出(FIFO)队列实现,线程安全。 基于 container/list 双向链表,使用互斥锁保证并发安全。 元素类型为 interface{},可存储任意类型的值。

使用示例:

q := &L_队列{}
q.Init()
q.J加入队列("hello")
val, ok := q.T弹出队列()

func (*L_队列) Dump

func (q *L_队列) Dump()

Dump 打印队列中所有元素的内容,用于调试。 从队首到队尾依次输出,格式为 "item: <value>"。

func (*L_队列) Init

func (j *L_队列) Init()

Init 初始化队列,清空所有已有数据。

func (*L_队列) J加入队列

func (q *L_队列) J加入队列(v interface{}) int

J加入队列 将元素加入队列尾部,返回当前队列长度。

参数:

  • v: 要加入队列的元素,类型为 interface{}

返回:

  • int: 加入后队列中的元素数量

func (*L_队列) Q取队列长度

func (q *L_队列) Q取队列长度() int

Q取队列长度 获取队列中当前元素的数量。

返回:

  • int: 队列长度

func (*L_队列) Q清空队列

func (q *L_队列) Q清空队列() interface{}

Q清空队列 清空队列中的所有元素。

返回:

  • interface{}: 内部 list.Init() 的返回值

func (*L_队列) T弹出队列

func (q *L_队列) T弹出队列() (interface{}, bool)

T弹出队列 从队列头部弹出一个元素(先进先出)。

返回:

  • interface{}: 弹出的元素值;队列为空时返回 nil
  • bool: true 表示成功弹出,false 表示队列为空

func (*L_队列) T弹出队列整数

func (q *L_队列) T弹出队列整数(值 *int) bool

T弹出队列整数 从队列头部弹出一个整数类型的元素。 如果队列为空或元素不是 int 类型,返回 false。

参数:

  • 值: 用于接收弹出整数的指针

返回:

  • bool: true 表示成功弹出整数,false 表示队列为空或类型不匹配

func (*L_队列) T弹出队列文本

func (q *L_队列) T弹出队列文本(值 *string) bool

T弹出队列文本 从队列头部弹出一个字符串类型的元素。 如果队列为空或元素不是字符串类型,返回 false。

参数:

  • 值: 用于接收弹出字符串的指针

返回:

  • bool: true 表示成功弹出字符串,false 表示队列为空或类型不匹配

type L_队列泛型

type L_队列泛型[T any] struct {
	// contains filtered or unexported fields
}

L_队列泛型 线程安全的泛型队列实现。 基于 container/list 双向链表,使用互斥锁保证并发安全。 支持任意类型的元素,遵循先进先出(FIFO)原则。

使用示例:

q := &L_队列泛型[int]{}
q.Init()
q.J加入队列(42)
val, ok := q.T弹出队列()

func (*L_队列泛型[T]) Dump

func (q *L_队列泛型[T]) Dump()

Dump 打印队列中所有元素的内容,用于调试。 从队首到队尾依次输出,格式为 "item: <value>"。

func (*L_队列泛型[T]) Init

func (q *L_队列泛型[T]) Init()

Init 初始化队列,清空所有已有数据。 在首次使用前调用,确保队列处于干净状态。

func (*L_队列泛型[T]) J加入队列

func (q *L_队列泛型[T]) J加入队列(v T) int

J加入队列 将元素加入队列尾部,返回当前队列长度。

参数:

  • v: 要加入队列的元素

返回:

  • int: 加入后队列中的元素数量

func (*L_队列泛型[T]) Q取队列长度

func (q *L_队列泛型[T]) Q取队列长度() int

Q取队列长度 获取队列中当前元素的数量。

返回:

  • int: 队列长度

func (*L_队列泛型[T]) Q清空队列

func (q *L_队列泛型[T]) Q清空队列()

Q清空队列 清空队列中的所有元素。

func (*L_队列泛型[T]) T弹出队列

func (q *L_队列泛型[T]) T弹出队列() (T, bool)

T弹出队列 从队列头部弹出一个元素(先进先出)。

返回:

  • T: 弹出的元素值;队列为空时返回类型零值
  • bool: true 表示成功弹出,false 表示队列为空

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL