跳到主要内容

str

str 库是 yaklang 的字符串处理超集（约 165 个函数），在标准字符串操作之外，深度集成了网络/HTTP/安全相关的解析与判定工具，是几乎所有脚本都会用到的基础库。

典型使用场景：

  • 基础操作：str.Split / str.Join / str.Trim* / str.Replace / str.Contains / str.HasPrefix / str.ToLower / str.f（格式化），str.RandStr / str.Random 生成随机串。
  • 目标解析：str.ParseStringToHosts / str.ParseStringToPorts / str.ParseStringToUrls / str.ParseStringToCClassHosts / str.HostPort 把目标描述解析为可扫描列表。
  • HTTP 处理：str.ParseStringToHTTPRequest / str.SplitHTTPHeadersAndBodyFromPacket / str.ExtractBodyFromHTTPResponseRaw / str.FixHTTPRequest / str.ExtractTitle / str.ExtractURLFromHTTPRequestRaw。
  • 抽取与判定：str.ExtractDomain / str.ExtractRootDomain / str.ExtractChineseIDCards、str.IsIPv4 / str.IsHttpURL / str.IsJsonResponse / str.IsPasswordField 等大量 Is* 判定。
  • 相似度与匹配：str.CalcSimilarity / str.CalcSimHash / str.CalcSSDeep 模糊比对，str.MatchAnyOfGlob / str.MatchAllOfRegexp 批量匹配，str.Grok 结构化解析，str.VersionCompare 版本比较。

与相邻库的关系：str 是纯计算基础库，与 re（正则）、codec（编解码）、json（结构化）协同；它内置的目标/HTTP 解析能力让它在扫描类脚本中尤为关键。

共 165 个函数

函数索引​

函数参数返回值说明
str.AddPrefixLineNumberi anystring为输入文本 i 的每一行加上行号前缀，并返回处理后的字符串。
str.AddPrefixLineNumberToReaderi anyio.Reader读取 i（字符串或 io.Reader）中的文本，为每一行加上行号前缀，并返回一个新的 io.Reader。
str.CalcOrdinaryTokenCounttext stringint计算文本的 token 数量（基于 Qwen BPE 词表），但不对特殊 token 做识别处理。
str.CalcSSDeepraw []bytestring计算并返回一段文本的模糊哈希值
str.CalcSimHashraw []byteuint64计算并返回一段文本的 SimHash 值
str.CalcTokenCounttext stringint计算文本的 token 数量（基于 Qwen BPE 词表），会识别特殊 token（如 <|im_start|>、<|im_end|>、<|endoftext|>）。
str.Comparea string, b stringint按照ascii码表顺序逐个比较字符串a和b中的每个字符，如果a==b，则返回0，如果a<b，则返回-1，如果a>b，则返回1
str.Containss string, substr stringbool判断字符串s是否包含substr
str.ContainsAnys string, chars stringbool判断字符串s是否包含chars中的任意字符
str.Counts string, substr stringint返回字符串s中substr出现的次数
str.Cuts string, sep stringstring, string, bool在 s 中查找第一个 sep，并以其为界把 s 切分为前后两部分。如果找到 sep，则 found 为 true。
str.CutPrefixs string, prefix stringstring, bool如果 s 以 prefix 开头，则返回去除该前缀后的字符串与 true，否则返回原字符串与 false。
str.CutSuffixs string, suffix stringstring, bool如果 s 以 suffix 结尾，则返回去除该后缀后的字符串与 true，否则返回原字符串与 false。
str.DecodeTokenstokens []intstring将 Qwen BPE token id 列表解码还原为文本，是 EncodeTokens 的逆操作。
str.EncodeOrdinaryTokenstext string[]int将文本编码为 Qwen BPE token id 列表（不识别特殊 token）。
str.EncodeTokenstext string[]int将文本编码为 Qwen BPE token id 列表（会识别特殊 token）。
str.EndsWiths string, suffix stringbool/ HasSuffix 判断字符串s是否以suffix结尾
str.EqualFolds string, t stringbool判断字符串s和t是否相等，忽略大小写
str.ExtractBodyFromHTTPResponseRawres []byte[]byte, error从原始 HTTP 响应报文中提取 body
str.ExtractChineseIDCardsi any[]string尝试将传入的参数转换为字符串，然后提取字符串中的身份证号
str.ExtractHostraw stringstring尝试从字符串中解析出host和port，并返回host
str.ExtractHostPortraw stringstring尝试从字符串中解析出host和port，并返回host:port
str.ExtractJsoni any[]string尝试提取字符串中的 JSON 并进行修复, 返回中的元素都是Object
str.ExtractJsonWithRawi any[]string, []string尝试提取字符串中的 JSON 并返回，第一个返回值返回经过修复后的JSON字符串数组，第二个返回值返回原始JSON字符串数组(如果修复失败)
str.ExtractRootDomaini any[]string尝试提取字符串中的根域名并返回
str.ExtractStrContextraw string, res []string[]string从字符串raw中提取一组关键字res上下文的内容，上下文的长度是512个字符确定。
str.ExtractTitlei anystring尝试将传入的字符串进行HTML解析并提取其中的标题(title标签)返回
str.ExtractURLFromHTTPRequestr *http.Request, https bool*url.URL, error从 HTTP 请求结构体中提取 URL，返回URL结构体与错误
str.ExtractURLFromHTTPRequestRawreq []byte, isHttps bool*url.URL, error从原始 HTTP 请求报文中提取 URL，返回URL结构体与错误
str.Fieldss string[]string返回将字符串s按照空白字符（'\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0）分割的字符串切片
str.FilterPortssourcePorts string, excludePorts string[]int接受两个字符串形式的端口列表作为参数，返回一个新的端口列表，
str.FixHTTPRequestraw []byte[]byte尝试对传入的HTTP请求报文进行修复，并返回修复后的请求
str.FixHTTPResponseraw []byte[]byte, []byte, error尝试对传入的响应进行修复，并返回修复后的响应，响应体和错误
str.Grokline string, rule stringGrokResult使用 Grok 规则解析字符串并返回解析结果（导出名为 re.Grok）
str.HasPrefixs string, prefix stringboolStartsWith / HasPrefix 判断字符串s是否以prefix开头
str.HasSuffixs string, suffix stringboolEndsWith / HasSuffix 判断字符串s是否以suffix结尾
str.HostPorthost string, port anystring将 host 和 port 拼接成 host:port 的形式
str.IPv4ToCClassNetworks stringstring, error尝试从一个 IPv4 地址中获取 C 类网络地址，并返回错误
str.Indexs string, substr stringint返回字符串s中substr第一次出现的位置的索引，如果字符串中不存在substr，则返回-1
str.IndexAnys string, chars stringint返回字符串s中chars任意字符首次出现的位置的索引，如果字符串中不存在chars，则返回-1
str.IndexBytes string, c byteint返回字符串s中第一个等于c的字符的索引，如果字符串中不存在c，则返回-1
str.Intersectx []string, y []string[]string/ IntersectString 返回两个字符串切片之间的交集
str.IntersectStringx []string, y []string[]stringIntersect / IntersectString 返回两个字符串切片之间的交集
str.IsAlNumi anyboolIsAlphaNum / IsAlNum 尝试将传入的参数转换为字符串，然后判断其是否都由英文字母和数字组成
str.IsAllVisibleASCIIs stringbool判断字符串是否全部由可见的 ASCII 字符（0x20~0x7E）组成
str.IsAlphai anybool尝试将传入的参数转换为字符串，然后判断其是否都由英文字母组成
str.IsAlphaNumi anybool/ IsAlNum 尝试将传入的参数转换为字符串，然后判断其是否都由英文字母和数字组成
str.IsBase64Valuei anybool尝试将传入的参数转换为字符串，然后猜测其是否是 Base64 编码的数据
str.IsCaptchaFieldi anybool尝试将传入的参数转换为字符串，然后猜测其是否是验证码字段
str.IsDigiti anybool尝试将传入的参数转换为字符串，然后判断其是否都由数字组成
str.IsHtmlResponsei anybool猜测传入的参数是否为原始 HTTP 响应报文
str.IsHttpURLv anybool根据 value 猜测是否是一个完整 url，目前只关心 http 和 https
str.IsIPv4raw stringbool判断字符串是否是 IPv4 地址
str.IsIPv6raw stringbool判断字符串是否是 IPv6 地址
str.IsJSONPParamkey string, value stringbool根据传入的参数名和参数值猜测是否为 JSONP 参数
str.IsJsonResponsei anybool尝试将传入的参数转换为字符串，然后猜测传入的参数是否为 JSON 格式的原始 HTTP 响应报文，这是通过判断Content-Type请求头实现的
str.IsMD5Valuei anybool尝试将传入的参数转换为字符串，然后猜测其是否是 MD5 编码的数据
str.IsPasswordFieldi anybool尝试将传入的参数转换为字符串，然后猜测其是否是 password 字段
str.IsPlainBase64Valuei anybool尝试将传入的参数转换为字符串，然后猜测其是否是 Base64 编码的数据，它相比于 IsBase64Value 多了一层判断，即判断 base64 解码后的数据是否为可见字符串
str.IsRedirectParamkey string, value stringbool根据传入的参数名和参数值猜测是否为重定向参数
str.IsSQLColumnFieldi anybool尝试将传入的参数转换为字符串，然后猜测其是否是 SQL 查询字段
str.IsSensitiveJsoni anybool尝试将传入的参数转换为字符串，然后猜测其是否为敏感的 JSON 数据
str.IsSensitiveTokenFieldi anybool尝试将传入的参数转换为字符串，然后猜测其是否是 token 字段
str.IsServerErrori anybool猜测传入的参数是否为服务器错误
str.IsSha256Valuei anybool尝试将传入的参数转换为字符串，然后猜测其是否是 SHA256 编码的数据
str.IsStrongPasswords stringbool判断字符串是否为强密码，强密码的定义为：长度大于8，同时包含特殊字符、小写字母、大写字母、数字
str.IsUrlParamkey string, value stringbool根据传入的参数名和参数值猜测是否为 URL 参数
str.IsUrlPathv anybool根据 value 猜测是否是一个 url path
str.IsUsernameFieldi anybool尝试将传入的参数转换为字符串，然后猜测其是否是 username 字段
str.IsXmlParamkey string, value stringbool根据传入的参数名和参数值猜测是否为 XML 参数
str.IsXmlRequesti anybool猜测传入的参数是否为请求头是 XML 格式的原始 HTTP 请求报文
str.IsXmlValuei anybool尝试将传入的参数转换为字符串，然后猜测其是否是 XML 格式的数据
str.Joini any, d anystring将i中的元素用d连接，如果传入的参数不是字符串，会自动将其转为字符串，再将其用d连接。如果连接失败，则会返回i的字符串形式。
str.JsonStringDecoderaw stringstring解码一个 JSON 字符串值（一次性版本），去掉首尾引号并还原转义（\n、\t、\uXXXX、\xNN 等），
str.JsonToMapline stringmap[string]any将 json 字符串 line 解析为 map，保留嵌套结构（对象/数组不会被转为字符串）
str.JsonToMapListline string[]map[string]any将 json 字符串 line 解析为 map 列表，保留嵌套结构（对象/数组不会被转为字符串）
str.LastIndexs string, substr stringint返回字符串s中substr最后一次出现的位置的索引，如果字符串中不存在substr，则返回-1
str.LastIndexAnys string, chars stringint返回字符串s中chars任意字符最后一次出现的位置的索引，如果字符串中不存在chars，则返回-1
str.LastIndexBytes string, c byteint返回字符串s中最后一个等于c的字符的索引，如果字符串中不存在c，则返回-1
str.LowerAndTrimSpaceraw stringstring将字符串raw转换为小写并去除前后空白字符
str.MergeUrlFromHTTPRequestrawRequest []byte, target string, isHttps boolstring将传入的 target 与 原始 HTTP 请求报文中的 URL 进行合并，并返回合并后的 URL
str.NewFilter-*StringFilter创建一个默认的字符串布谷鸟过滤器，布谷鸟过滤器用于判断一个元素是否在一个集合中，它存在极低的假阳性（即说存在的元素实际上不存在），通常这个集合中的元素数量非常大才会使用布谷鸟过滤器。
str.NewJSONStringReaderr io.Readerio.Reader包装一个 JSON 字符串值的 Reader，流式解码其中的转义（\n、\t、\uXXXX、\xNN 等），
str.NewReaders string*strings.Reader基于字符串 s 创建一个只读的 io.Reader，可用于需要 reader 的接口。
str.NewUTF8Readerr io.Readerio.Reader包装一个 Reader，使每次读取都只返回完整的 UTF-8 字符，
str.ParamsGetOri any, key string, defaultValue stringstring从 map 中获取 key 对应的值，如果不存在则返回 defaultValue。支持 map[string]string 与 map[string]any。
str.ParseBytesToHTTPRequestraw []byte*http.Request, error将字节数组解析为 HTTP 请求
str.ParseBytesToHTTPResponseres []byte*http.Response, error将字节数组解析为 HTTP 响应
str.ParseStringToCClassHoststargets stringstring尝试从给定的字符串中解析Host，再将其转为 C 类网段，用,分隔
str.ParseStringToHTTPRequestraw string*http.Request, error将字符串解析为 HTTP 请求
str.ParseStringToHTTPResponseres string*http.Response, error将字符串解析为 HTTP 响应
str.ParseStringToHostPortraw stringstring, int, error尝试从字符串中解析出host和port，并与错误一起返回
str.ParseStringToHostsraw string[]string将字符串解析成 Host 列表， Host 可以以逗号、换行分隔，并且会解析 CIDR 网段
str.ParseStringToLinesraw string[]string将字符串按换行符(\n)分割成字符串数组，并去除BOM头和空行
str.ParseStringToPortsports string[]int将字符串解析成 Port 列表， Port 可以以逗号分隔，并且会解析-分隔的范围
str.ParseStringUrlToUrlInstances string*url.URL, error将字符串 url 解析为 URL 结构体并返回错误
str.ParseStringUrlToWebsiteRootPathurl stringstring将字符串 url 解析为其根路径的URL
str.Quotes stringstring给字符串 s 加上双引号并转义其中的特殊字符，返回 Go 语法风格的带引号字符串。
str.RandSecretn intstring返回在所有可见ascii字符表中随机挑选 n 个字符组成的密码字符串，这个密码经过str.IsStrongPassword验证，即为强密码
str.RandStrn intstringRandStringBytes 返回在大小写字母表中随机挑选 n 个字符组成的字符串
str.Randoms stringstringRandomUpperAndLower 返回一个随机大小写的字符串
str.RandomUpperAndLowers stringstring返回一个随机大小写的字符串
str.RegexpMatchpattern string, s anybool使用正则尝试匹配字符串，如果匹配成功返回 true，否则返回 false
str.RemoveDuplicatePortsports1 string, ports2 string[]int解析两个字符串形式的端口列表，并使用布谷鸟过滤器进行去重。
str.RemoveRepeatslc []string[]string移除字符串切片slc中的重复元素
str.RenderTemplatei string, m anystring使用 m 中的数据渲染模板字符串 i（基于 Go text/template 语法），渲染失败时返回原始模板。
str.Repeats string, count intstring返回将字符串s重复count次的字符串
str.Replaces string, old string, new string, n intstring返回将字符串s中前n个old字符串替换为new字符串的字符串
str.ReplaceAlls string, old string, new stringstring返回将字符串s中所有old字符串替换为new字符串的字符串
str.ReplaceHTTPPacketBodyraw []byte, body []byte, chunk bool[]byteReplaceBody 将原始 HTTP 请求报文中的 body 替换为指定的 body，并指定是否为 chunked，返回新的 HTTP 请求报文
str.ShrinkStringi any, size intstringstr.ShrinkString 将会把一个字符串压缩成一个设定一个长度下的较短的字符串
str.Splits string, sep string[]string将字符串s按照sep分割成字符串切片
str.SplitAfters string, sep string[]string将字符串s按照sep分割成字符串切片，但是每个元素都会保留sep
str.SplitAfterNs string, sep string, n int[]string将字符串s按照sep分割成字符串切片，但是每个元素都会保留sep，最多分为n个元素
str.SplitAndTrimRaw string, sep string[]string将字符串s按照sep分割成字符串切片，并且去除每个字符串的前后空白字符
str.SplitNs string, sep string, n int[]string将字符串s按照sep分割成字符串切片，最多分为n个元素
str.StartsWiths string, prefix stringbool/ HasPrefix 判断字符串s是否以prefix开头
str.StringContainsAnyOfSubStrings string, subs []stringbool判断字符串s中是否包含subs中的任意一个子串
str.StringSliceContainss any, raw stringbool判断字符串切片s中是否包含raw，对于非字符串的切片，会尝试将其元素转换为字符串再判断是否包含
str.Subtractx []string, y []string[]string返回两个字符串切片的差集
str.TextReaderSplitctx context.Context, reader io.Readerchan string从 io.Reader 流式读取文本，并按分隔符与块大小递归切分，通过 channel 返回文本块
str.TextSplitctx context.Context, text string[]string将文本按照分隔符与块大小递归切分为多个文本块
str.Titles stringstring返回字符串s的标题化版本，即所有单词的首字母都是大写的
str.ToJsonIndentStrd anystring将v转换为格式化的JSON字符串并返回，如果转换失败，则返回空字符串
str.ToLowers stringstring返回字符串s的小写形式
str.ToLowerSpecialc unicode.SpecialCase, s stringstring使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为小写。
str.ToStringSlicei any[]string将任意类型的数据转换为字符串切片
str.ToTitles stringstring返回字符串s的标题化版本，其中所有Unicode字母都会被转换为其大写
str.ToTitleSpecialc unicode.SpecialCase, s stringstring使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为标题形式（Title Case）。
str.ToUppers stringstring返回字符串s的大写形式
str.ToUpperSpecialc unicode.SpecialCase, s stringstring使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为大写。
str.ToValidUTF8s string, replacement stringstring返回将字符串s中无效的UTF-8编码替换为replacement的字符串
str.Trims string, cutset stringstring返回将字符串s两侧所有包含cutset字符串中的字符都去掉的字符串
str.TrimLefts string, cutset stringstring返回将字符串s左侧所有包含cutset字符串中的字符都去掉的字符串
str.TrimPrefixs string, prefix stringstring返回将字符串s前缀prefix去掉的字符串
str.TrimRights string, cutset stringstring返回将字符串s右侧所有包含cutset字符串中的字符都去掉的字符串
str.TrimSpaces stringstring返回将字符串s两侧所有的空白字符都去掉的字符串
str.TrimSuffixs string, suffix stringstring返回将字符串s后缀suffix去掉的字符串
str.Unquotes stringstring, error把一个带引号的字符串（双引号、单引号或反引号）还原为原始字符串，失败时返回错误。
str.VersionComparev1 string, v2 stringint, error泛用形的版本比较,传入(p1,p2 string), p1>p2返回1,nil, p1<p2返回-1,nil, p1==p2返回0,nil, 比较失败返回 -2,err
str.VersionEqualv1 string, v2 stringbool使用版本比较算法比较版本 v1 与版本 v2，如果 v1 等于 v2 返回 true，否则返回 false
str.VersionGreaterv1 string, v2 stringbool使用版本比较算法比较版本 v1 与版本 v2，如果 v1 大于 v2 返回 true，否则返回 false
str.VersionGreaterEqualv1 string, v2 stringbool使用版本比较算法比较版本 v1 与版本 v2，如果 v1 大于等于 v2 返回 true，否则返回 false
str.VersionLessv1 string, v2 stringbool使用版本比较算法比较版本 v1 与版本 v2，如果 v1 小于 v2 返回 true，否则返回 false
str.VersionLessEqualv1 string, v2 stringbool使用版本比较算法比较版本 v1 与版本 v2，如果 v1 小于等于 v2 返回 true，否则返回 false

可变参数函数索引​

函数参数返回值说明
str.CalcSSDeepStabilityreq ...[]bytefloat64, error使用模糊哈希算法计算多段文本之间的相似度，返回相似度与错误。传入的文本应该为大文本，即长度大于 30 kb。
str.CalcSimHashStabilityreq ...[]bytefloat64, error使用 SimHash 算法计算多段文本之间的相似度，返回相似度与错误。
str.CalcSimilarityraw ...[]bytefloat64计算多段文本之间的相似度，根据最长的文本长度选择不同的算法
str.CalcTextMaxSubStrStabilityraw ...[]bytefloat64, error使用文本子串匹配算法计算多段文本之间的相似度，返回相似度与错误
str.ExtractDomaini any, tryDecode ...bool[]string尝试提取字符串中的域名并返回，后续可以接收一个 tryDecode 参数，如果传入 true，则会尝试对输入的文本进行解码(双重URL编码，URL编码，unicode编码，quoted编码)
str.IsTLSServeraddr string, proxies ...stringbool尝试访问传入的host，然后判断其是否为 TLS 服务。第一个参数为 host，后面可以传入零个或多个参数，为代理地址
str.MatchAllOfGlobi any, re ...stringbool尝试将 i 转换为字符串，然后使用 glob 匹配模式匹配，如果所有的glob模式都匹配成功，则返回 true，否则返回 false
str.MatchAllOfRegexpi any, re ...stringbool尝试将 i 转换为字符串，然后使用正则表达式匹配，如果所有的正则表达式都匹配成功，则返回 true，否则返回 false
str.MatchAllOfSubStringi any, subStr ...stringbool尝试将 i 转换为字符串，然后判断所有子串 subStr 是否都存在于 i 中，如果都存在则返回 true，否则返回 false，此函数忽略大小写
str.MatchAnyOfGlobi any, re ...stringbool尝试将 i 转换为字符串，然后使用 glob 匹配模式匹配，如果任意一个glob模式匹配成功，则返回 true，否则返回 false
str.MatchAnyOfRegexpi any, re ...stringbool尝试将 i 转换为字符串，然后使用正则表达式匹配，如果任意一个正则表达式匹配成功，则返回 true，否则返回 false
str.MatchAnyOfSubStringi any, subStr ...stringbool尝试将 i 转换为字符串，然后判断是否有任意子串 subStr 存在于 i 中，如果有其中一个子串存在于 i 中则返回 true，否则返回 false，此函数忽略大小写
str.ParseStringToUrlstargets ...string[]string尝试从给定的字符串(ip,域名)中解析出 URL 列表，补全协议和端口
str.ParseStringToUrlsWith3Wsub ...string[]string尝试从给定的字符串(ip,域名)中解析出 URL 列表，补全协议和端口，还会补全域名前的 www 前缀
str.PathJoinelem ...stringstring将传入的文件路径进行拼接并返回
str.SplitHTTPHeadersAndBodyFromPacketraw []byte, hook ...func(line string)string, []byte将传入的 HTTP 报文分割为 headers 和 body，如果传入了hook，则会在每次读取到一行 header 时调用 hook
str.SplitHostsToPrivateAndPublichosts ...string[]string, []string将 hosts 按照私有 IP 和公有 IP 分开
str.StringSliceContainsAlls []string, elements ...stringbool判断字符串切片s中是否完全包含elements中的所有元素，对于非字符串的切片，会尝试将其元素转换为字符串再判断是否包含
str.UrlJoinorigin string, paths ...stringstring, error将 字符串 origin 和 字符串数组 paths 拼接成一个新的 URL 字符串，并返回错误
str.ff string, items ...anystring用于对字符串进行格式化

函数详情​

AddPrefixLineNumber​

AddPrefixLineNumber(i any) string

为输入文本 i 的每一行加上行号前缀，并返回处理后的字符串。

参数

参数名类型说明
iany输入内容，会被转换为字符串

返回值

序号类型说明
r1string每行带行号前缀的字符串

示例

out = str.AddPrefixLineNumber("a\nb\nc")
assert str.Contains(out, "1") && str.Contains(out, "3"), "AddPrefixLineNumber should number every line"

AddPrefixLineNumberToReader​

AddPrefixLineNumberToReader(i any) io.Reader

读取 i（字符串或 io.Reader）中的文本，为每一行加上行号前缀，并返回一个新的 io.Reader。

参数

参数名类型说明
iany输入内容，可以是字符串，也可以是 io.Reader

返回值

序号类型说明
r1io.Reader每行带行号前缀的 io.Reader

示例

reader = str.AddPrefixLineNumberToReader("a\nb")
data = io.ReadAll(reader)~
assert str.Contains(string(data), "1"), "AddPrefixLineNumberToReader should add line numbers"

CalcOrdinaryTokenCount​

CalcOrdinaryTokenCount(text string) int

计算文本的 token 数量（基于 Qwen BPE 词表），但不对特殊 token 做识别处理。

参数

参数名类型说明
textstring待计算的文本

返回值

序号类型说明
r1inttoken 数量

示例

n = str.CalcOrdinaryTokenCount("Hello, Yak!")

CalcSSDeep​

CalcSSDeep(raw []byte) string

计算并返回一段文本的模糊哈希值

参数

参数名类型说明
raw[]byte待计算的文本字节

返回值

序号类型说明
r1string模糊哈希字符串，失败返回空字符串

示例

str.CalcSSDeep("hello")

CalcSimHash​

CalcSimHash(raw []byte) uint64

计算并返回一段文本的 SimHash 值

参数

参数名类型说明
raw[]byte待计算的文本字节

返回值

序号类型说明
r1uint64SimHash 值

示例

str.CalcSimHash("hello")

CalcTokenCount​

CalcTokenCount(text string) int

计算文本的 token 数量（基于 Qwen BPE 词表），会识别特殊 token（如 <|im_start|>、<|im_end|>、<|endoftext|>）。

常用于大模型上下文预算估算、长文本裁剪等 AI 处理场景。

参数

参数名类型说明
textstring待计算的文本

返回值

序号类型说明
r1inttoken 数量

示例

n = str.CalcTokenCount("Hello, Yak!")   // 英文 token 数
n = str.CalcTokenCount("你好，世界")      // 中文 token 数

Compare​

Compare(a string, b string) int

按照ascii码表顺序逐个比较字符串a和b中的每个字符，如果a==b，则返回0，如果a<b，则返回-1，如果a>b，则返回1

参数

参数名类型说明
astring第一个字符串
bstring第二个字符串

返回值

序号类型说明
r1int比较结果：相等为0，a<b为-1，a>b为1

示例

result = str.Compare("hello yak", "hello yak")
println(result)   // OUT: 0
assert result == 0, "Compare should return 0 for equal strings"
assert str.Compare("hello yak", "hello") == 1, "Compare should return 1 when a > b"
assert str.Compare("hello", "hello yak") == -1, "Compare should return -1 when a < b"

Contains​

Contains(s string, substr string) bool

判断字符串s是否包含substr

参数

参数名类型说明
sstring原始字符串
substrstring要查找的子串

返回值

序号类型说明
r1bool是否包含该子串（区分大小写）

示例

ok = str.Contains("hello yakit", "yak")
println(ok)   // OUT: true
assert ok == true, "Contains should detect substring"
assert str.Contains("hello yakit", "Yak") == false, "Contains is case sensitive"

ContainsAny​

ContainsAny(s string, chars string) bool

判断字符串s是否包含chars中的任意字符

参数

参数名类型说明
sstring原始字符串
charsstring待匹配的字符集合

返回值

序号类型说明
r1bool是否包含其中任意一个字符

示例

ok = str.ContainsAny("hello yak", "ly")
println(ok)   // OUT: true
assert ok == true, "ContainsAny should match any char present"
assert str.ContainsAny("hello yak", "m") == false, "ContainsAny should fail when none present"

Count​

Count(s string, substr string) int

返回字符串s中substr出现的次数

参数

参数名类型说明
sstring原始字符串
substrstring要统计的子串

返回值

序号类型说明
r1int不重叠出现的次数

示例

count = str.Count("hello yak", "l")
println(count)   // OUT: 2
assert count == 2, "Count should count non-overlapping occurrences"

Cut​

Cut(s string, sep string) (before string, after string, found bool)

在 s 中查找第一个 sep，并以其为界把 s 切分为前后两部分。如果找到 sep，则 found 为 true。

参数

参数名类型说明
sstring原始字符串
sepstring分隔符

返回值

序号类型说明
beforestringsep 之前的部分
afterstringsep 之后的部分
foundbool是否找到了 sep

示例

before, after, found = str.Cut("key=value", "=")
println(before, after, found)   // OUT: key value true
assert before == "key" && after == "value" && found, "Cut should split on the separator"

CutPrefix​

CutPrefix(s string, prefix string) (after string, found bool)

如果 s 以 prefix 开头，则返回去除该前缀后的字符串与 true，否则返回原字符串与 false。

参数

参数名类型说明
sstring原始字符串
prefixstring要去除的前缀

返回值

序号类型说明
afterstring去除前缀后的字符串（未命中前缀时为原字符串）
foundbool是否命中前缀

示例

after, found = str.CutPrefix("https://example.com", "https://")
println(after, found)   // OUT: example.com true
assert after == "example.com" && found, "CutPrefix should strip the prefix"

CutSuffix​

CutSuffix(s string, suffix string) (before string, found bool)

如果 s 以 suffix 结尾，则返回去除该后缀后的字符串与 true，否则返回原字符串与 false。

参数

参数名类型说明
sstring原始字符串
suffixstring要去除的后缀

返回值

序号类型说明
beforestring去除后缀后的字符串（未命中后缀时为原字符串）
foundbool是否命中后缀

示例

before, found = str.CutSuffix("file.txt", ".txt")
println(before, found)   // OUT: file true
assert before == "file" && found, "CutSuffix should strip the suffix"

DecodeTokens​

DecodeTokens(tokens []int) string

将 Qwen BPE token id 列表解码还原为文本，是 EncodeTokens 的逆操作。

参数

参数名类型说明
tokens[]inttoken id 列表

返回值

序号类型说明
r1string解码还原后的文本

示例

ids = str.EncodeTokens("Hello, Yak!")
text = str.DecodeTokens(ids) // Hello, Yak!

EncodeOrdinaryTokens​

EncodeOrdinaryTokens(text string) []int

将文本编码为 Qwen BPE token id 列表（不识别特殊 token）。

参数

参数名类型说明
textstring待编码的文本

返回值

序号类型说明
r1[]inttoken id 列表

示例

ids = str.EncodeOrdinaryTokens("Hello, Yak!")

EncodeTokens​

EncodeTokens(text string) []int

将文本编码为 Qwen BPE token id 列表（会识别特殊 token）。

参数

参数名类型说明
textstring待编码的文本

返回值

序号类型说明
r1[]inttoken id 列表

示例

ids = str.EncodeTokens("Hello, Yak!")
println(len(ids))

EndsWith​

EndsWith(s string, suffix string) bool

/ HasSuffix 判断字符串s是否以suffix结尾

参数

参数名类型说明
sstring原始字符串
suffixstring要判断的后缀

返回值

序号类型说明
r1bool是否以该后缀结尾

示例

ok = str.EndsWith("Hello Yak", "Yak")
println(ok)   // OUT: true
assert ok == true, "EndsWith should match suffix"
assert str.EndsWith("Hello Yak", "Hello") == false, "EndsWith should reject non-suffix"

EqualFold​

EqualFold(s string, t string) bool

判断字符串s和t是否相等，忽略大小写

参数

参数名类型说明
sstring第一个字符串
tstring第二个字符串

返回值

序号类型说明
r1bool忽略大小写后是否相等

示例

ok = str.EqualFold("hello Yak", "HELLO YAK")
println(ok)   // OUT: true
assert ok == true, "EqualFold should ignore case"

ExtractBodyFromHTTPResponseRaw​

ExtractBodyFromHTTPResponseRaw(res []byte) ([]byte, error)

从原始 HTTP 响应报文中提取 body

参数

参数名类型说明
res[]byte原始 HTTP 响应报文字节

返回值

序号类型说明
r1[]byte提取出的响应体字节
r2error错误信息

示例

body, err = str.ExtractBodyFromHTTPResponseRaw(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok") // body = b"ok"

ExtractChineseIDCards​

ExtractChineseIDCards(i any) []string

尝试将传入的参数转换为字符串，然后提取字符串中的身份证号

参数

参数名类型说明
iany待提取的内容（string 或 []byte）

返回值

序号类型说明
r1[]string提取到的身份证号列表

示例

str.ExtractChineseIDCards("Your ChineseID is: 110101202008027420?") // ["110101202008027420"]

ExtractHost​

ExtractHost(raw string) string

尝试从字符串中解析出host和port，并返回host

参数

参数名类型说明
rawstring形如 host:port 或 URL 的字符串

返回值

序号类型说明
r1string解析出的 host，无法解析时返回原字符串

示例

str.ExtractHost("127.0.0.1:8888") // 127.0.0.1
str.ExtractHost("https://example.com") // example.com

ExtractHostPort​

ExtractHostPort(raw string) string

尝试从字符串中解析出host和port，并返回host:port

参数

参数名类型说明
rawstring形如 host:port 或 URL 的字符串

返回值

序号类型说明
r1string解析出的 host:port，无法解析时返回原字符串

示例

str.ExtractHostPort("https://127.0.0.1:8888") // 127.0.0.1:8888
str.ExtractHostPort("https://baidu.com") // 127.0.0.1:443

ExtractJson​

ExtractJson(i any) []string

尝试提取字符串中的 JSON 并进行修复, 返回中的元素都是Object

参数

参数名类型说明
iany任意可转为字符串的输入

返回值

序号类型说明
r1[]string提取并修复后的 JSON 对象字符串数组

示例

objs = str.ExtractJson(`{"hello": "yak"}`)
println(len(objs))   // OUT: 1
assert len(objs) == 1, "ExtractJson should extract one json object"
assert len(str.ExtractJson("hello yak")) == 0, "ExtractJson should return empty when no json present"

ExtractJsonWithRaw​

ExtractJsonWithRaw(i any) ([]string, []string)

尝试提取字符串中的 JSON 并返回，第一个返回值返回经过修复后的JSON字符串数组，第二个返回值返回原始JSON字符串数组(如果修复失败)

参数

参数名类型说明
iany任意可转为字符串的输入

返回值

序号类型说明
r1[]string修复后的 JSON 字符串数组
r2[]string修复失败时的原始 JSON 字符串数组

示例

fixed, raw = str.ExtractJsonWithRaw(`{"hello": "yak"}`)
println(len(fixed))   // OUT: 1
assert len(fixed) == 1, "ExtractJsonWithRaw should extract one json object"

ExtractRootDomain​

ExtractRootDomain(i any) []string

尝试提取字符串中的根域名并返回

参数

参数名类型说明
iany任意可转为字符串的输入

返回值

序号类型说明
r1[]string提取到的根域名数组

示例

roots = str.ExtractRootDomain("hello www.yaklang.com or www.yaklang.io")
println(len(roots))   // OUT: 2
assert len(roots) == 2, "ExtractRootDomain should extract both root domains"

ExtractStrContext​

ExtractStrContext(raw string, res []string) []string

从字符串raw中提取一组关键字res上下文的内容，上下文的长度是512个字符确定。

参数

参数名类型说明
rawstring原始字符串
res[]string关键词列表

返回值

序号类型说明
r1[]string每个命中关键词周围的上下文文本切片（已去重）

示例

str.ExtractStrContext("hello yak", ["hello"]) // ["hello yak"]

ExtractTitle​

ExtractTitle(i any) string

尝试将传入的字符串进行HTML解析并提取其中的标题(title标签)返回

参数

参数名类型说明
iany任意可转为字符串的 HTML 输入

返回值

序号类型说明
r1string提取到的标题文本，未找到返回空字符串

示例

title = str.ExtractTitle("<title>hello yak</title>")
println(title)   // OUT: hello yak
assert title == "hello yak", "ExtractTitle should read the title tag"

ExtractURLFromHTTPRequest​

ExtractURLFromHTTPRequest(r *http.Request, https bool) (*url.URL, error)

从 HTTP 请求结构体中提取 URL，返回URL结构体与错误

参数

参数名类型说明
r*http.RequestHTTP 请求结构体
httpsbool是否为 https 协议

返回值

序号类型说明
r1*url.URL解析出的 URL 实例
r2error错误信息

示例

v, err = http.Raw("GET / HTTP/1.1\r\nHost: www.yaklang.com\r\n\r\n")
url, err = str.ExtractURLFromHTTPRequest(v, false)

ExtractURLFromHTTPRequestRaw​

ExtractURLFromHTTPRequestRaw(req []byte, isHttps bool) (*url.URL, error)

从原始 HTTP 请求报文中提取 URL，返回URL结构体与错误

参数

参数名类型说明
req[]byte原始 HTTP 请求报文字节
isHttpsbool是否为 https 协议

返回值

序号类型说明
r1*url.URL解析出的 URL 实例
r2error错误信息

示例

url, err := str.ExtractURLFromHTTPRequestRaw(b"GET / HTTP/1.1\r\nHost: www.yaklang.com\r\n\r\n", false)

Fields​

Fields(s string) []string

返回将字符串s按照空白字符（'\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0）分割的字符串切片

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1[]string按连续空白分割后的非空字段切片

示例

fields = str.Fields("hello world\nhello yak\tand\vyakit")
println(fields)   // OUT: [hello world hello yak and yakit]
assert len(fields) == 6, "Fields should split on any whitespace run"
assert fields[0] == "hello" && fields[5] == "yakit", "Fields should keep tokens in order"

FilterPorts​

FilterPorts(sourcePorts string, excludePorts string) []int

接受两个字符串形式的端口列表作为参数，返回一个新的端口列表，

其中包含了在 ports1 中但不在 ports2 中的所有端口。

这个函数首先将两个输入字符串解析为端口列表，然后创建一个映射（或集合）来存储 ports2 中的所有端口。

然后，它遍历 ports1 中的每个端口，如果这个端口不在 ports2 中，那么它就会被添加到结果列表中。

最后，函数返回结果列表，其中包含了所有只在 ports1 中出现的端口。

参数

参数名类型说明
sourcePortsstring源端口列表字符串
excludePortsstring需要排除的端口列表字符串

返回值

序号类型说明
r1[]int在 sourcePorts 中但不在 excludePorts 中的端口整数列表

示例

ports = str.FilterPorts("1-10", "2-10") // [1]
assert len(ports) == 1 && ports[0] == 1, "should keep ports not excluded"

FixHTTPRequest​

FixHTTPRequest(raw []byte) []byte

尝试对传入的HTTP请求报文进行修复，并返回修复后的请求

参数

参数名类型说明
raw[]byte原始 HTTP 请求报文字节

返回值

序号类型说明
r1[]byte修复后的 HTTP 请求报文字节

示例

str.FixHTTPRequest(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")

FixHTTPResponse​

FixHTTPResponse(raw []byte) (rsp []byte, body []byte, _ error)

尝试对传入的响应进行修复，并返回修复后的响应，响应体和错误

参数

参数名类型说明
raw[]byte原始 HTTP 响应报文字节

返回值

序号类型说明
rsp[]byte修复后的完整响应报文
body[]byte修复后的响应体
_error错误信息

示例

fixedResponse, body, err = str.FixHTTPResponse(b"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=gbk\r\n\r\n<html>你好</html>")

Grok​

Grok(line string, rule string) GrokResult

使用 Grok 规则解析字符串并返回解析结果（导出名为 re.Grok）

结果为字段名到取值的映射，可用 .Get(key) 取第一个值；参考 logstash grok 语法

参数

参数名类型说明
linestring待解析的原始字符串
rulestringGrok 规则（如 "%{MONTHNUM:month}/%{MONTHDAY:day}-%{TIME:time}"）

返回值

序号类型说明
r1GrokResultGrok 解析结果对象，解析失败返回空结果，可用 .Get(name) 取值

示例

result = re.Grok("04/18-00:59:45.385191", "%{MONTHNUM:month}/%{MONTHDAY:day}-%{TIME:time}")
println(result.Get("month"))   // OUT: 04
assert result.Get("day") == "18", "Grok should capture the day field"
assert result.Get("time") == "00:59:45.385191", "Grok should capture the time field"

HasPrefix​

HasPrefix(s string, prefix string) bool

StartsWith / HasPrefix 判断字符串s是否以prefix开头

参数

参数名类型说明
sstring原始字符串
prefixstring要判断的前缀

返回值

序号类型说明
r1bool是否以该前缀开头

示例

ok = str.StartsWith("Hello Yak", "Hello")
println(ok)   // OUT: true
assert ok == true, "StartsWith should match prefix"
assert str.StartsWith("Hello Yak", "Yak") == false, "StartsWith should reject non-prefix"

HasSuffix​

HasSuffix(s string, suffix string) bool

EndsWith / HasSuffix 判断字符串s是否以suffix结尾

参数

参数名类型说明
sstring原始字符串
suffixstring要判断的后缀

返回值

序号类型说明
r1bool是否以该后缀结尾

示例

ok = str.EndsWith("Hello Yak", "Yak")
println(ok)   // OUT: true
assert ok == true, "EndsWith should match suffix"
assert str.EndsWith("Hello Yak", "Hello") == false, "EndsWith should reject non-suffix"

HostPort​

HostPort(host string, port any) string

将 host 和 port 拼接成 host:port 的形式

参数

参数名类型说明
hoststring主机名或 IP
portany端口（数字或字符串）

返回值

序号类型说明
r1string拼接后的 host:port 字符串

示例

str.HostPort("yaklang.com", 443) // yaklang.com:443

IPv4ToCClassNetwork​

IPv4ToCClassNetwork(s string) (network string, err error)

尝试从一个 IPv4 地址中获取 C 类网络地址，并返回错误

参数

参数名类型说明
sstringIPv4 地址字符串

返回值

序号类型说明
networkstringC 类网段（形如 192.168.0.0/24）
errerror错误信息

示例

network, err = str.IPv4ToCClassNetwork("192.168.0.1") // network = "192.168.0.0/24", err = nil

Index​

Index(s string, substr string) int

返回字符串s中substr第一次出现的位置的索引，如果字符串中不存在substr，则返回-1

参数

参数名类型说明
sstring原始字符串
substrstring要查找的子串

返回值

序号类型说明
r1int首次出现的下标，未找到返回 -1

示例

idx = str.Index("hello yak", "yak")
println(idx)   // OUT: 6
assert idx == 6, "Index should return the first match position"
assert str.Index("hello world", "yak") == -1, "Index should return -1 when not found"

IndexAny​

IndexAny(s string, chars string) int

返回字符串s中chars任意字符首次出现的位置的索引，如果字符串中不存在chars，则返回-1

参数

参数名类型说明
sstring原始字符串
charsstring待匹配的字符集合

返回值

序号类型说明
r1int任意字符首次出现的下标，未找到返回 -1

示例

// l 在 "Hello world" 第三个字符首次命中 chars
idx = str.IndexAny("Hello world", "world")
println(idx)   // OUT: 2
assert idx == 2, "IndexAny should locate first matching char"
// chars 中字符都不出现时返回 -1
assert str.IndexAny("Hello World", "Yak") == -1, "IndexAny should return -1 when no char matches"

IndexByte​

IndexByte(s string, c byte) int

返回字符串s中第一个等于c的字符的索引，如果字符串中不存在c，则返回-1

参数

参数名类型说明
sstring原始字符串
cbyte要查找的字节

返回值

序号类型说明
r1int首次出现的下标，未找到返回 -1

示例

idx = str.IndexByte("hello yak", 'y')
println(idx)   // OUT: 6
assert idx == 6, "IndexByte should return the first byte position"
assert str.IndexByte("hello yak", 'm') == -1, "IndexByte should return -1 when not found"

Intersect​

Intersect(x []string, y []string) []string

/ IntersectString 返回两个字符串切片之间的交集

参数

参数名类型说明
x[]string第一个字符串切片
y[]string第二个字符串切片

返回值

序号类型说明
r1[]string同时存在于 x 和 y 中的元素组成的切片

示例

str.Intersect(["1", "2", "3"], ["3", "4", "5"]) // ["3"]

IntersectString​

IntersectString(x []string, y []string) []string

Intersect / IntersectString 返回两个字符串切片之间的交集

参数

参数名类型说明
x[]string第一个字符串切片
y[]string第二个字符串切片

返回值

序号类型说明
r1[]string同时存在于 x 和 y 中的元素组成的切片

示例

str.Intersect(["1", "2", "3"], ["3", "4", "5"]) // ["3"]

IsAlNum​

IsAlNum(i any) bool

IsAlphaNum / IsAlNum 尝试将传入的参数转换为字符串，然后判断其是否都由英文字母和数字组成

参数

参数名类型说明
iany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否全部由英文字母和数字组成

示例

str.IsAlphaNum("abc123") // true
str.IsAlphaNum("abc123!") // false

IsAllVisibleASCII​

IsAllVisibleASCII(s string) bool

判断字符串是否全部由可见的 ASCII 字符（0x20~0x7E）组成

参数

参数名类型说明
sstring待判断的字符串

返回值

序号类型说明
r1bool是否全部为可见 ASCII 字符

示例

str.IsAllVisibleASCII("hello") // true
str.IsAllVisibleASCII("你好")    // false

IsAlpha​

IsAlpha(i any) bool

尝试将传入的参数转换为字符串，然后判断其是否都由英文字母组成

参数

参数名类型说明
iany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否全部由英文字母组成

示例

str.IsAlpha("abc") // true
str.IsAlpha("abc123") // false

IsAlphaNum​

IsAlphaNum(i any) bool

/ IsAlNum 尝试将传入的参数转换为字符串，然后判断其是否都由英文字母和数字组成

参数

参数名类型说明
iany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否全部由英文字母和数字组成

示例

str.IsAlphaNum("abc123") // true
str.IsAlphaNum("abc123!") // false

IsBase64Value​

IsBase64Value(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 Base64 编码的数据

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为 Base64 编码数据

示例

str.IsBase64Value("MTI=") // true
str.IsBase64Value("123") // false

IsCaptchaField​

IsCaptchaField(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是验证码字段

参数

参数名类型说明
iany待判断的字段名（string 或 []byte）

返回值

序号类型说明
r1bool是否为验证码字段

示例

str.IsCaptchaField("captcha") // true
str.IsCaptchaField("code_img") // true
str.IsCaptchaField("id") // false

IsDigit​

IsDigit(i any) bool

尝试将传入的参数转换为字符串，然后判断其是否都由数字组成

参数

参数名类型说明
iany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否全部由数字组成

示例

str.IsDigit("123") // true
str.IsDigit("abc123") // false

IsHtmlResponse​

IsHtmlResponse(i any) bool

猜测传入的参数是否为原始 HTTP 响应报文

参数

参数名类型说明
iany原始 HTTP 响应（string、[]byte 或 *http.Response）

返回值

序号类型说明
r1bool是否为 HTML 响应

示例

str.IsHtmlResponse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<html></html>") // true
resp, _ = str.ParseStringToHTTPResponse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<html></html>")
str.IsHtmlResponse(resp) // true

IsHttpURL​

IsHttpURL(v any) bool

根据 value 猜测是否是一个完整 url，目前只关心 http 和 https

参数

参数名类型说明
vany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否为 http(s) 协议的完整 URL

示例

str.IsHttpURL("http://www.yaklang.com") // true
str.IsHttpURL("www.yaklang.com") // false

IsIPv4​

IsIPv4(raw string) bool

判断字符串是否是 IPv4 地址

参数

参数名类型说明
rawstring待判断的字符串

返回值

序号类型说明
r1bool是否为 IPv4 地址

示例

str.IsIPv4("::1") // false
str.IsIPv4("127.0.0.1") // true

IsIPv6​

IsIPv6(raw string) bool

判断字符串是否是 IPv6 地址

参数

参数名类型说明
rawstring待判断的字符串

返回值

序号类型说明
r1bool是否为 IPv6 地址

示例

str.IsIPv6("::1") // true
str.IsIPv6("127.0.0.1") // false

IsJSONPParam​

IsJSONPParam(key string, value string) bool

根据传入的参数名和参数值猜测是否为 JSONP 参数

参数

参数名类型说明
keystring参数名
valuestring参数值

返回值

序号类型说明
r1bool是否为 JSONP 参数

示例

str.IsJSONPParam("callback","jquery1.0.min.js") // true，因为参数名为常见的 JSONP 参数名，且参数值为常见的JS文件名
str.IsJSONPParam("f","jquery1.0.min.js") // true，因为参数值为常见的 JS 文件名
str.IsJSONPParam("id","1") // false

IsJsonResponse​

IsJsonResponse(i any) bool

尝试将传入的参数转换为字符串，然后猜测传入的参数是否为 JSON 格式的原始 HTTP 响应报文，这是通过判断Content-Type请求头实现的

参数

参数名类型说明
iany原始 HTTP 响应（string、[]byte 或 *http.Response）

返回值

序号类型说明
r1bool是否为 JSON 响应

示例

str.IsJsonResponse("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{\"code\": 0}") // true
str.IsJsonResponse("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nhello") // false

IsMD5Value​

IsMD5Value(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 MD5 编码的数据

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为 MD5 值

示例

str.IsMD5Value("202cb962ac59075b964b07152d234b70") // true
str.IsMD5Value("123") // false

IsPasswordField​

IsPasswordField(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 password 字段

参数

参数名类型说明
iany待判断的字段名（string 或 []byte）

返回值

序号类型说明
r1bool是否为 password 字段

示例

str.IsPasswordField("password") // true
str.IsPasswordField("pwd") // true
str.IsPasswordField("id") // false

IsPlainBase64Value​

IsPlainBase64Value(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 Base64 编码的数据，它相比于 IsBase64Value 多了一层判断，即判断 base64 解码后的数据是否为可见字符串

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为可解码为可见字符串的 Base64 数据

示例

str.IsPlainBase64Value("MTI=") // true
str.IsPlainBase64Value("Aw==") // false

IsRedirectParam​

IsRedirectParam(key string, value string) bool

根据传入的参数名和参数值猜测是否为重定向参数

参数

参数名类型说明
keystring参数名
valuestring参数值

返回值

序号类型说明
r1bool是否为重定向参数

示例

str.IsRedirectParam("to","http://www.yaklang.com") // true，因为参数值为完整的 URL
str.IsRedirectParam("target","/index.php") // true，因为参数值为一个 URL 路径而且参数名为常见的跳转的参数名
str.IsRedirectParam("id", "1") // false

IsSQLColumnField​

IsSQLColumnField(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 SQL 查询字段

参数

参数名类型说明
iany待判断的字段名（string 或 []byte）

返回值

序号类型说明
r1bool是否为 SQL 查询字段

示例

str.IsSQLColumnField("sort") // true
str.IsSQLColumnField("order") // true
str.IsSQLColumnField("id") // false

IsSensitiveJson​

IsSensitiveJson(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否为敏感的 JSON 数据

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为敏感 JSON 数据

示例

str.IsSensitiveJson(`{"password":"123456"}`) // true
str.IsSensitiveJson(`{"uid": 10086}`) // true
str.IsSensitiveJson(`{"id": 1}`) // false

IsSensitiveTokenField​

IsSensitiveTokenField(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 token 字段

参数

参数名类型说明
iany待判断的字段名（string 或 []byte）

返回值

序号类型说明
r1bool是否为 token 字段

示例

str.IsSensitiveTokenField("token") // true
str.IsSensitiveTokenField("access_token") // true
str.IsSensitiveTokenField("id") // false

IsServerError​

IsServerError(i any) bool

猜测传入的参数是否为服务器错误

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否包含服务器错误特征

示例

str.IsServerError(`Fatal error: Uncaught Error: Call to undefined function sum() in F:\xampp\htdocs\test.php:7 Stack trace: #0 {main} thrown in <path> on line 7`) // true，这是PHP报错信息

IsSha256Value​

IsSha256Value(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 SHA256 编码的数据

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为 SHA256 值

示例

str.IsSha256Value("a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3") // true
str.IsSha256Value("123") // false

IsStrongPassword​

IsStrongPassword(s string) bool

判断字符串是否为强密码，强密码的定义为：长度大于8，同时包含特殊字符、小写字母、大写字母、数字

参数

参数名类型说明
sstring待检测的密码字符串

返回值

序号类型说明
r1bool是否满足强密码要求

示例

str.IsStrongPassword("12345678") // false
str.IsStrongPassword("12345678a") // false
str.IsStrongPassword("12345678aA") // false
str.IsStrongPassword("12345678aA!") // true

IsUrlParam​

IsUrlParam(key string, value string) bool

根据传入的参数名和参数值猜测是否为 URL 参数

参数

参数名类型说明
keystring参数名
valuestring参数值

返回值

序号类型说明
r1bool是否为 URL 参数

示例

str.IsUrlParam("url","http://www.yaklang.com") // true，因为参数名为常见的 URL 参数名，且参数值为完整的URL
str.IsUrlParam("id","1") // false

IsUrlPath​

IsUrlPath(v any) bool

根据 value 猜测是否是一个 url path

参数

参数名类型说明
vany待判断的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否为 URL 路径

示例

str.IsUrlPath("/index.php") // true
str.IsUrlPath("index.php") // false

IsUsernameField​

IsUsernameField(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 username 字段

参数

参数名类型说明
iany待判断的字段名（string 或 []byte）

返回值

序号类型说明
r1bool是否为 username 字段

示例

str.IsUsernameField("username") // true
str.IsUsernameField("user") // true
str.IsUsernameField("id") // false

IsXmlParam​

IsXmlParam(key string, value string) bool

根据传入的参数名和参数值猜测是否为 XML 参数

参数

参数名类型说明
keystring参数名
valuestring参数值

返回值

序号类型说明
r1bool是否为 XML 参数

示例

str.IsXmlParam("xml","<xml></xml>") // true，因为参数名为常见的 XML 参数名，且参数值为 XML 格式的字符串
str.IsXmlParam("X","<xml></xml>") // true，因为参数值为 XML 格式的字符串
str.IsXmlParam("id","1") // false

IsXmlRequest​

IsXmlRequest(i any) bool

猜测传入的参数是否为请求头是 XML 格式的原始 HTTP 请求报文

参数

参数名类型说明
iany原始 HTTP 请求（string、[]byte 或 *http.Request）

返回值

序号类型说明
r1bool是否为 XML 请求

示例

str.IsXmlRequest("POST / HTTP/1.1\r\nContent-Type: application/xml\r\n\r\n<xml></xml>") // true
str.IsXmlRequest("POST / HTTP/1.1\r\nContent-Type: text/html\r\n\r\n<html></html>") // false

IsXmlValue​

IsXmlValue(i any) bool

尝试将传入的参数转换为字符串，然后猜测其是否是 XML 格式的数据

参数

参数名类型说明
iany待判断的内容（string 或 []byte）

返回值

序号类型说明
r1bool是否为 XML 格式数据

示例

str.IsXmlValue("<xml></xml>") // true
str.IsXmlValue("<html></html>") // false

Join​

Join(i any, d any) (defaultResult string)

将i中的元素用d连接，如果传入的参数不是字符串，会自动将其转为字符串，再将其用d连接。如果连接失败，则会返回i的字符串形式。

参数

参数名类型说明
iany要连接的切片或可迭代对象
dany连接用的分隔符

返回值

序号类型说明
defaultResultstring连接后的字符串

示例

result = str.Join(["hello", "yak"], " ")
println(result)   // OUT: hello yak
assert result == "hello yak", "Join should join string slice with sep"
assert str.Join([1, 2, 3], " ") == "1 2 3", "Join should stringify non-string elements"

JsonStringDecode​

JsonStringDecode(raw string) string

解码一个 JSON 字符串值（一次性版本），去掉首尾引号并还原转义（\n、\t、\uXXXX、\xNN 等），

返回真实字符串内容。相比 str.Unquote 更容错：遇到非标准/畸形数据会回退返回原始内容而不是报错。

适合处理 jsonstream onField 给出的带引号原始值。

参数

参数名类型说明
rawstring带引号和转义的 JSON 字符串值

返回值

序号类型说明
r1string去引号、去转义后的真实字符串内容

示例

str.JsonStringDecode(`"Hello\nYak"`)            // Hello(换行)Yak
str.JsonStringDecode(`"\u4f60\u597d"`)          // 你好

JsonToMap​

JsonToMap(line string) map[string]any

将 json 字符串 line 解析为 map，保留嵌套结构（对象/数组不会被转为字符串）

单对象时优先用 json.Unmarshal 确保嵌套正确；多对象（如 {} {}）时回退到 jstream。

参数

参数名类型说明
linestringJSON 字符串

返回值

序号类型说明
r1map[string]any解析出的 map，解析失败返回 nil

示例

str.JsonToMap(`{"a":1,"b":2}`)           // map[a:1 b:2]
str.JsonToMap(`{"b":{},"c":[],"d":{"d1":""}}`)  // 嵌套结构完整保留

JsonToMapList​

JsonToMapList(line string) []map[string]any

将 json 字符串 line 解析为 map 列表，保留嵌套结构（对象/数组不会被转为字符串）

参数

参数名类型说明
linestring包含一个或多个 JSON 对象的字符串

返回值

序号类型说明
r1[]map[string]any解析出的 map 列表

示例

str.JsonToMapList(`{"a":1,"b":2} {"c":3, "d":4}`) // [map[a:1 b:2] map[c:3 d:4]]
str.JsonToMapList(`{"a":{"x":1},"b":[]}`)         // [map[a:map[x:1] b:[]]

LastIndex​

LastIndex(s string, substr string) int

返回字符串s中substr最后一次出现的位置的索引，如果字符串中不存在substr，则返回-1

参数

参数名类型说明
sstring原始字符串
substrstring要查找的子串

返回值

序号类型说明
r1int最后一次出现的下标，未找到返回 -1

示例

idx = str.LastIndex("hello yak", "l")
println(idx)   // OUT: 3
assert idx == 3, "LastIndex should return the last match position"
assert str.LastIndex("hello yak", "m") == -1, "LastIndex should return -1 when not found"

LastIndexAny​

LastIndexAny(s string, chars string) int

返回字符串s中chars任意字符最后一次出现的位置的索引，如果字符串中不存在chars，则返回-1

参数

参数名类型说明
sstring原始字符串
charsstring待匹配的字符集合

返回值

序号类型说明
r1int任意字符最后一次出现的下标，未找到返回 -1

示例

idx = str.LastIndexAny("hello yak", "ly")
println(idx)   // OUT: 6
assert idx == 6, "LastIndexAny should return last position of any char"
assert str.LastIndexAny("hello yak", "m") == -1, "LastIndexAny should return -1 when none present"

LastIndexByte​

LastIndexByte(s string, c byte) int

返回字符串s中最后一个等于c的字符的索引，如果字符串中不存在c，则返回-1

参数

参数名类型说明
sstring原始字符串
cbyte要查找的字节

返回值

序号类型说明
r1int最后一次出现的下标，未找到返回 -1

示例

idx = str.LastIndexByte("hello yak", 'l')
println(idx)   // OUT: 3
assert idx == 3, "LastIndexByte should return last byte position"
assert str.LastIndexByte("hello yak", 'm') == -1, "LastIndexByte should return -1 when not found"

LowerAndTrimSpace​

LowerAndTrimSpace(raw string) string

将字符串raw转换为小写并去除前后空白字符

参数

参数名类型说明
rawstring原始字符串

返回值

序号类型说明
r1string转为小写并去除前后空白后的字符串

示例

str.LowerAndTrimSpace("  Hello  ") // "hello"

MergeUrlFromHTTPRequest​

MergeUrlFromHTTPRequest(rawRequest []byte, target string, isHttps bool) (newURL string)

将传入的 target 与 原始 HTTP 请求报文中的 URL 进行合并，并返回合并后的 URL

参数

参数名类型说明
rawRequest[]byte原始 HTTP 请求报文字节
targetstring待合并的目标路径或 URL
isHttpsbool是否为 https 协议

返回值

序号类型说明
newURLstring合并后的 URL 字符串

示例

url = str.MergeUrlFromHTTPRequest(b"GET /z HTTP/1.1\r\nHost: www.yaklang.com\r\n\r\n", "/a/b", true) // url = "https://www.yaklang.com/z/a/b"

NewFilter​

NewFilter() *StringFilter

创建一个默认的字符串布谷鸟过滤器，布谷鸟过滤器用于判断一个元素是否在一个集合中，它存在极低的假阳性（即说存在的元素实际上不存在），通常这个集合中的元素数量非常大才会使用布谷鸟过滤器。

返回值

序号类型说明
r1*StringFilter一个新的字符串过滤器实例

示例

f = str.NewFilter()
f.Insert("hello")
f.Exist("hello") // true

NewJSONStringReader​

NewJSONStringReader(r io.Reader) io.Reader

包装一个 JSON 字符串值的 Reader，流式解码其中的转义（\n、\t、\uXXXX、\xNN 等），

返回去引号、去转义后的真实字符串内容。内部已用 UTF-8 安全读取，遇到非标准/畸形数据会自动回退为原始透传。

常用于 jsonstream 的 onField 回调：字段流给出的是带引号和转义的原始值，用它解码即可拿到真实内容。

参数

参数名类型说明
rio.Reader提供 JSON 字符串值的 io.Reader

返回值

序号类型说明
r1io.Reader一个输出去引号、去转义后真实内容的 io.Reader

示例

jsonstream.Extract(`{"content": "Hello\nYak \u4f60\u597d"}`,

	jsonstream.onField("content", func(key, reader, parents) {
	    data = io.ReadAll(str.NewJSONStringReader(reader))~
	    println(string(data)) // Hello(换行)Yak 你好
	}),

)

NewReader​

NewReader(s string) *strings.Reader

基于字符串 s 创建一个只读的 io.Reader，可用于需要 reader 的接口。

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1*strings.Reader一个从 s 读取数据的 *strings.Reader

示例

reader = str.NewReader("hello")
data = io.ReadAll(reader)~
assert string(data) == "hello", "NewReader should provide a reader over the string"

NewUTF8Reader​

NewUTF8Reader(r io.Reader) io.Reader

包装一个 Reader，使每次读取都只返回完整的 UTF-8 字符，

避免在按字节/小缓冲读取数据流（如 jsonstream 字段流）时把一个多字节字符（中文等）从中间截断。

参数

参数名类型说明
rio.Reader原始的 io.Reader

返回值

序号类型说明
r1io.Reader一个保证按完整 UTF-8 字符返回的 io.Reader

示例

// 包装原始 Reader，逐块读取中文内容时避免把多字节字符从中间截断
rawReader = str.NewReader("你好世界")
r = str.NewUTF8Reader(rawReader)
buf = make([]byte, 4)
n, err = r.Read(buf) // buf[:n] 一定是完整的 UTF-8 字符序列
assert n > 0, "should read at least one complete UTF-8 character"

ParamsGetOr​

ParamsGetOr(i any, key string, defaultValue string) string

从 map 中获取 key 对应的值，如果不存在则返回 defaultValue。支持 map[string]string 与 map[string]any。

参数

参数名类型说明
iany源 map（map[string]string 或 map[string]any）
keystring要获取的键
defaultValuestring键不存在时返回的默认值

返回值

序号类型说明
r1string键对应的字符串值，不存在时返回 defaultValue

示例

str.ParamsGetOr({"a": "1"}, "a", "2") // 1
str.ParamsGetOr({"a": "1"}, "b", "2") // 2

ParseBytesToHTTPRequest​

ParseBytesToHTTPRequest(raw []byte) (reqInst *http.Request, err error)

将字节数组解析为 HTTP 请求

参数

参数名类型说明
raw[]byte原始 HTTP 请求报文字节数组

返回值

序号类型说明
reqInst*http.Request解析得到的 HTTP 请求对象
errerror错误信息，解析失败时返回非空

示例

req, err := str.ParseBytesToHTTPRequest(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")

ParseBytesToHTTPResponse​

ParseBytesToHTTPResponse(res []byte) (rspInst *http.Response, err error)

将字节数组解析为 HTTP 响应

参数

参数名类型说明
res[]byte原始 HTTP 响应报文字节数组

返回值

序号类型说明
rspInst*http.Response解析得到的 HTTP 响应对象
errerror错误信息，解析失败时返回非空

示例

res, err := str.ParseBytesToHTTPResponse(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")

ParseStringToCClassHosts​

ParseStringToCClassHosts(targets string) string

尝试从给定的字符串中解析Host，再将其转为 C 类网段，用,分隔

参数

参数名类型说明
targetsstring主机字符串（支持范围、CIDR 等）

返回值

序号类型说明
r1string以逗号分隔的 C 类网段字符串

示例

str.ParseStringToCClassHosts("192.168.0.1-255") // 192.168.0.0/24

ParseStringToHTTPRequest​

ParseStringToHTTPRequest(raw string) (*http.Request, error)

将字符串解析为 HTTP 请求

参数

参数名类型说明
rawstringHTTP 请求报文字符串

返回值

序号类型说明
r1*http.Request解析出的 HTTP 请求结构体
r2error错误信息

示例

req, err = str.ParseStringToHTTPRequest("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")

ParseStringToHTTPResponse​

ParseStringToHTTPResponse(res string) (*http.Response, error)

将字符串解析为 HTTP 响应

参数

参数名类型说明
resstringHTTP 响应报文字符串

返回值

序号类型说明
r1*http.Response解析出的 HTTP 响应结构体
r2error错误信息

示例

res, err := str.ParseStringToHTTPResponse("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")

ParseStringToHostPort​

ParseStringToHostPort(raw string) (host string, port int, err error)

尝试从字符串中解析出host和port，并与错误一起返回

参数

参数名类型说明
rawstring形如 host:port 或 URL 的字符串

返回值

序号类型说明
hoststring解析出的主机
portint解析出的端口
errerror错误信息

示例

host, port, err = str.ParseStringToHostPort("127.0.0.1:8888") // host = "127.0.0.1", port = 8888, err = nil
host, port, err = str.ParseStringToHostPort("https://example.com") // host = "example.com", port = 443, err = nil
host, port, err = str.ParseStringToHostPort("Hello Yak") // host = "", port = 0, err = error("unknown port for [Hello Yak]")

ParseStringToHosts​

ParseStringToHosts(raw string) []string

将字符串解析成 Host 列表， Host 可以以逗号、换行分隔，并且会解析 CIDR 网段

参数

参数名类型说明
rawstring主机字符串，支持逗号/换行分隔与 CIDR 网段

返回值

序号类型说明
r1[]string展开后的主机列表

示例

str.ParseStringToHosts("192.168.0.1/32,127.0.0.1") // ["192.168.0.1", "127.0.0.1"]

ParseStringToLines​

ParseStringToLines(raw string) []string

将字符串按换行符(\n)分割成字符串数组，并去除BOM头和空行

参数

参数名类型说明
rawstring原始多行字符串

返回值

序号类型说明
r1[]string去除 BOM 头与空行后的行字符串数组

示例

str.ParseStringToLines("Hello World\nHello Yak") // ["Hello World", "Hello Yak"]

ParseStringToPorts​

ParseStringToPorts(ports string) []int

将字符串解析成 Port 列表， Port 可以以逗号分隔，并且会解析-分隔的范围

参数

参数名类型说明
portsstring端口字符串，支持逗号分隔与短横线范围（如 "80,443,1000-1010"）

返回值

序号类型说明
r1[]int解析出的端口整数列表

示例

str.ParseStringToPorts("10086-10088,23333") // [10086, 10087, 10088, 23333]

ParseStringUrlToUrlInstance​

ParseStringUrlToUrlInstance(s string) (*url.URL, error)

将字符串 url 解析为 URL 结构体并返回错误

参数

参数名类型说明
sstring原始 URL 字符串

返回值

序号类型说明
r1*url.URL解析后的 URL 实例
r2error错误信息

示例

str.ParseStringUrlToUrlInstance("https://yaklang.com/abc?a=1")

ParseStringUrlToWebsiteRootPath​

ParseStringUrlToWebsiteRootPath(url string) (newURL string)

将字符串 url 解析为其根路径的URL

参数

参数名类型说明
urlstring原始 URL 字符串

返回值

序号类型说明
newURLstring仅保留根路径（去除路径与查询参数）后的 URL 字符串

示例

str.ParseStringUrlToWebsiteRootPath("https://yaklang.com/abc?a=1") // https://yaklang.com/

Quote​

Quote(s string) string

给字符串 s 加上双引号并转义其中的特殊字符，返回 Go 语法风格的带引号字符串。

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string带双引号并完成转义的字符串

示例

q = str.Quote("hello\nworld")
// 换行被转义为 \n，并加上首尾双引号
println(q)   // OUT: "hello\nworld"
assert q == "\"hello\\nworld\"", "Quote should escape special chars"

RandSecret​

RandSecret(n int) string

返回在所有可见ascii字符表中随机挑选 n 个字符组成的密码字符串，这个密码经过str.IsStrongPassword验证，即为强密码

参数

参数名类型说明
nint生成密码的长度（应大于 8 以满足强密码要求）

返回值

序号类型说明
r1string满足强密码要求的随机字符串

示例

str.RandSecret(10)

RandStr​

RandStr(n int) string

RandStringBytes 返回在大小写字母表中随机挑选 n 个字符组成的字符串

参数

参数名类型说明
nint生成字符串的长度

返回值

序号类型说明
r1string随机字母组成的字符串

示例

str.RandStr(10)

Random​

Random(s string) string

RandomUpperAndLower 返回一个随机大小写的字符串

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string随机切换字母大小写后的字符串（字母内容不变）

示例

out = str.RandomUpperAndLower("target")
// 仅大小写变化，小写化后应与原串相同
println(str.ToLower(out))   // OUT: target
assert str.ToLower(out) == "target", "RandomUpperAndLower should only flip letter case"

RandomUpperAndLower​

RandomUpperAndLower(s string) string

返回一个随机大小写的字符串

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string随机切换字母大小写后的字符串（字母内容不变）

示例

out = str.RandomUpperAndLower("target")
// 仅大小写变化，小写化后应与原串相同
println(str.ToLower(out))   // OUT: target
assert str.ToLower(out) == "target", "RandomUpperAndLower should only flip letter case"

RegexpMatch​

RegexpMatch(pattern string, s any) bool

使用正则尝试匹配字符串，如果匹配成功返回 true，否则返回 false

参数

参数名类型说明
patternstring正则表达式
sany待匹配的对象，会被转换为字符串

返回值

序号类型说明
r1bool是否匹配成功

示例

str.RegexpMatch("^[a-z]+$", "abc") // true

RemoveDuplicatePorts​

RemoveDuplicatePorts(ports1 string, ports2 string) []int

解析两个字符串形式的端口列表，并使用布谷鸟过滤器进行去重。

这个函数首先创建一个布谷鸟过滤器，然后将两个输入字符串解析为端口列表。

接着，它遍历这两个列表，将每个端口添加到布谷鸟过滤器中，如果这个端口之前没有被添加过，

那么它也会被添加到结果列表中。最后，函数返回结果列表，其中包含两个输入字符串中的所有唯一端口。

参数

参数名类型说明
ports1string第一个端口列表字符串
ports2string第二个端口列表字符串

返回值

序号类型说明
r1[]int两个端口列表合并去重后的端口整数列表

示例

ports = str.RemoveDuplicatePorts("10086-10088,23333", "10086,10089,23333") // [10086, 10087, 10088, 23333, 10089]
assert len(ports) == 5, "should merge and deduplicate ports"

RemoveRepeat​

RemoveRepeat(slc []string) []string

移除字符串切片slc中的重复元素

参数

参数名类型说明
slc[]string原始字符串切片

返回值

序号类型说明
r1[]string去除重复元素后的字符串切片（保持原有顺序）

示例

str.RemoveRepeat(["hello", "yak", "hello"]) // ["hello", "yak"]

RenderTemplate​

RenderTemplate(i string, m any) string

使用 m 中的数据渲染模板字符串 i（基于 Go text/template 语法），渲染失败时返回原始模板。

参数

参数名类型说明
istring模板字符串，例如 "hello {{ .name }}"
many模板数据，通常是一个 map

返回值

序号类型说明
r1string渲染后的字符串（失败时回退为原模板内容）

示例

out = str.RenderTemplate("hello {{ .name }}", {"name": "yak"})
println(out)   // OUT: hello yak
assert out == "hello yak", "RenderTemplate should fill template variables"

Repeat​

Repeat(s string, count int) string

返回将字符串s重复count次的字符串

参数

参数名类型说明
sstring原始字符串
countint重复次数

返回值

序号类型说明
r1string重复拼接后的字符串

示例

result = str.Repeat("hello", 3)
println(result)   // OUT: hellohellohello
assert result == "hellohellohello", "Repeat should repeat the string count times"

Replace​

Replace(s string, old string, new string, n int) string

返回将字符串s中前n个old字符串替换为new字符串的字符串

参数

参数名类型说明
sstring原始字符串
oldstring要被替换的子串
newstring替换成的子串
nint最多替换的次数（-1 表示全部）

返回值

序号类型说明
r1string替换后的字符串

示例

result = str.Replace("hello yak", "l", "L", 1)
println(result)   // OUT: heLlo yak
assert result == "heLlo yak", "Replace should replace only the first n occurrences"

ReplaceAll​

ReplaceAll(s string, old string, new string) string

返回将字符串s中所有old字符串替换为new字符串的字符串

参数

参数名类型说明
sstring原始字符串
oldstring要被替换的子串
newstring替换成的子串

返回值

序号类型说明
r1string替换全部匹配后的字符串

示例

result = str.ReplaceAll("hello yak", "yak", "yakit")
println(result)   // OUT: hello yakit
assert result == "hello yakit", "ReplaceAll should replace all occurrences"

ReplaceHTTPPacketBody​

ReplaceHTTPPacketBody(raw []byte, body []byte, chunk bool) (newHTTPRequest []byte)

ReplaceBody 将原始 HTTP 请求报文中的 body 替换为指定的 body，并指定是否为 chunked，返回新的 HTTP 请求报文

参数

参数名类型说明
raw[]byte原始 HTTP 报文字节数组
body[]byte替换后的报文主体内容
chunkbool是否使用 chunked 传输编码

返回值

序号类型说明
newHTTPRequest[]byte修改后的 HTTP 报文字节数组

示例

poc.ReplaceBody(`POST / HTTP/1.1
Host: example.com
Content-Length: 11

hello world`, "hello yak", false)

ShrinkString​

ShrinkString(i any, size int) string

str.ShrinkString 将会把一个字符串压缩成一个设定一个长度下的较短的字符串

参数

参数名类型说明
iany输入内容，会被转换为字符串
sizeint压缩后字符串的目标最大长度

返回值

序号类型说明
r1string压缩后的字符串，过长部分会用省略号替代

示例

result = str.ShrinkString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 20)
println(result)
/* output: aaaaaaaaaa...aaaaaaaaaa */

Split​

Split(s string, sep string) []string

将字符串s按照sep分割成字符串切片

参数

参数名类型说明
sstring原始字符串
sepstring分隔符

返回值

序号类型说明
r1[]string分割后的字符串切片

示例

parts = str.Split("Hello Yak", " ")
println(parts)   // OUT: [Hello Yak]
assert len(parts) == 2, "Split should produce two parts"
assert parts[0] == "Hello" && parts[1] == "Yak", "Split should split by separator"

SplitAfter​

SplitAfter(s string, sep string) []string

将字符串s按照sep分割成字符串切片，但是每个元素都会保留sep

参数

参数名类型说明
sstring原始字符串
sepstring分隔符

返回值

序号类型说明
r1[]string分割后的字符串切片，每个元素保留结尾的分隔符

示例

parts = str.SplitAfter("Hello-Yak", "-")
println(parts)   // OUT: [Hello- Yak]
assert len(parts) == 2, "SplitAfter should produce two parts"
assert parts[0] == "Hello-" && parts[1] == "Yak", "SplitAfter keeps the separator at element tail"

SplitAfterN​

SplitAfterN(s string, sep string, n int) []string

将字符串s按照sep分割成字符串切片，但是每个元素都会保留sep，最多分为n个元素

参数

参数名类型说明
sstring原始字符串
sepstring分隔符
nint最多分割出的元素个数

返回值

序号类型说明
r1[]string最多n个元素的字符串切片，每个元素保留结尾的分隔符

示例

parts = str.SplitAfterN("Hello-Yak-and-World", "-", 2)
println(parts)   // OUT: [Hello- Yak-and-World]
assert len(parts) == 2, "SplitAfterN should cap to n parts"
assert parts[0] == "Hello-" && parts[1] == "Yak-and-World", "SplitAfterN keeps separator and stops at n"

SplitAndTrim​

SplitAndTrim(Raw string, sep string) (targets []string)

将字符串s按照sep分割成字符串切片，并且去除每个字符串的前后空白字符

参数

参数名类型说明
Rawstring原始字符串
sepstring分隔符

返回值

序号类型说明
targets[]string分割并去除空白后的非空字符串切片

示例

str.SplitAndTrim(" hello yak ", " ") // ["hello", "yak"]

SplitN​

SplitN(s string, sep string, n int) []string

将字符串s按照sep分割成字符串切片，最多分为n个元素

参数

参数名类型说明
sstring原始字符串
sepstring分隔符
nint最多分割出的元素个数

返回值

序号类型说明
r1[]string最多n个元素的字符串切片

示例

parts = str.SplitN("Hello-Yak-and-World", "-", 2)
println(parts)   // OUT: [Hello Yak-and-World]
assert len(parts) == 2, "SplitN should cap to n parts"
assert parts[0] == "Hello" && parts[1] == "Yak-and-World", "SplitN should stop splitting at n"

StartsWith​

StartsWith(s string, prefix string) bool

/ HasPrefix 判断字符串s是否以prefix开头

参数

参数名类型说明
sstring原始字符串
prefixstring要判断的前缀

返回值

序号类型说明
r1bool是否以该前缀开头

示例

ok = str.StartsWith("Hello Yak", "Hello")
println(ok)   // OUT: true
assert ok == true, "StartsWith should match prefix"
assert str.StartsWith("Hello Yak", "Yak") == false, "StartsWith should reject non-prefix"

StringContainsAnyOfSubString​

StringContainsAnyOfSubString(s string, subs []string) bool

判断字符串s中是否包含subs中的任意一个子串

参数

参数名类型说明
sstring原始字符串
subs[]string待匹配的子串切片

返回值

序号类型说明
r1bool是否包含任意一个子串

示例

str.StringContainsAnyOfSubString("hello yak", ["yak", "world"]) // true

StringSliceContains​

StringSliceContains(s any, raw string) (result bool)

判断字符串切片s中是否包含raw，对于非字符串的切片，会尝试将其元素转换为字符串再判断是否包含

参数

参数名类型说明
sany字符串切片（或可转换为字符串元素的切片）
rawstring待查找的字符串

返回值

序号类型说明
resultbool切片中是否包含该字符串

示例

str.StringSliceContains(["hello", "yak"], "yak") // true
str.StringSliceContains([1, 2, 3], "4") // false

Subtract​

Subtract(x []string, y []string) []string

返回两个字符串切片的差集

参数

参数名类型说明
x[]string被减字符串切片
y[]string要减去的字符串切片

返回值

序号类型说明
r1[]string存在于 x 但不存在于 y 的元素组成的切片

示例

str.Subtract(["1", "2", "3"], ["3", "4", "5"]) // ["1", "2"]

TextReaderSplit​

TextReaderSplit(ctx context.Context, reader io.Reader) chan string

从 io.Reader 流式读取文本，并按分隔符与块大小递归切分，通过 channel 返回文本块

参数

参数名类型说明
ctxcontext.Context上下文，可用于取消操作
readerio.Reader提供文本数据的 io.Reader

返回值

序号类型说明
r1chan string一个不断产出文本块的 channel

示例

ch = str.TextReaderSplit(context.Background(), str.NewReader("段落一。段落二。"))
for chunk = range ch { println(chunk) }

TextSplit​

TextSplit(ctx context.Context, text string) []string

将文本按照分隔符与块大小递归切分为多个文本块

参数

参数名类型说明
ctxcontext.Context上下文，可用于取消操作
textstring待切分的文本

返回值

序号类型说明
r1[]string切分后的文本块列表

示例

chunks = str.TextSplit(context.Background(), "段落一。段落二。段落三。")
assert len(chunks) > 0, "TextSplit should produce chunks"

Title​

Title(s string) string

返回字符串s的标题化版本，即所有单词的首字母都是大写的

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string每个单词首字母大写后的字符串

示例

result = str.Title("hello yak")
println(result)   // OUT: Hello Yak
assert result == "Hello Yak", "Title should capitalize each word"

ToJsonIndentStr​

ToJsonIndentStr(d any) string

将v转换为格式化的JSON字符串并返回，如果转换失败，则返回空字符串

参数

参数名类型说明
dany任意可序列化为 JSON 的对象

返回值

序号类型说明
r1string带缩进的 JSON 字符串，失败返回空字符串

示例

s = str.ToJsonIndentStr({"hello": "yak"})
// 输出为带缩进的多行 JSON，这里打印是否包含关键字段
println(str.Contains(s, "hello"))   // OUT: true
assert str.Contains(s, "hello") && str.Contains(s, "yak"), "ToJsonIndentStr should serialize keys and values"

ToLower​

ToLower(s string) string

返回字符串s的小写形式

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string全部转为小写后的字符串

示例

result = str.ToLower("HELLO YAK")
println(result)   // OUT: hello yak
assert result == "hello yak", "ToLower should lowercase all letters"

ToLowerSpecial​

ToLowerSpecial(c unicode.SpecialCase, s string) string

使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为小写。

参数

参数名类型说明
cunicode.SpecialCase特殊大小写规则（如 unicode.TurkishCase）
sstring原始字符串

返回值

序号类型说明
r1string按指定规则转换为小写后的字符串

示例

// ToLowerSpecial 需要传入 unicode.SpecialCase 大小写映射规则(用于土耳其语等特殊语言)
// 常规转小写直接用 str.ToLower 即可
out = str.ToLower("ABC")
assert out == "abc", "lowercase should work"

ToStringSlice​

ToStringSlice(i any) (result []string)

将任意类型的数据转换为字符串切片

参数

参数名类型说明
iany任意类型的数据

返回值

序号类型说明
result[]string转换得到的字符串切片

示例

str.ToStringSlice("hello") // ["hello"]
str.ToStringSlice([1, 2]) // ["1", "2"]

ToTitle​

ToTitle(s string) string

返回字符串s的标题化版本，其中所有Unicode字母都会被转换为其大写

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string全部字母转为大写（Unicode title）后的字符串

示例

result = str.ToTitle("hello yak")
println(result)   // OUT: HELLO YAK
assert result == "HELLO YAK", "ToTitle should upper-case all letters"

ToTitleSpecial​

ToTitleSpecial(c unicode.SpecialCase, s string) string

使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为标题形式（Title Case）。

参数

参数名类型说明
cunicode.SpecialCase特殊大小写规则（如 unicode.TurkishCase）
sstring原始字符串

返回值

序号类型说明
r1string按指定规则转换为标题形式后的字符串

示例

// ToTitleSpecial 需要传入 unicode.SpecialCase 大小写映射规则(用于土耳其语等特殊语言)
// 常规转标题形式可用 str.Title
out = str.Title("hello world")
assert str.Contains(out, "Hello"), "title-case should capitalize words"

ToUpper​

ToUpper(s string) string

返回字符串s的大写形式

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string全部转为大写后的字符串

示例

result = str.ToUpper("hello yak")
println(result)   // OUT: HELLO YAK
assert result == "HELLO YAK", "ToUpper should uppercase all letters"

ToUpperSpecial​

ToUpperSpecial(c unicode.SpecialCase, s string) string

使用指定的字符大小写映射规则 c，把字符串 s 中的所有字符转换为大写。

参数

参数名类型说明
cunicode.SpecialCase特殊大小写规则（如 unicode.TurkishCase）
sstring原始字符串

返回值

序号类型说明
r1string按指定规则转换为大写后的字符串

示例

// ToUpperSpecial 需要传入 unicode.SpecialCase 大小写映射规则(用于土耳其语等特殊语言)
// 常规转大写直接用 str.ToUpper 即可
out = str.ToUpper("abc")
assert out == "ABC", "uppercase should work"

ToValidUTF8​

ToValidUTF8(s string, replacement string) string

返回将字符串s中无效的UTF-8编码替换为replacement的字符串

参数

参数名类型说明
sstring原始字符串
replacementstring无效 UTF-8 字节序列的替换串

返回值

序号类型说明
r1string修正后的合法 UTF-8 字符串

示例

result = str.ToValidUTF8("hello yak", "?")
println(result)   // OUT: hello yak
assert result == "hello yak", "ToValidUTF8 should keep valid input unchanged"

Trim​

Trim(s string, cutset string) string

返回将字符串s两侧所有包含cutset字符串中的字符都去掉的字符串

参数

参数名类型说明
sstring原始字符串
cutsetstring要从两侧去除的字符集合

返回值

序号类型说明
r1string去除两侧字符后的字符串

示例

result = str.Trim("Hello Yak", "Hk")
println(result)   // OUT: ello Ya
assert result == "ello Ya", "Trim should trim chars in cutset from both sides"

TrimLeft​

TrimLeft(s string, cutset string) string

返回将字符串s左侧所有包含cutset字符串中的字符都去掉的字符串

参数

参数名类型说明
sstring原始字符串
cutsetstring要从左侧去除的字符集合

返回值

序号类型说明
r1string去除左侧字符后的字符串

示例

result = str.TrimLeft("Hello Yak", "H")
println(result)   // OUT: ello Yak
assert result == "ello Yak", "TrimLeft should trim leading chars in cutset"

TrimPrefix​

TrimPrefix(s string, prefix string) string

返回将字符串s前缀prefix去掉的字符串

参数

参数名类型说明
sstring原始字符串
prefixstring要去除的前缀

返回值

序号类型说明
r1string去除前缀后的字符串；若不以prefix开头则原样返回

示例

result = str.TrimPrefix("HelloYak", "Hello")
println(result)   // OUT: Yak
assert result == "Yak", "TrimPrefix should drop the prefix"

TrimRight​

TrimRight(s string, cutset string) string

返回将字符串s右侧所有包含cutset字符串中的字符都去掉的字符串

参数

参数名类型说明
sstring原始字符串
cutsetstring要从右侧去除的字符集合

返回值

序号类型说明
r1string去除右侧字符后的字符串

示例

result = str.TrimRight("Hello Yak", "k")
println(result)   // OUT: Hello Ya
assert result == "Hello Ya", "TrimRight should trim trailing chars in cutset"

TrimSpace​

TrimSpace(s string) string

返回将字符串s两侧所有的空白字符都去掉的字符串

参数

参数名类型说明
sstring原始字符串

返回值

序号类型说明
r1string去除两侧空白字符后的字符串

示例

result = str.TrimSpace(" \t\n Hello Yak \n\t\r\n")
println(result)   // OUT: Hello Yak
assert result == "Hello Yak", "TrimSpace should strip surrounding whitespace"

TrimSuffix​

TrimSuffix(s string, suffix string) string

返回将字符串s后缀suffix去掉的字符串

参数

参数名类型说明
sstring原始字符串
suffixstring要去除的后缀

返回值

序号类型说明
r1string去除后缀后的字符串；若不以suffix结尾则原样返回

示例

result = str.TrimSuffix("HelloYak", "Yak")
println(result)   // OUT: Hello
assert result == "Hello", "TrimSuffix should drop the suffix"

Unquote​

Unquote(s string) (string, error)

把一个带引号的字符串（双引号、单引号或反引号）还原为原始字符串，失败时返回错误。

参数

参数名类型说明
sstring带引号的字符串

返回值

序号类型说明
r1string去除引号并反转义后的字符串
r2error错误信息

示例

raw = str.Unquote("\"hello\\nworld\"")~
assert raw == "hello\nworld", "Unquote should unescape quoted string"

VersionCompare​

VersionCompare(v1 string, v2 string) (int, error)

泛用形的版本比较,传入(p1,p2 string), p1>p2返回1,nil, p1<p2返回-1,nil, p1==p2返回0,nil, 比较失败返回 -2,err

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1int比较结果：v1>v2 返回 1，v1<v2 返回 -1，相等返回 0，比较失败返回 -2
r2error错误信息

示例

res, err = str.VersionCompare("1.2.0", "1.1.9") // res = 1

VersionEqual​

VersionEqual(v1 string, v2 string) bool

使用版本比较算法比较版本 v1 与版本 v2，如果 v1 等于 v2 返回 true，否则返回 false

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1boolv1 是否等于 v2

示例

str.VersionEqual("3.0", "3.0") // true
str.VersionEqual("3.0", "3.0a") // false

VersionGreater​

VersionGreater(v1 string, v2 string) bool

使用版本比较算法比较版本 v1 与版本 v2，如果 v1 大于 v2 返回 true，否则返回 false

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1boolv1 是否大于 v2

示例

str.VersionGreater("1.0.0", "0.9.9") // true
str.VersionGreater("3.0", "2.8.8alpha") // true

VersionGreaterEqual​

VersionGreaterEqual(v1 string, v2 string) bool

使用版本比较算法比较版本 v1 与版本 v2，如果 v1 大于等于 v2 返回 true，否则返回 false

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1boolv1 是否大于等于 v2

示例

str.VersionGreaterEqual("1.0.0", "0.9.9") // true
str.VersionGreaterEqual("3.0", "3.0") // true
str.VersionGreaterEqual("3.0", "3.0a") // false

VersionLess​

VersionLess(v1 string, v2 string) bool

使用版本比较算法比较版本 v1 与版本 v2，如果 v1 小于 v2 返回 true，否则返回 false

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1boolv1 是否小于 v2

示例

str.VersionLess("0.9.9", "1.0.0") // true
str.VersionLess("3.0", "3.0a") // true

VersionLessEqual​

VersionLessEqual(v1 string, v2 string) bool

使用版本比较算法比较版本 v1 与版本 v2，如果 v1 小于等于 v2 返回 true，否则返回 false

参数

参数名类型说明
v1string第一个版本号字符串
v2string第二个版本号字符串

返回值

序号类型说明
r1boolv1 是否小于等于 v2

示例

str.VersionLessEqual("0.9.9", "1.0.0") // true
str.VersionLessEqual("3.0", "3.0") // true
str.VersionLessEqual("3.0a", "3.0") // false

可变参数函数详情​

CalcSSDeepStability​

CalcSSDeepStability(req ...[]byte) (float64, error)

使用模糊哈希算法计算多段文本之间的相似度，返回相似度与错误。传入的文本应该为大文本，即长度大于 30 kb。

可选参数

参数名类型说明
req...[]byte两段或多段待比较的大文本字节

返回值

序号类型说明
r1float64相似度，取值范围 0~1
r2error错误信息

示例

p, err = str.CalcSSDeepStability(str.RandStr(100000), str.RandStr(100000))

CalcSimHashStability​

CalcSimHashStability(req ...[]byte) (float64, error)

使用 SimHash 算法计算多段文本之间的相似度，返回相似度与错误。

可选参数

参数名类型说明
req...[]byte两段或多段待比较的文本字节

返回值

序号类型说明
r1float64相似度，取值范围 0~1
r2error错误信息

示例

p, err = str.CalcSimHashStability("hello", "hello world") // p = 0.96484375

CalcSimilarity​

CalcSimilarity(raw ...[]byte) float64

计算多段文本之间的相似度，根据最长的文本长度选择不同的算法

如果最长的文本长度小于等于 2000，使用文本子串匹配算法

如果最短的文本长度大于等于 30000，使用模糊哈希算法

如果上述算法出现错误，则使用 SimHash 算法

可选参数

参数名类型说明
raw...[]byte两段或多段待比较的文本字节

返回值

序号类型说明
r1float64相似度，取值范围 0~1

示例

str.CalcSimilarity("hello", "hello world") // 0.625

CalcTextMaxSubStrStability​

CalcTextMaxSubStrStability(raw ...[]byte) (float64, error)

使用文本子串匹配算法计算多段文本之间的相似度，返回相似度与错误

可选参数

参数名类型说明
raw...[]byte两段或多段待比较的文本字节

返回值

序号类型说明
r1float64相似度，取值范围 0~1
r2error错误信息

示例

p, err = str.CalcTextMaxSubStrStability("hello", "hello world") // p = 0.625

ExtractDomain​

ExtractDomain(i any, tryDecode ...bool) []string

尝试提取字符串中的域名并返回，后续可以接收一个 tryDecode 参数，如果传入 true，则会尝试对输入的文本进行解码(双重URL编码，URL编码，unicode编码，quoted编码)

必填参数

参数名类型说明
iany任意可转为字符串的输入

可选参数

参数名类型说明
tryDecode...bool可选，是否在提取前尝试解码

返回值

序号类型说明
r1[]string提取到的域名数组

示例

domains = str.ExtractDomain("hello yaklang.com or yaklang.io")
println(len(domains))   // OUT: 2
assert len(domains) == 2, "ExtractDomain should extract both domains"

IsTLSServer​

IsTLSServer(addr string, proxies ...string) bool

尝试访问传入的host，然后判断其是否为 TLS 服务。第一个参数为 host，后面可以传入零个或多个参数，为代理地址

必填参数

参数名类型说明
addrstring目标地址（host:port）

可选参数

参数名类型说明
proxies...string可选的一个或多个代理地址

返回值

序号类型说明
r1bool目标是否为 TLS 服务

示例

str.IsTLSServer("www.yaklang.com:443") // true
str.IsTLSServer("www.yaklang.com:80") // false

MatchAllOfGlob​

MatchAllOfGlob(i any, re ...string) bool

尝试将 i 转换为字符串，然后使用 glob 匹配模式匹配，如果所有的glob模式都匹配成功，则返回 true，否则返回 false

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
re...string一个或多个 glob 模式

返回值

序号类型说明
r1bool是否所有 glob 模式都匹配成功

示例

str.MatchAllOfGlob("abc", "a*", "?b?", "[a-z]?c") // true

MatchAllOfRegexp​

MatchAllOfRegexp(i any, re ...string) bool

尝试将 i 转换为字符串，然后使用正则表达式匹配，如果所有的正则表达式都匹配成功，则返回 true，否则返回 false

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
re...string一个或多个正则表达式

返回值

序号类型说明
r1bool是否所有正则表达式都匹配成功

示例

str.MatchAllOfRegexp("abc", "a.+", ".?b.?", "\\w{2}c") // true

MatchAllOfSubString​

MatchAllOfSubString(i any, subStr ...string) bool

尝试将 i 转换为字符串，然后判断所有子串 subStr 是否都存在于 i 中，如果都存在则返回 true，否则返回 false，此函数忽略大小写

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
subStr...string一个或多个子串

返回值

序号类型说明
r1bool是否所有子串都存在于 i 中

示例

str.MatchAllOfSubString("abc", "a", "b", "c") // true

MatchAnyOfGlob​

MatchAnyOfGlob(i any, re ...string) bool

尝试将 i 转换为字符串，然后使用 glob 匹配模式匹配，如果任意一个glob模式匹配成功，则返回 true，否则返回 false

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
re...string一个或多个 glob 模式

返回值

序号类型说明
r1bool是否有任意 glob 模式匹配成功

示例

str.MatchAnyOfGlob("abc", "a*", "??b", "[^a-z]?c") // true

MatchAnyOfRegexp​

MatchAnyOfRegexp(i any, re ...string) bool

尝试将 i 转换为字符串，然后使用正则表达式匹配，如果任意一个正则表达式匹配成功，则返回 true，否则返回 false

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
re...string一个或多个正则表达式

返回值

序号类型说明
r1bool是否有任意正则表达式匹配成功

示例

str.MatchAnyOfRegexp("abc", "a.+", "Ab.?", ".?bC") // true

MatchAnyOfSubString​

MatchAnyOfSubString(i any, subStr ...string) bool

尝试将 i 转换为字符串，然后判断是否有任意子串 subStr 存在于 i 中，如果有其中一个子串存在于 i 中则返回 true，否则返回 false，此函数忽略大小写

必填参数

参数名类型说明
iany待匹配的对象，会被转换为字符串

可选参数

参数名类型说明
subStr...string一个或多个子串

返回值

序号类型说明
r1bool是否存在任意子串于 i 中

示例

str.MatchAnyOfSubString("abc", "a", "z", "x") // true

ParseStringToUrls​

ParseStringToUrls(targets ...string) []string

尝试从给定的字符串(ip,域名)中解析出 URL 列表，补全协议和端口

可选参数

参数名类型说明
targets...string一个或多个目标字符串（IP、域名或 host:port）

返回值

序号类型说明
r1[]string补全协议与端口后的 URL 列表

示例

str.ParseStringToUrls("yaklang.com:443", "https://yaklang.io") // [https://yaklang.com, https://yaklang.io]

ParseStringToUrlsWith3W​

ParseStringToUrlsWith3W(sub ...string) []string

尝试从给定的字符串(ip,域名)中解析出 URL 列表，补全协议和端口，还会补全域名前的 www 前缀

可选参数

参数名类型说明
sub...string一个或多个目标字符串（IP、域名或 host:port）

返回值

序号类型说明
r1[]string补全协议、端口与 www 前缀后的 URL 列表

示例

str.ParseStringToUrlsWith3W("yaklang.com:443", "https://yaklang.io") // [https://yaklang.com, https://www.yaklang.com, https://yaklang.io, https://www.yaklang.io]

PathJoin​

PathJoin(elem ...string) (newPath string)

将传入的文件路径进行拼接并返回

可选参数

参数名类型说明
elem...string任意数量的路径片段

返回值

序号类型说明
newPathstring用系统分隔符拼接后的路径

示例

// *nix 下使用 / 作为分隔符
p = str.PathJoin("/var", "www", "html")
println(p)   // OUT: /var/www/html
assert p == "/var/www/html", "PathJoin should join path segments"

SplitHTTPHeadersAndBodyFromPacket​

SplitHTTPHeadersAndBodyFromPacket(raw []byte, hook ...func(line string)) (headers string, body []byte)

将传入的 HTTP 报文分割为 headers 和 body，如果传入了hook，则会在每次读取到一行 header 时调用 hook

必填参数

参数名类型说明
raw[]byte原始 HTTP 报文字节

可选参数

参数名类型说明
hook...func(line string)可选的逐行 header 回调函数

返回值

序号类型说明
headersstring报文头部字符串
body[]byte报文体字节

示例

headers, body = str.SplitHTTPHeadersAndBodyFromPacket(b"GET / HTTP/1.1\r\nHost: www.yaklang.com\r\n\r\n")

SplitHostsToPrivateAndPublic​

SplitHostsToPrivateAndPublic(hosts ...string) (privs []string, pub []string)

将 hosts 按照私有 IP 和公有 IP 分开

可选参数

参数名类型说明
hosts...string一个或多个主机/IP 字符串

返回值

序号类型说明
privs[]string私有 IP 列表
pub[]string公有 IP 列表

示例

str.SplitHostsToPrivateAndPublic("127.0.0.1", "8.8.8.8", "10.0.0.1") // ["127.0.0.1", "10.0.0.1"], ["8.8.8.8"]

StringSliceContainsAll​

StringSliceContainsAll(s []string, elements ...string) bool

判断字符串切片s中是否完全包含elements中的所有元素，对于非字符串的切片，会尝试将其元素转换为字符串再判断是否包含

必填参数

参数名类型说明
s[]string字符串切片

可选参数

参数名类型说明
elements...string待检查的一个或多个元素

返回值

序号类型说明
r1bool切片是否包含所有给定元素

示例

str.StringSliceContainsAll(["hello", "yak"], "hello", "yak") // true
str.StringSliceContainsAll(["hello", "yak"], "hello", "yak", "world") // false

UrlJoin​

UrlJoin(origin string, paths ...string) (newURL string, err error)

将 字符串 origin 和 字符串数组 paths 拼接成一个新的 URL 字符串，并返回错误

必填参数

参数名类型说明
originstring基础 URL

可选参数

参数名类型说明
paths...string一个或多个待拼接的路径片段

返回值

序号类型说明
newURLstring拼接后的新 URL
errerror错误信息

示例

newURL, err = str.UrlJoin("https://yaklang.com", "asd", "qwe") // newURL = "https://yaklang.com/asd/qwe", err = nil
newURL, err = str.UrlJoin("https://yaklang.com/zxc", "/asd", "qwe") // newURL = "https://yaklang.com/asd/qwe", err = nil

f​

f(f string, items ...any) string

用于对字符串进行格式化

必填参数

参数名类型说明
fstring格式化模板字符串（使用 %s、%d 等占位符）

可选参数

参数名类型说明
items...any填充到占位符的参数

返回值

序号类型说明
r1string格式化后的字符串

示例

str.f("hello %s", "yak") // hello yak