Signed-off-by: lxinyu <lxinyu@lxinyu.cn>

2024-11-02 16:47:10 +08:00 · 2024-11-02 16:47:10 +08:00 · 40ccca6384
commit 40ccca6384
parent 60cf6ea244
8 changed files with 1700 additions and 0 deletions
--- a/1.go
+++ b/1.go
@ -0,0 +1,193 @@
+package c
+
+// [\x00-\x7F]
+// [\xC0-\xDF][\x80-\xBF]
+// [\xE0-\xEF][\x80-\xBF]{2}
+// [\xF0-\xF7][\x80-\xBF]{3}
+type utf8 struct {
+	byte
+}
+
+func (u utf8) String() string {
+	return "utf-8"
+}
+
+func (u *utf8) Feed(x byte) bool {
+	if u.byte == 0 {
+		if x >= 0x00 && x <= 0x7F {
+			return true
+		}
+		if x >= 0xC0 && x <= 0xDF {
+			u.byte = 1
+			return true
+		}
+		if x >= 0xE0 && x <= 0xEF {
+			u.byte = 2
+			return true
+		}
+		if x >= 0xF0 && x <= 0xF7 {
+			u.byte = 3
+			return true
+		}
+	} else {
+		if x >= 0x80 && x <= 0xBF {
+			u.byte -= 1
+			return true
+		}
+	}
+	return false
+}
+
+func (u utf8) Priority() float64 {
+	return 0
+}
+
+// [\x00-\xD7\xE0-\xFF][\x00-\xFF]
+// [\xD8-\xDB][\x00-\xFF][\xDC-\DF][\x00-\xFF]
+type utf16BE struct {
+	byte
+}
+
+func (u utf16BE) String() string {
+	return "utf-16be"
+}
+
+func (u *utf16BE) Feed(x byte) bool {
+	switch u.byte {
+	case 0:
+		if (x >= 0x00 && x <= 0xD7) || (x >= 0xE0 && x <= 0xFF) {
+			u.byte = 1
+			return true
+		}
+		if x >= 0xD8 && x <= 0xDB {
+			u.byte = 2
+			return true
+		}
+	case 1:
+		u.byte = 0
+		return true
+	case 2:
+		u.byte = 3
+		return true
+	default:
+		if x >= 0xDC && x <= 0xDF {
+			u.byte = 1
+			return true
+		}
+	}
+	return false
+}
+
+func (u utf16BE) Priority() float64 {
+	return 0
+}
+
+// [\x00-\xFF][\x00-\xD7\xE0-\xFF]
+// [\x00-\xFF][\xD8-\xDB][\x00-\xFF][\xDC-\DF]
+type utf16LE struct {
+	byte
+}
+
+func (u utf16LE) String() string {
+	return "utf-16le"
+}
+
+func (u *utf16LE) Feed(x byte) bool {
+	switch u.byte {
+	case 0:
+		u.byte = 1
+		return true
+	case 1:
+		if (x >= 0x00 && x <= 0xD7) || (x >= 0xE0 && x <= 0xFF) {
+			u.byte = 0
+			return true
+		}
+		if x >= 0xD8 && x <= 0xDB {
+			u.byte = 2
+			return true
+		}
+	case 2:
+		u.byte = 3
+		return true
+	default:
+		if x >= 0xDC && x <= 0xDF {
+			u.byte = 0
+			return true
+		}
+	}
+	return false
+}
+
+func (u utf16LE) Priority() float64 {
+	return 0
+}
+
+// \x00[\x00-\x0F][\x00-\xFF]{2}
+type utf32BE struct {
+	byte
+}
+
+func (u utf32BE) String() string {
+	return "utf-32be"
+}
+
+func (u *utf32BE) Feed(x byte) bool {
+	switch u.byte {
+	case 0:
+		if x == 0x00 {
+			u.byte = 1
+			return true
+		}
+	case 1:
+		if x >= 0x00 && x <= 0x1F {
+			u.byte = 2
+			return true
+		}
+	case 2:
+		u.byte = 3
+		return true
+	default:
+		u.byte = 0
+		return true
+	}
+	return false
+}
+
+func (u utf32BE) Priority() float64 {
+	return 0
+}
+
+// [\x00-\xFF]{2}[\x00-\x0F]\x00
+type utf32LE struct {
+	byte
+}
+
+func (u utf32LE) String() string {
+	return "utf-32le"
+}
+
+func (u *utf32LE) Feed(x byte) bool {
+	switch u.byte {
+	case 0:
+		u.byte = 1
+		return true
+	case 1:
+		u.byte = 2
+		return true
+	case 2:
+		if x >= 0x00 && x <= 0x1F {
+			u.byte = 3
+			return true
+		}
+	default:
+		if x == 0x00 {
+			u.byte = 0
+			return true
+		}
+	}
+	return false
+}
+
+func (u utf32LE) Priority() float64 {
+	return 0
+}
--- a/go.mod
+++ b/go.mod
@ -0,0 +1,8 @@
+module c
+
+go 1.18
+
+require (
+	github.com/gogf/gf v1.16.8 // indirect
+	golang.org/x/text v0.3.7 // indirect
+)
--- a/go.sum
+++ b/go.sum
@ -0,0 +1,38 @@
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/clbanning/mxj v1.8.5-0.20200714211355-ff02cfb8ea28/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/gogf/gf v1.16.8 h1:iVXUB+QPQIYDMMjMdDb6ZINF8xf5bWy54XxAo600zMs=
+github.com/gogf/gf v1.16.8/go.mod h1:8Q/kw05nlVRp+4vv7XASBsMe9L1tsVKiGoeP2AHnlkk=
+github.com/gomodule/redigo v1.8.5/go.mod h1:P9dn9mFrCBvWhGE1wpxx6fgq7BAeLBk+UUUzlpkBYO0=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grokify/html-strip-tags-go v0.0.1/go.mod h1:2Su6romC5/1VXOQMaWL2yb618ARB8iVo6/DR99A6d78=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+go.opentelemetry.io/otel v1.0.0/go.mod h1:AjRVh9A5/5DE7S+mZtTR6t8vpKKryam+0lREnfmS4cg=
+go.opentelemetry.io/otel/trace v1.0.0/go.mod h1:PXTWqayeFUlJV1YDNhsJYB184+IvAH814St6o6ajzIs=
+golang.org/x/net v0.0.0-20210520170846-37e1c6afe023/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/z/注册表.go
+++ b/z/注册表.go
@ -0,0 +1,136 @@
+package z
+
+import (
+	. "gitlab.lxinyu.cn/lxinyu/go/c"
+
+	"github.com/golang/sys/windows/registry"
+)
+
+var KEY根类 = registry.CLASSES_ROOT
+var KEY现行设置 = registry.CURRENT_CONFIG
+var KEY现行用户 = registry.CURRENT_USER
+var KEY本地机器 = registry.LOCAL_MACHINE
+var KEY所有用户 = registry.USERS
+
+func Z取注册项文本(根目录 registry.Key, 目录, 子项 string) string {
+	key, exists, err := registry.CreateKey(根目录, 目录, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS) // registry.ALL_ACCESS
+	if err != nil {
+		return "1" + err.Error()
+	}
+	defer key.Close()
+	if exists == false {
+		return "2"
+	}
+	QWQ, _, _ := key.GetStringValue(子项)
+	return QWQ
+}
+func Z取注册项数值(根目录 registry.Key, 目录, 子项 string) int64 {
+	key, exists, err := registry.CreateKey(根目录, 目录, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS) // registry.ALL_ACCESS
+	if err != nil {
+		return 0
+	}
+	defer key.Close()
+	if exists == false {
+		return 0
+	}
+	QWQ, _, _ := key.GetIntegerValue(子项)
+	return int64(QWQ)
+}
+func Z写注册项文本(根目录 registry.Key, 目录, 子项, 内容 string) {
+	key, _, err := registry.CreateKey(根目录, 目录, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS)
+	if err != nil {
+		C日记("写err", err, 目录, 子项, 内容)
+		return
+	}
+	C日记("写", 目录, 子项, 内容)
+	defer key.Close()
+	key.SetStringValue(子项, 内容)
+}
+func Z写注册项整数(根目录 registry.Key, 目录, 子项 string, 内容 int64) {
+	key, _, err := registry.CreateKey(根目录, 目录, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS)
+	if err != nil {
+		return
+	}
+	defer key.Close()
+	key.SetQWordValue(子项, uint64(内容))
+}
+func Z删除注册项(根目录 registry.Key, 目录, 子项 string) {
+	key, exists, err := registry.CreateKey(根目录, 目录, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS)
+	if err != nil {
+		return
+	}
+	defer key.Close()
+	if exists == false {
+		return
+	}
+	subkey, _, _ := registry.CreateKey(key, 子项, registry.ALL_ACCESS)
+	defer subkey.Close()
+}
+func Z添加右键打开(软件名, 路径, 参数 string) bool {
+	//C日记(55)
+	if 软件名 == "" || 路径 == "" {
+		C日记("qwq", 软件名, 路径)
+		return false
+	}
+	Z写注册项文本(KEY根类, "*\\shell\\"+软件名+"\\command", "", 路径+" %1"+参数)
+	return true
+}
+func pp() {
+	/*
+	   key, exists, err := registry.CreateKey(registry.CURRENT_USER, "SOFTWARE\\Hello Go", registry.ALL_ACCESS)
+	   	if err != nil {
+	   		log.Fatal(err)
+	   	}
+	   	defer key.Close()
+
+	   	if exists {
+	   		fmt.Println("键已存在")
+	   	} else {
+	   		fmt.Println("新建注册表键")
+	   	}
+
+	   	// 写入32位整形值
+	   	key.SetDWordValue("DWORD", 0xFFFFFFFF)
+
+	   	// 写入64位整形值
+	   	key.SetQWordValue("QDWORD", 0xFFFFFFFFFFFFFFFF)
+
+	   	// 写入字符串
+	   	key.SetStringValue("String", "hello")
+
+	   	// 写入多行字符串
+	   	key.SetStringsValue("Strings", []string{"hello", "world"})
+
+	   	// 写入二进制
+	   	key.SetBinaryValue("Binary", []byte{0x11, 0x22})
+
+	   	// 读取字符串值
+	   	s, _, _ := key.GetStringValue("String")
+	   	fmt.Println(s)
+
+	   	// 枚举所有值名称
+	   	values, _ := key.ReadValueNames(0)
+	   	fmt.Println(values)
+
+	   	// 创建三个子键
+	   	subkey1, _, _ := registry.CreateKey(key, "Sub1", registry.ALL_ACCESS)
+	   	subkey2, _, _ := registry.CreateKey(key, "Sub2", registry.ALL_ACCESS)
+	   	subkey3, _, _ := registry.CreateKey(subkey1, "Sub3", registry.ALL_ACCESS)
+	   	defer subkey1.Close()
+	   	defer subkey2.Close()
+	   	defer subkey3.Close()
+
+	   	// 枚举所有子键
+	   	keys, _ := key.ReadSubKeyNames(0)
+	   	fmt.Println(keys)
+
+	   	// 该键有子项，所以会删除失败
+	   	err = registry.DeleteKey(key, "Sub1")
+	   	if err != nil {
+	   		fmt.Println(err)
+	   	}
+
+	       // 没有子项，删除成功
+	   	registry.DeleteKey(key, "Sub2")
+	*/
+}
--- a/常用.go
+++ b/常用.go
@ -0,0 +1,970 @@
+package c
+
+import (
+	"crypto/md5"
+	"crypto/rc4"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/gogf/gf/encoding/gbase64"
+	"github.com/gogf/gf/encoding/gurl"
+	"github.com/gogf/gf/os/gtime"
+	"github.com/gogf/gf/util/gconv"
+	"golang.org/x/text/encoding/simplifiedchinese"
+)
+
+// 调用格式： 〈文本型〉 Base64编码 （字节集 编码数据，［文本型 编码表］） - E2EE互联网服务器套件2.2.3->文本处理
+// 英文名称：Base64Encode
+// 将数据编码到Base64。本命令为初级命令。
+// 参数<1>的名称为“编码数据”，类型为“字节集（bin）”。要编码的字节集数据。
+// 参数<2>的名称为“编码表”，类型为“文本型（text）”，可以被省略。除特殊情况下，不建议使用本参数。如果使用本参数，那么编码表长度必须为64位，否则会编码失败。默认编码表：“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”。
+//
+// 操作系统需求： Windows
+func CBase64编码(data []byte) string {
+	return gbase64.EncodeToString(data)
+}
+
+// 调用格式： 〈字节集〉 Base64解码 （文本型 解码内容，［文本型 编码表］） - E2EE互联网服务器套件2.2.3->文本处理
+// 英文名称：Base64Decode
+// 解码Base64文本到数据。本命令为初级命令。
+// 参数<1>的名称为“解码内容”，类型为“文本型（text）”。要解码的文本数据。
+// 参数<2>的名称为“编码表”，类型为“文本型（text）”，可以被省略。除特殊情况下，不建议使用本参数。如果使用本参数，那么编码表长度必须为64位，否则会解码失败。默认编码表：“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”。
+//
+// 操作系统需求： Windows
+func CBase64解码(data string) string {
+	str, _ := gbase64.DecodeToString(data)
+	return str
+}
+
+// 调用格式： 〈文本型〉 URL编码 （文本型 编码文本，［文本型 编码格式］） - E2EE互联网服务器套件2.2.3->文本处理
+// 英文名称：URLEncode
+// 编码URL内容。本命令为初级命令。
+// 参数<1>的名称为“编码文本”，类型为“文本型（text）”。要进行URL编码的文本内容。
+// 参数<2>的名称为“编码格式”，类型为“文本型（text）”，可以被省略。指定编码格式。可使用“#文本编码格式_”开头的常量指定。如果为空则默认原始编码。
+//
+// 操作系统需求： Windows
+func CURL编码(str string) string {
+	return gurl.Encode(str)
+}
+
+// 调用格式： 〈文本型〉 URL解码 （文本型 解码文本，［文本型 编码格式］） - E2EE互联网服务器套件2.2.3->文本处理
+// 英文名称：URLDecode
+// 解码URL内容。本命令为初级命令。
+// 参数<1>的名称为“解码文本”，类型为“文本型（text）”。要进行URL编码的文本内容。
+// 参数<2>的名称为“编码格式”，类型为“文本型（text）”，可以被省略。指定编码格式。可使用“#文本编码格式_”开头的常量指定。如果为空则默认为原始的编码。
+//
+// 操作系统需求： Windows
+func CURL解码(str string) string {
+	s, _ := gurl.Decode(str)
+	return s
+}
+
+// component -1: all; 1: scheme; 2: host; 4: port; 8: user; 16: pass; 32: path; 64: query; 128: fragment. See http://php.net/manual/en/function.parse-url.php.
+func CURL解析(str string, component int) map[string]string {
+	s, _ := gurl.ParseURL(str, component)
+	return s
+}
+func C编码_utf8到gbk(str string) string {
+	gbkData, _ := simplifiedchinese.GBK.NewEncoder().Bytes([]byte(str)) //使用官方库将utf-8转换为gbk
+	return string(gbkData)
+}
+
+func C编码_gbk到utf8(str string) string {
+	gbkData, _ := simplifiedchinese.GBK.NewDecoder().Bytes([]byte(str))
+	return string(gbkData)
+}
+
+/*
+*    C延时 毫秒
+ */
+func C延时(毫秒 int64) {
+	time.Sleep(time.Duration(毫秒) * time.Millisecond)
+}
+
+/*
+*    C时间now
+ */
+func C时间now() string {
+	return gtime.Now().Format("YmdHis")
+}
+
+// 调用格式： 〈文本型〉 C时间nowF （文本型 时间格式）
+// 参数<1>的名称为“解码文本”，类型为“文本型（text）”。 时间格式 默认为 "Y-m-d H:i:s"
+func C时间nowF(格式 string) string {
+	return gtime.Now().Format(C选择文本(格式 == "", "Y-m-d H:i:s", 格式))
+}
+
+/*
+*    C转换字节转为 B KB MB GB T
+ */
+func C转换(b float64) string {
+	if b/1024/1024/1024/1024 > 1 {
+		return fmt.Sprintf("%.2f TB", b/1024/1024/1024/1024)
+	} else if b/1024/1024/1024 > 1 {
+		return fmt.Sprintf("%.2f GB", b/1024/1024/1024)
+	} else if b/1024/1024 > 1 {
+		return fmt.Sprintf("%.2f MB", b/1024/1024)
+	} else if b/1024 > 1 {
+		return fmt.Sprintf("%.2f KB", b/1024)
+	} else {
+		return fmt.Sprintf("%.2f B", b)
+	}
+}
+
+// 日记带时间 qwq
+func C日记(a ...interface{}) {
+	log.Println(a...)
+}
+func C日记f(from string, a ...interface{}) {
+	log.Printf(from, a...)
+}
+func C结束信息(v ...interface{}) {
+	log.Fatalln(v)
+}
+func C结束信息f(format string, v ...interface{}) {
+	log.Fatalf(format, v)
+}
+
+// 除了名称 版本外 都可空!
+// 额 啥啊
+func C说明(名称, 版本, 作者, 主页, 邮箱 string) {
+	/*
+		@Author: lxinyu.cn
+		@Date: 2019-01-16 23:37:38
+		@Last Modified by:   成精的宅货ゝ
+		@Last Modified time: 2019-01-16 23:37:38
+	*/
+	/*
+		C日记("--------------------------------")
+		C日记("作者: " + C选择文本(作者 == "", "成精的宅货", 作者))
+		C日记("主页: " + C选择文本(主页 == "", "https://www.lxinyu.cn", 主页))
+		C日记("邮箱: " + C选择文本(邮箱 == "", "lxinyu@lxinyu.cn", 邮箱))
+		C日记("名称: " + 名称)
+		C日记("版本: " + 版本)
+		C日记("--------------------------------")
+	*/
+	/*
+		数据 := "------------"
+		数据 = 数据 + "\n    作者: " + C选择文本(作者 == "", "成精的宅货", 作者)
+		数据 = 数据 + "\n    主页: " + C选择文本(主页 == "", "https://www.lxinyu.cn", 主页)
+		数据 = 数据 + "\n    邮箱: " + C选择文本(邮箱 == "", "lxinyu@lxinyu.cn", 邮箱)
+		数据 = 数据 + "\n    名称: " + 名称
+		数据 = 数据 + "\n    版本: " + 版本
+		C日记(数据)
+		C日记("------------")
+	*/
+	fmt.Println("------------------------------------------")
+	fmt.Println("作者:", "\t", C选择文本(作者 == "", "成精的宅货", 作者))
+	fmt.Println("主页:", "\t", C选择文本(主页 == "", "https://www.lxinyu.cn", 主页))
+	fmt.Println("邮箱:", "\t", C选择文本(邮箱 == "", "lxinyu@lxinyu.cn", 邮箱))
+	fmt.Println("名称:", "\t", 名称)
+	fmt.Println("版本:", "\t", 版本)
+	fmt.Println("启动:", "\t", C时间nowF(""))
+	fmt.Println("------------------------------------------")
+}
+func C取md5从文本(str string) string {
+	h := md5.New()
+	h.Write([]byte(str))
+	return hex.EncodeToString(h.Sum(nil))
+}
+func C取md5(data []byte) string {
+	h := md5.New()
+	h.Write(data)
+	return hex.EncodeToString(h.Sum(nil))
+}
+func Cmd5文本(数据 string, 是否大写, 是否十六位 bool) string {
+	ss := C取md5从文本(数据)
+	if 是否大写 == true {
+		ss = C到大写(ss)
+	}
+	if 是否十六位 == true {
+		ss = ss[8:24]
+	}
+	return ss
+}
+
+// 调用格式： 〈整数型〉 取文本长度 （文本型 文本数据） - 系统核心支持库->文本操作
+// 英文名称：len
+// 取文本型数据的长度，不包含结束0。本命令为初级命令。
+// 参数<1>的名称为“文本数据”，类型为“文本型（text）”。参数值指定欲检查其长度的文本数据。
+//
+// 操作系统需求： Windows、Linux
+func C取文本长度(value string) int64 {
+	return C到整数(len([]rune(value)))
+}
+
+// 调用格式： 〈文本型〉 取文本左边 （文本型 欲取其部分的文本，整数型 欲取出字符的数目） - 系统核心支持库->文本操作
+// 英文名称：left
+// 返回一个文本，其中包含指定文本中从左边算起指定数量的字符。本命令为初级命令。
+// 参数<1>的名称为“欲取其部分的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲取出字符的数目”，类型为“整数型（int）”。
+//
+// 操作系统需求： Windows、Linux
+func C取文本左边(欲取其部分的文本 string, 欲取出字符的数目 int64) string {
+	if C取文本长度(欲取其部分的文本) < 欲取出字符的数目 {
+		欲取出字符的数目 = C取文本长度(欲取其部分的文本)
+	}
+	return string([]rune(欲取其部分的文本)[:欲取出字符的数目])
+}
+
+// 调用格式： 〈文本型〉 取文本右边 （文本型 欲取其部分的文本，整数型 欲取出字符的数目） - 系统核心支持库->文本操作
+// 英文名称：right
+// 返回一个文本，其中包含指定文本中从右边算起指定数量的字符。本命令为初级命令。
+// 参数<1>的名称为“欲取其部分的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲取出字符的数目”，类型为“整数型（int）”。
+//
+// 操作系统需求： Windows、Linux
+func C取文本右边(欲取其部分的文本 string, 欲取出字符的数目 int64) string {
+	l := C取文本长度(欲取其部分的文本)
+	lpos := l - 欲取出字符的数目
+	if lpos < 0 {
+		lpos = 0
+	}
+	return string([]rune(欲取其部分的文本)[lpos:l])
+}
+
+// 调用格式： 〈文本型〉 取中间文本 （文本型 欲取其部分的文本，整数型 起始取出位置，整数型 欲取出字符的数目） - 系统核心支持库->文本操作
+// 英文名称：Index
+// 返回一个文本，其中包含指定文本中从右边算起指定数量的字符。本命令为初级命令。
+// 参数<1>的名称为“欲取其部分的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“起始取出位置”，类型为“整数型（int）”。
+// 参数<3>的名称为“欲取出字符的数目”，类型为“整数型（int）”。
+//
+// 操作系统需求： Windows、Linux
+func C取文本中间(欲取其部分的文本 string, 起始取出位置, 欲取出字符的数目 int) string {
+	rs := []rune(欲取其部分的文本)
+	rl := len(rs)
+	end := 0
+	if 起始取出位置 < 0 {
+		起始取出位置 = rl - 1 + 起始取出位置
+	}
+	end = 起始取出位置 + 欲取出字符的数目
+
+	if 起始取出位置 > end {
+		起始取出位置, end = end, 起始取出位置
+	}
+
+	if 起始取出位置 < 0 {
+		起始取出位置 = 0
+	}
+	if 起始取出位置 > rl {
+		起始取出位置 = rl
+	}
+	if end < 0 {
+		end = 0
+	}
+	if end > rl {
+		end = rl
+	}
+	return string(rs[起始取出位置:end])
+}
+
+// 调用格式： 〈文本型〉 字符 （字节型 欲取其字符的字符代码） - 系统核心支持库->文本操作
+// 英文名称：chr
+// 返回一个文本，其中包含有与指定字符代码相关的字符。本命令为初级命令。
+// 参数<1>的名称为“欲取其字符的字符代码”，类型为“字节型（byte）”。
+//
+// 操作系统需求： Windows、Linux
+func C字符(字节型 int8) string {
+	return string(byte(字节型))
+}
+
+// 调用格式： 〈整数型〉 寻找文本 （文本型 被搜寻的文本，文本型 欲寻找的文本，［整数型 起始搜寻位置］，逻辑型 是否不区分大小写） - 系统核心支持库->文本操作
+// 英文名称：InStr
+// 返回一个整数值，指定一文本在另一文本中最先出现的位置，位置值从 1 开始。如果未找到，返回-1。本命令为初级命令。
+// 参数<1>的名称为“被搜寻的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲寻找的文本”，类型为“文本型（text）”。
+// 参数<3>的名称为“起始搜寻位置”，类型为“整数型（int）”，可以被省略。位置值从 1 开始。如果本参数被省略，默认为 1 。
+// 参数<4>的名称为“是否不区分大小写”，类型为“逻辑型（bool）”，初始值为“假”。为真不区分大小写，为假区分。
+//
+// 操作系统需求： Windows、Linux
+func C寻找文本(被搜寻的文本 string, 欲寻找的文本 string) int {
+	return strings.Index(被搜寻的文本, 欲寻找的文本)
+}
+
+// 调用格式： 〈整数型〉 倒找文本 （文本型 被搜寻的文本，文本型 欲寻找的文本，［整数型 起始搜寻位置］，逻辑型 是否不区分大小写） - 系统核心支持库->文本操作
+// 英文名称：InStrRev
+// 返回一个整数值，指定一文本在另一文本中最后出现的位置，位置值从 1 开始。如果未找到，返回-1。本命令为初级命令。
+// 参数<1>的名称为“被搜寻的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲寻找的文本”，类型为“文本型（text）”。
+// 参数<3>的名称为“起始搜寻位置”，类型为“整数型（int）”，可以被省略。位置值从 1 开始。如果本参数被省略，默认为从被搜寻文本的尾部开始。
+// 参数<4>的名称为“是否不区分大小写”，类型为“逻辑型（bool）”，初始值为“假”。为真不区分大小写，为假区分。
+//
+// 操作系统需求： Windows、Linux
+func C倒找文本(被搜寻的文本 string, 欲寻找的文本 string) int {
+	return strings.LastIndex(被搜寻的文本, 欲寻找的文本)
+}
+
+/*
+调用格式： 〈文本型〉 到大写 （文本型 欲变换的文本） - 系统核心支持库->文本操作
+英文名称：UCase
+将文本中的小写英文字母变换为大写，返回变换后的结果文本。本命令为初级命令。
+参数<1>的名称为“欲变换的文本”，类型为“文本型（text）”。
+操作系统需求： Windows、Linux
+*/
+func C到大写(value string) string {
+	return strings.ToUpper(value)
+}
+func C到小写(value string) string {
+	return strings.ToLower(value)
+}
+
+/*
+	func C到半角(value string) string {
+		return dBCtoSBCNew(value)
+	}
+
+	func C到整数(value interface{}) int64 {
+		return gconv.Int64(value)
+	}
+*/
+func C到字节集(value interface{}) []byte {
+	return gconv.Bytes(value)
+}
+func C到字节(value interface{}) byte {
+	return gconv.Byte(value)
+}
+func C到整数(value interface{}) int64 {
+	return gconv.Int64(value)
+}
+
+func C到数值(value interface{}) float64 {
+	return gconv.Float64(value)
+}
+func C到文本(value interface{}) string {
+	return gconv.String(value)
+}
+func C到结构体(待转换的参数 interface{}, 结构体指针 interface{}) error {
+	return gconv.Struct(待转换的参数, 结构体指针)
+}
+
+// 调用格式： 〈文本型〉 删首空 （文本型 欲删除空格的文本） - 系统核心支持库->文本操作
+// 英文名称：LTrim
+// 返回一个文本，其中包含被删除了首部全角或半角空格的指定文本。本命令为初级命令。
+// 参数<1>的名称为“欲删除空格的文本”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C删首空(欲删除空格的文本 string) string {
+	return strings.TrimLeft(欲删除空格的文本, " ")
+}
+
+// 调用格式： 〈文本型〉 删尾空 （文本型 欲删除空格的文本） - 系统核心支持库->文本操作
+// 英文名称：RTrim
+// 返回一个文本，其中包含被删除了尾部全角或半角空格的指定文本。本命令为初级命令。
+// 参数<1>的名称为“欲删除空格的文本”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C删尾空(欲删除空格的文本 string) string {
+	return strings.TrimRight(欲删除空格的文本, " ")
+}
+func C删首尾空(内容 string) string {
+	return strings.TrimSpace(内容)
+}
+
+// 删全部空
+func C删全部空(内容 string) string {
+	return strings.Join(strings.FieldsFunc(内容, unicode.IsSpace), "")
+}
+
+// 调用格式： 〈文本型〉 子文本替换 （文本型 欲被替换的文本，文本型 欲被替换的子文本，［文本型 用作替换的子文本］，［整数型 进行替换的起始位置］，［整数型 替换进行的次数］，逻辑型 是否区分大小写） - 系统核心支持库->文本操作
+// 英文名称：RpSubText
+// 返回一个文本，该文本中指定的子文本已被替换成另一子文本，并且替换发生的次数也是被指定的。本命令为初级命令。
+// 参数<1>的名称为“欲被替换的文本”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲被替换的子文本”，类型为“文本型（text）”。
+// 参数<3>的名称为“用作替换的子文本”，类型为“文本型（text）”，可以被省略。如果本参数被省略，默认为空文本。
+// 参数<4>的名称为“进行替换的起始位置”，类型为“整数型（int）”，可以被省略。参数值指定被替换子文本的起始搜索位置。如果省略，默认从 1 开始。
+// 参数<5>的名称为“替换进行的次数”，类型为“整数型（int）”，可以被省略。参数值指定对子文本进行替换的次数。如果省略，默认进行所有可能的替换。
+// 参数<6>的名称为“是否区分大小写”，类型为“逻辑型（bool）”，初始值为“真”。为真区分大小写，为假不区分。
+//
+// 操作系统需求： Windows、Linux
+func C子文本替换(欲被替换的文本 string, 欲被替换的子文本 string, 用作替换的子文本 string) string {
+	return strings.Replace(欲被替换的文本, 欲被替换的子文本, 用作替换的子文本, -1)
+}
+
+// 调用格式： 〈文本型〉 取空白文本 （整数型 重复次数） - 系统核心支持库->文本操作
+// 英文名称：space
+// 返回具有指定数目半角空格的文本。本命令为初级命令。
+// 参数<1>的名称为“重复次数”，类型为“整数型（int）”。
+//
+// 操作系统需求： Windows、Linux
+func C取空白文本(重复次数 int) string {
+	var str string
+	for i := 0; i < 重复次数; i++ {
+		str = str + " "
+	}
+	return str
+}
+
+// 调用格式： 〈文本型〉 取重复文本 （整数型 重复次数，文本型 待重复文本） - 系统核心支持库->文本操作
+// 英文名称：string
+// 返回一个文本，其中包含指定次数的文本重复结果。本命令为初级命令。
+// 参数<1>的名称为“重复次数”，类型为“整数型（int）”。
+// 参数<2>的名称为“待重复文本”，类型为“文本型（text）”。该文本将用于建立返回的文本。如果为空，将返回一个空文本。
+//
+// 操作系统需求： Windows、Linux
+func C取重复文本(重复次数 int, 待重复文本 string) string {
+	var str string
+	for i := 0; i < 重复次数; i++ {
+		str = str + 待重复文本
+	}
+	return str
+}
+
+// 调用格式： 〈文本型数组〉 分割文本 （文本型 待分割文本，［文本型 用作分割的文本］，［整数型 要返回的子文本数目］） - 系统核心支持库->文本操作
+// 英文名称：split
+// 将指定文本进行分割，返回分割后的一维文本数组。本命令为初级命令。
+// 参数<1>的名称为“待分割文本”，类型为“文本型（text）”。如果参数值是一个长度为零的文本，则返回一个空数组，即没有任何成员的数组。
+// 参数<2>的名称为“用作分割的文本”，类型为“文本型（text）”，可以被省略。参数值用于标识子文本边界。如果被省略，则默认使用半角逗号字符作为分隔符。如果是一个长度为零的文本，则返回的数组仅包含一个成员，即完整的“待分割文本”。
+// 参数<3>的名称为“要返回的子文本数目”，类型为“整数型（int）”，可以被省略。如果被省略，则默认返回所有的子文本。
+//
+// 操作系统需求： Windows、Linux
+func C分割文本(待分割文本 string, 用作分割的文本 string) []string {
+	return strings.Split(待分割文本, 用作分割的文本)
+}
+
+// 调用格式： 〈无返回值〉 取命令行 （文本型变量数组 存放被取回命令行文本的数组变量） - 系统核心支持库->环境存取
+// 英文名称：GetCmdLine
+// 本命令可以取出在启动易程序时附加在其可执行文件名后面的所有以空格分隔的命令行文本段。本命令为初级命令。
+// 参数<1>的名称为“存放被取回命令行文本的数组变量”，类型为“文本型（text）”，提供参数数据时只能提供变量数组。在命令执行完毕后，本变量数组内被顺序填入在启动易程序时附加在其可执行文件名后面的以空格分隔的命令行文本段。变量数组内原有数据被全部销毁，变量数组的维数被自动调整为命令行文本段数。
+//
+// 操作系统需求： Windows、Linux
+func C取命令行() []string {
+	return os.Args
+}
+func C读环境变量(环境变量名称 string, 默认值 ...interface{}) string {
+	var def string
+	if len(默认值) > 1 {
+		def = C到文本(默认值[0])
+	}
+	e := os.Getenv(环境变量名称)
+	if e == "" {
+		return def
+	} else {
+		return e
+	}
+}
+
+// 调用格式： 〈逻辑型〉 写环境变量 （文本型 环境变量名称，文本型 欲写入内容） - 系统核心支持库->环境存取
+// 英文名称：PutEnv
+// 修改或建立指定的操作系统环境变量。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“环境变量名称”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲写入内容”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C写环境变量(环境变量名称 string, 欲写入内容 string) bool {
+	err := os.Setenv(环境变量名称, 欲写入内容)
+	return err == nil
+}
+
+// 调用格式： 〈逻辑型〉 创建目录 （文本型 欲创建的目录名称） - 系统核心支持库->磁盘操作
+// 英文名称：MkDir
+// 创建一个新的目录。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“欲创建的目录名称”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C创建目录(欲创建的目录名称 string) error {
+	欲创建的目录名称 = C子文本替换(欲创建的目录名称, "\\", "/")
+	return os.Mkdir(欲创建的目录名称, os.ModePerm)
+}
+
+// 调用格式： 〈逻辑型〉 创建目录1 （文本型 欲创建的目录名称） - 系统核心支持库->磁盘操作 创建多级目录
+// 英文名称：MkDir
+// 创建一个新的目录。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“欲创建的目录名称”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C创建目录1(路径 string) bool {
+	路径 = C子文本替换(路径, "\\", "/")
+	数组 := C分割文本(路径, "/")
+	qwq := 数组[0]
+	for n := 1; n < len(数组); n++ {
+		qwq = qwq + "/" + 数组[n]
+		if C目录是否存在(qwq) == false {
+			C创建目录(qwq)
+		}
+	}
+	return C目录是否存在(路径)
+}
+
+// 调用格式： 〈逻辑型〉 删除目录 （文本型 欲删除的目录名称） - 系统核心支持库->磁盘操作
+// 英文名称：RmDir
+// 删除一个存在的目录及其中的所有子目录和下属文件，请务必谨慎使用本命令。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“欲删除的目录名称”，类型为“文本型（text）”。该目录应实际存在，如果目录中存在文件或子目录，将被一并删除，因此使用本命令请千万慎重。
+//
+// 操作系统需求： Windows、Linux
+func C删除目录(欲删除的目录名称 string) error {
+	return os.RemoveAll(欲删除的目录名称)
+}
+
+// 调用格式： 〈逻辑型〉 目录是否存在 （文本型 欲判断的目录名） - 系统核心支持库->流程控制
+// 英文名称：
+// 输入一个目录名,判断此目录是否存在
+// 参数<1>的名称为“欲判断的目录名”，类型为“文本型（text）”。传入的目录名不会被改变。
+//
+// 操作系统需求： Windows、Linux
+func C目录是否存在(欲判断的目录名 string) bool {
+	s, err := os.Stat(C子文本替换(欲判断的目录名, "\\", "/"))
+	if err != nil {
+		return false
+	}
+	return s.IsDir()
+}
+
+// 调用格式： 〈文本型〉 取运行目录 （） - 系统核心支持库->环境存取
+// 英文名称：GetRunPath
+// 取当前被执行的易程序文件所处的目录。本命令为初级命令。
+//
+// 操作系统需求： Windows
+func C取运行目录() string {
+	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
+	if err != nil {
+		C日记(err)
+	}
+	return strings.Replace(dir, "\\", "\\", -1)
+}
+
+// 调用格式： 〈文本型〉 取目录 （） 根据路径取目录
+// 英文名称：*
+// 取当前被执行的易程序文件所处的目录。本命令为初级命令。
+//
+// 操作系统需求： Windows
+func C取目录() string {
+	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
+	if err != nil {
+		C日记(err)
+	}
+	return strings.Replace(dir, "\\", "/", -1)
+}
+
+// 本命令结束当前易程序的运行。
+func C结束() {
+	os.Exit(0)
+}
+
+// 调用格式： 〈逻辑型〉 目录_处理 （文本型 要处理的目录） - 系统核心支持库->流程控制
+// 英文名称：
+// 检测最后一个字符是否为“\”如果不是则加上，某些支持库或组件要求必须结尾有\等符号才能识别为目录。
+// 参数<1>的名称为“欲判断的目录名”，类型为“文本型（text）”。传入要检测和处理的目录路径。
+//
+// 操作系统需求： Windows、Linux
+func C目录处理(要处理的目录 string) string {
+	zz := C取文本右边(要处理的目录, 1)
+	if zz != "/" && zz != "\\" {
+		return 要处理的目录 + "\\"
+	}
+	return 要处理的目录
+}
+
+// 调用格式： 〈逻辑型〉 复制文件 （文本型 被复制的文件名，文本型 复制到的文件名） - 系统核心支持库->磁盘操作
+// 英文名称：FileCopy
+// 成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“被复制的文件名”，类型为“文本型（text）”。
+// 参数<2>的名称为“复制到的文件名”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C复制文件(被复制的文件名 string, 复制到的文件名 string) error {
+	src, err := os.Open(被复制的文件名)
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+	dst, err := os.OpenFile(复制到的文件名, os.O_WRONLY|os.O_CREATE, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer dst.Close()
+	_, err = io.Copy(dst, src)
+	return err
+}
+
+// 调用格式： 〈逻辑型〉 移动文件 （文本型 被移动的文件，文本型 移动到的位置） - 系统核心支持库->磁盘操作
+// 英文名称：FileMove
+// 将文件从一个位置移动到另外一个位置。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“被移动的文件”，类型为“文本型（text）”。
+// 参数<2>的名称为“移动到的位置”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C移动文件(被移动的文件 string, 移动到的位置 string) error {
+	return os.Rename(被移动的文件, 移动到的位置)
+}
+
+// 调用格式： 〈逻辑型〉 删除文件 （文本型 欲删除的文件名） - 系统核心支持库->磁盘操作
+// 英文名称：kill
+// 成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“欲删除的文件名”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C删除文件(欲删除的文件名 string) error {
+	return os.Remove(欲删除的文件名)
+}
+
+// 调用格式： 〈逻辑型〉 文件更名 （文本型 欲更名的原文件或目录名，文本型 欲更改为的现文件或目录名） - 系统核心支持库->磁盘操作
+// 英文名称：name
+// 重新命名一个文件或目录。成功返回真，失败返回假。本命令为初级命令。
+// 参数<1>的名称为“欲更名的原文件或目录名”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲更改为的现文件或目录名”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C文件更名(欲更名的原文件或目录名 string, 欲更改为的现文件或目录名 string) error {
+	return os.Rename(欲更名的原文件或目录名, 欲更改为的现文件或目录名)
+}
+
+// 调用格式： 〈逻辑型〉 文件是否存在 （文本型 欲测试的文件名称） - 系统核心支持库->磁盘操作
+// 英文名称：IsFileExist
+// 判断指定的磁盘文件是否真实存在。如存在返回真，否则返回假。本命令为初级命令。
+// 参数<1>的名称为“欲测试的文件名称”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C文件是否存在(欲测试的文件名称 string) bool {
+	if stat, err := os.Stat(欲测试的文件名称); stat != nil && !os.IsNotExist(err) {
+		return true
+	}
+	return false
+}
+
+// 调用格式： 〈整数型〉 取文件尺寸 （文本型 文件名） - 系统核心支持库->磁盘操作
+// 英文名称：FileLen
+// 返回一个文件的长度，单位是字节。如果该文件不存在，将返回 -1。本命令为初级命令。
+// 参数<1>的名称为“文件名”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C取文件尺寸(文件名 string) int64 {
+	f, err := os.Stat(文件名)
+	if err == nil {
+		return f.Size()
+	} else {
+		return -1
+	}
+}
+
+// 调用格式： 〈字节集〉 读入文件 （文本型 文件名） - 系统核心支持库->磁盘操作
+// 英文名称：ReadFile
+// 返回一个字节集，其中包含指定文件的所有数据。本命令为初级命令。
+// 参数<1>的名称为“文件名”，类型为“文本型（text）”。
+//
+// 操作系统需求： Windows、Linux
+func C读入文件(文件名 string) []byte {
+	var data []byte
+	data, _ = ioutil.ReadFile(文件名)
+	return data
+}
+
+// 调用格式： 〈逻辑型〉 写到文件 （文本型 文件名，字节集 欲写入文件的数据，... ） - 系统核心支持库->磁盘操作
+// 英文名称：WriteFile
+// 本命令用作将一个或数个字节集顺序写到指定文件中，文件原有内容被覆盖。成功返回真，失败返回假。本命令为初级命令。命令参数表中最后一个参数可以被重复添加。
+// 参数<1>的名称为“文件名”，类型为“文本型（text）”。
+// 参数<2>的名称为“欲写入文件的数据”，类型为“字节集（bin）”。
+//
+// 操作系统需求： Windows、Linux
+func C写到文件(文件名 string, 欲写入文件的数据 []byte) error {
+	父目录 := C文件取父目录(文件名)
+	if !C目录是否存在(父目录) {
+		C创建目录1(父目录)
+	}
+	return ioutil.WriteFile(文件名, 欲写入文件的数据, os.ModePerm)
+}
+func C文件取文件名(路径 string, 是否需要后缀 bool) string {
+	路径 = C子文本替换(路径, "\\", "/")
+	if 是否需要后缀 {
+		return filepath.Base(路径)
+	}
+	return strings.TrimSuffix(filepath.Base(路径), filepath.Ext(路径))
+}
+func C文件取父目录(dirpath string) string {
+	return path.Dir(C子文本替换(dirpath, "\\", "/"))
+}
+func C格式化文本(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, a...)
+}
+func C文本_取左边(被查找的文本 string, 欲寻找的文本 string) string {
+	return C文本_取出中间文本(被查找的文本, "", 欲寻找的文本)
+}
+func C文本_取右边(被查找的文本 string, 欲寻找的文本 string) string {
+	return C文本_取出中间文本(被查找的文本, 欲寻找的文本, "")
+}
+
+// 文本取出中间文本
+func C文本_取出中间文本(内容 string, 左边文本 string, 右边文本 string) string {
+	左边位置 := strings.Index(内容, 左边文本)
+	if 左边位置 == -1 {
+		return ""
+	}
+	左边位置 = 左边位置 + len(左边文本)
+	内容 = string([]byte(内容)[左边位置:])
+	var 右边位置 int
+	if 右边文本 == "" {
+		右边位置 = len(内容)
+	} else {
+		右边位置 = strings.Index(内容, 右边文本)
+		if 右边位置 == -1 {
+			return ""
+		}
+	}
+	内容 = string([]byte(内容)[:右边位置])
+	return 内容
+}
+func C文本_删左边(欲处理文本 string, 删除长度 int64) string {
+	return C取文本右边(欲处理文本, C取文本长度(欲处理文本)-删除长度)
+}
+func C文本_删右边(欲处理文本 string, 删除长度 int64) string {
+	return C取文本左边(欲处理文本, C取文本长度(欲处理文本)-删除长度)
+}
+func C文本_删中间(欲处理文本 string, 起始位置 int64, 删除长度 int64) string {
+	return C取文本左边(欲处理文本, 起始位置) + C文本_删左边(欲处理文本, 起始位置+删除长度)
+}
+func C文本_取出文本中汉字(s string) string {
+	return C文本区分_只取汉子(s)
+}
+func C文本_逐字分割(s string) []string {
+	r := []rune(s)
+	strarr := []string{}
+	for _, s := range r {
+		strarr = append(strarr, string(s))
+	}
+	return strarr
+}
+func C文本_颠倒(s string) string {
+	runes := []rune(s)
+	for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
+		runes[from], runes[to] = runes[to], runes[from]
+	}
+	return string(runes)
+}
+
+// 前面补全0
+func C文本_自动补零(s string, len int) string {
+	return C格式化文本("%0*d", len, C到整数(s))
+}
+
+// 后面不全0
+func C文本_自动补零1(s string, len int) string {
+	return s + C取重复文本(len-int(C取文本长度(s)), "0")
+	//return C格式化文本("%0*d", len, C到整数(s))
+
+}
+
+// unicode的参数含义
+// https://www.cnblogs.com/golove/p/3269099.html
+// Golang学习 - unicode 包
+// https://www.cnblogs.com/golove/p/3273585.html
+func C文本_是否为小写字母(s string) bool {
+	for _, r := range s {
+		if unicode.IsLower(r) {
+			return true
+		}
+	}
+	return false
+}
+func C文本_是否为大写字母(s string) bool {
+	for _, r := range s {
+		if unicode.IsUpper(r) {
+			return true
+		}
+	}
+	return false
+}
+func C文本_是否为字母(s string) bool {
+	for _, r := range s {
+		if unicode.IsLower(r) || unicode.IsUpper(r) {
+			return true
+		}
+	}
+	return false
+}
+func C文本_是否为数字(s string) bool {
+	for _, r := range s {
+		if unicode.IsNumber(r) {
+			return true
+		}
+	}
+	return false
+}
+func C文本_是否为汉字(s string) bool {
+	for _, r := range s {
+		if unicode.Is(unicode.Scripts["Han"], r) {
+			return true
+		}
+	}
+	return false
+}
+func C文本区分_只取字母(s string) string {
+
+	str := ""
+	for _, r := range s {
+		if unicode.IsLower(r) || unicode.IsUpper(r) {
+			str = str + string(r)
+		}
+	}
+	return str
+}
+func C文本区分_只取数字(s string) string {
+	str := ""
+	for _, r := range s {
+		if unicode.IsNumber(r) {
+			str = str + string(r)
+		}
+	}
+	return str
+}
+func C文本区分_只取汉子(s string) string {
+	str := ""
+	for _, r := range s {
+		if unicode.Is(unicode.Scripts["Han"], r) {
+			str = str + string(r)
+		}
+	}
+	return str
+}
+func C文本区分_只取符号(s string) string {
+	str := ""
+	for _, r := range s {
+		if unicode.IsSymbol(r) {
+			str = str + string(r)
+		}
+	}
+	return str
+}
+func C文本_首字母改大写(s string) string {
+	if len(s) < 1 {
+		return ""
+	}
+	strArry := []rune(s)
+	if strArry[0] >= 97 && strArry[0] <= 122 {
+		strArry[0] -= 32
+	}
+	return string(strArry)
+}
+
+func C判断文本前缀(s string, 前缀 string) bool {
+	return strings.HasPrefix(s, 前缀)
+}
+func C判断文本后缀(s string, 后缀 string) bool {
+	return strings.HasSuffix(s, 后缀)
+}
+func C字节集到十六进制(数据 []byte) string {
+	return hex.EncodeToString(数据)
+}
+func C十六进制到字节集(数据 string) []byte {
+	解码, _ := hex.DecodeString(数据)
+	return 解码
+}
+func C时间_秒到时分秒格式(秒 int64, 格式 string) string {
+	局_秒 := 秒
+	if 格式 == "" {
+		格式 = "d天h小时m分s秒"
+	}
+	局_天 := 局_秒 / 86400
+	局_小时 := (局_秒 % 86400) / 3600
+	局_分 := (局_秒 % 86400 % 3600) / 60
+	局_秒 = 局_秒 % 86400 % 3600 % 60
+
+	局_位置 := C倒找文本(格式, "d")
+	if 局_位置 != -1 {
+		局_Time := C到文本(局_天)
+		局_Time = C文本_自动补零(局_Time, 2)
+		格式 = C子文本替换(格式, "d", 局_Time)
+	}
+	局_位置 = C倒找文本(格式, "h")
+	if 局_位置 != -1 {
+		局_Time := C到文本(局_小时)
+		局_Time = C文本_自动补零(局_Time, 2)
+		格式 = C子文本替换(格式, "h", 局_Time)
+	}
+	局_位置 = C倒找文本(格式, "m")
+	if 局_位置 != -1 {
+		局_Time := C到文本(局_分)
+		局_Time = C文本_自动补零(局_Time, 2)
+		格式 = C子文本替换(格式, "m", 局_Time)
+	}
+	局_位置 = C倒找文本(格式, "s")
+	if 局_位置 != -1 {
+		局_Time := C到文本(局_秒)
+		局_Time = C文本_自动补零(局_Time, 2)
+		格式 = C子文本替换(格式, "s", 局_Time)
+	}
+	return 格式
+}
+func C选择文本(条件 bool, 参数一, 参数二 string) string {
+	if 条件 == true {
+		return 参数一
+	} else {
+		return 参数二
+	}
+}
+func CRc4加密(待加密 []byte, 密钥 string) []byte {
+	//AA日记("加密", len(待加密))
+	key := []byte(密钥)
+	cipher1, _ := rc4.NewCipher(key)
+	cipher1.XORKeyStream(待加密, 待加密)
+	cipher1.Reset()
+	return 待加密
+}
+func CRc4解密(待解密 []byte, 密钥 string) []byte {
+	//AA日记("解密", len(待解密))
+	key := []byte(密钥)
+	cipher2, _ := rc4.NewCipher(key)
+	cipher2.XORKeyStream(待解密, 待解密)
+	cipher2.Reset()
+	return 待解密
+}
+
+//var loger *log.Logger
+
+// 需要个全局变量 var loger *log.Logger
+// 使用的时候，需要采用loger作为输出的前缀 loger.Println("Hello:world!")
+func C日记设置(文件名, 日记前缀 string) (loger *log.Logger) {
+	if C文件是否存在(文件名) == false {
+		C日记("文件不存在", C写到文件(文件名, []byte("")))
+	}
+	logFile, err := os.OpenFile(文件名, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
+	if err != nil {
+		panic(err)
+	}
+	loger = log.New(logFile, 日记前缀, log.LstdFlags|log.Lshortfile|log.LUTC) // 将文件设置为loger作为输出
+	return
+}
+func C头(原文, 条件 string) bool {
+	if C取文本左边(原文, C取文本长度(条件)) == 条件 {
+		return true
+	}
+	return false
+}
+
+// 以1000作为基数
+func C文件_大小转换单位(b int64) string {
+	const unit = 1000
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB",
+		float64(b)/float64(div), "kMGTPE"[exp])
+}
+
+// 以1024作为基数
+func ByteCountIEC(b int64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB",
+		float64(b)/float64(div), "KMGTPE"[exp])
+}
--- a/时间操作.go
+++ b/时间操作.go
@ -0,0 +1,153 @@
+package c
+
+import (
+	"github.com/gogf/gf/os/gtime"
+)
+
+//A simple extension for Time based on PHP's Carbon library. https://github.com/uniplaces/carbon
+
+//到时间
+//增减时间
+//取时间间隔
+//取某月天数
+//时间到文本
+//取时间部分
+//取年份-
+//取月份-
+//取日-
+//取星期几
+//取小时
+//取分钟
+//取秒
+//指定时间
+//取现行时间
+//置现行时间
+//取日期
+//取时间
+
+type C日期时间型 struct {
+	Time *gtime.Time
+}
+
+func (this *C日期时间型) C取星期几() int64 {
+	return C到整数(this.Time.Format("N"))
+}
+func (this *C日期时间型) C取月天数() int64 {
+	return C到整数(this.Time.Format("t"))
+}
+
+func (this *C日期时间型) C取年份() int64 {
+	return C到整数(this.Time.Format("Y"))
+}
+func (this *C日期时间型) C取月份() int64 {
+	return C到整数(this.Time.Format("m"))
+}
+func (this *C日期时间型) C取日() int64 {
+	return C到整数(this.Time.Format("d"))
+}
+func (this *C日期时间型) C取小时() int64 {
+	return C到整数(this.Time.Format("H"))
+}
+func (this *C日期时间型) C取分钟() int64 {
+	return C到整数(this.Time.Format("i"))
+}
+func (this *C日期时间型) C取秒() int64 {
+	return C到整数(this.Time.Format("s"))
+}
+func (this *C日期时间型) C取毫秒() int64 {
+	return C到整数(this.Time.Millisecond())
+}
+func (this *C日期时间型) C取微秒() int64 {
+	return C到整数(this.Time.Microsecond())
+}
+func (this *C日期时间型) C取纳秒() int64 {
+	return C到整数(this.Time.Nanosecond())
+}
+func (this *C日期时间型) C取时间戳() int64 {
+	return this.Time.Timestamp()
+}
+func (this *C日期时间型) C取时间戳毫秒() int64 {
+	return this.Time.TimestampMilli()
+}
+func (this *C日期时间型) C取时间戳微秒() int64 {
+	return this.Time.TimestampMicro()
+}
+func (this *C日期时间型) C取时间戳纳秒() int64 {
+	return this.Time.TimestampNano()
+}
+
+func (this *C日期时间型) C时间到文本(format string) string {
+	if format == "" {
+		format = "Y-m-d H:i:s"
+	}
+	return this.Time.Format(format)
+}
+
+func (this *C日期时间型) C增减日期(年 int, 月 int, 日 int) *C日期时间型 {
+	this.Time = this.Time.AddDate(年, 月, 日)
+	return this
+}
+func (this *C日期时间型) C增减时间(时 int, 分 int, 秒 int) *C日期时间型 {
+	if 时 != 0 {
+		this.Time.AddStr(C到文本(时) + "h")
+	}
+	if 分 != 0 {
+		this.Time.AddStr(C到文本(分) + "m")
+	}
+	if 秒 != 0 {
+		this.Time.AddStr(C到文本(秒) + "s")
+	}
+	return this
+}
+
+func (this *C日期时间型) C大于(time *C日期时间型) bool {
+	return this.Time.After(time.Time)
+}
+func (this *C日期时间型) C小于(time *C日期时间型) bool {
+	return this.Time.Before(time.Time)
+}
+func (this *C日期时间型) C等于(time *C日期时间型) bool {
+	return this.Time.Equal(time.Time)
+}
+
+// 返回当前区域设置中可读格式的差异。
+// 将过去的值与现在的默认值进行比较时：
+// 1 小时前
+// 5 个月前
+// 将将来的值与现在的默认值进行比较时：
+// 1 小时后
+// 5 个月后
+// 将过去的值与另一个值进行比较时：
+// 1 小时前
+// 5 个月前
+// 将将来的值与另一个值进行比较时：
+// 1 小时后
+// 5 个月后
+func (this *C日期时间型) C到友好时间(d *C日期时间型) string {
+	return "暂时没有编写"
+}
+
+//到时间
+//增减时间
+//取时间间隔
+//取某月天数
+//时间到文本
+//取时间部分
+
+func C取现行时间() *C日期时间型 {
+	this := new(C日期时间型)
+	this.Time = gtime.Now()
+	return this
+}
+func C到时间(s string) *C日期时间型 {
+	this := new(C日期时间型)
+	if t, err := gtime.StrToTime(s); err == nil {
+		this.Time = t
+	}
+	return this
+}
+func C到时间从时间戳(s int64) *C日期时间型 {
+	this := new(C日期时间型)
+	this.Time = gtime.NewFromTimeStamp(s)
+	return this
+}
--- a/算数运算.go
+++ b/算数运算.go
@ -0,0 +1,126 @@
+package c
+
+import (
+	"math"
+	"math/rand"
+	"time"
+
+	"github.com/gogf/gf/util/grand"
+)
+
+// 调用格式： 〈双精度小数型〉 四舍五入 （双精度小数型 欲被四舍五入的数值，［整数型 被舍入的位置］） - 系统核心支持库->算术运算
+// 英文名称：round
+// 返回按照指定的方式进行四舍五入运算的结果数值。本命令为初级命令。
+// 参数<1>的名称为“欲被四舍五入的数值”，类型为“双精度小数型（double）”。
+// 参数<2>的名称为“被舍入的位置”，类型为“整数型（int）”，可以被省略。如果大于0，表示小数点右边应保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：四舍五入 (1056.65, 1) 返回 1056.7； 四舍五入 (1056.65, 0) 返回 1057； 四舍五入 (1056.65, -1) 返回 1060。如果省略本参数，则默认为0。
+//
+// 操作系统需求： Windows、Linux
+func C四舍五入(欲被四舍五入的数值 float64, 被舍入的位置 int) float64 {
+	var pow float64 = 1
+	for i := 0; i < 被舍入的位置; i++ {
+		pow *= 10
+	}
+	return float64(int((欲被四舍五入的数值*pow)+0.5)) / pow
+}
+
+// 调用格式： 〈双精度小数型〉 取绝对值 （双精度小数型 欲取其绝对值的数值） - 系统核心支持库->算术运算
+// 英文名称：abs
+// 如果所提供数值为字节型，则将直接返回该数值。本命令为初级命令。
+// 参数<1>的名称为“欲取其绝对值的数值”，类型为“双精度小数型（double）”。
+//
+// 操作系统需求： Windows、Linux
+func C取绝对值(双精度小数型 float64) float64 {
+	return math.Abs(双精度小数型)
+}
+
+// 调用格式： 〈双精度小数型〉 求次方 （双精度小数型 欲求次方数值，双精度小数型 次方数） - 系统核心支持库->算术运算
+// 英文名称：pow
+// 返回指定数值的指定次方。本命令为初级命令。
+// 参数<1>的名称为“欲求次方数值”，类型为“双精度小数型（double）”。参数值指定欲求其某次方的数值。
+// 参数<2>的名称为“次方数”，类型为“双精度小数型（double）”。参数值指定对欲求次方数值的运算指数。
+//
+// 操作系统需求： Windows、Linux
+func C求次方(欲求次方数值 float64, 次方数 float64) float64 {
+	return math.Pow(欲求次方数值, 次方数)
+}
+
+// 调用格式： 〈双精度小数型〉 求平方根 （双精度小数型 欲求其平方根的数值） - 系统核心支持库->算术运算
+// 英文名称：sqr
+// 返回指定参数的平方根。本命令为初级命令。
+// 参数<1>的名称为“欲求其平方根的数值”，类型为“双精度小数型（double）”。参数值如果小于零将导致计算错误。
+//
+// 操作系统需求： Windows、Linux
+func C求平方根(欲求次方数值 float64) float64 {
+	return math.Sqrt(欲求次方数值)
+}
+
+// 调用格式： 〈双精度小数型〉 求正弦 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算
+// 英文名称：sin
+// 返回指定角的正弦值。本命令为初级命令。
+// 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。
+//
+// 操作系统需求： Windows、Linux
+func C求正弦(欲进行计算的角 float64) float64 {
+	return math.Sin(欲进行计算的角)
+}
+
+// 调用格式： 〈双精度小数型〉 求余弦 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算
+// 英文名称：cos
+// 返回指定角的余弦值。本命令为初级命令。
+// 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。
+//
+// 操作系统需求： Windows、Linux
+func C求余弦(欲进行计算的角 float64) float64 {
+	return math.Cos(欲进行计算的角)
+}
+
+// 调用格式： 〈双精度小数型〉 求正切 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算
+// 英文名称：tan
+// 返回指定角的正切值。本命令为初级命令。
+// 参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 #pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / #pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。
+//
+// 操作系统需求： Windows、Linux
+func E求正切(欲进行计算的角 float64) float64 {
+	return math.Tan(欲进行计算的角)
+}
+
+// 调用格式： 〈双精度小数型〉 求反正切 （双精度小数型 欲求其反正切值的数值） - 系统核心支持库->算术运算
+// 英文名称：atn
+// 返回指定数的反正切值。本命令为初级命令。
+// 参数<1>的名称为“欲求其反正切值的数值”，类型为“双精度小数型（double）”。
+//
+// 操作系统需求： Windows、Linux
+func C求反正切(欲求其反正切值的数值 float64) float64 {
+	return math.Atan(欲求其反正切值的数值)
+}
+
+// 调用格式： 〈无返回值〉 置随机数种子 （［整数型 欲置入的种子数值］） - 系统核心支持库->算术运算
+// 英文名称：randomize
+// 为随机数生成器初始化一个种子值，不同的种子值将导致“取随机数”命令返回不同的随机数系列。本命令为初级命令。
+// 参数<1>的名称为“欲置入的种子数值”，类型为“整数型（int）”，可以被省略。如果省略本参数，将默认使用当前计算机系统的时钟值。
+//
+// 操作系统需求： Windows、Linux
+func C置随机数种子(欲置入的种子数值 int64) {
+	if 欲置入的种子数值 == 0 {
+		欲置入的种子数值 = time.Now().UnixNano()
+	}
+	rand.Seed(欲置入的种子数值)
+}
+
+// 调用格式： 〈整数型〉 取随机数 （［整数型 欲取随机数的最小值］，［整数型 欲取随机数的最大值］） - 系统核心支持库->算术运算
+// 英文名称：rnd
+// 返回一个指定范围内的随机数值。在使用本命令取一系列的随机数之前，应该先使用“置随机数种子”命令为随机数生成器初始化一个种子值。本命令为初级命令。
+// 参数<1>的名称为“欲取随机数的最小值”，类型为“整数型（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为 0 。
+// 参数<2>的名称为“欲取随机数的最大值”，类型为“整数型（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为无限。
+//
+// 操作系统需求： Windows、Linux
+func C取随机数(欲取随机数的最小值 int, 欲取随机数的最大值 int) int {
+	return grand.N(欲取随机数的最小值, 欲取随机数的最大值)
+}
+
+func C颜色24位转16位_RGB(r, g, b int64) int64 {
+	r = int64((r*249 + 1023) / 2047)
+	g = int64((g*249 + 1023) / 2047)
+	b = int64((b*249 + 1023) / 2047)
+	return (r << 11) | (g << 6) | b
+}
--- a/进制.go
+++ b/进制.go
@ -0,0 +1,76 @@
+package c
+
+import (
+	"strconv"
+)
+
+/*
+1. 二进制转八进制  %b -> %o
+2. 二进制转十进制  %b ->  %d
+3. 二进制转十六进制 %b -> %x
+4. 八进制转二进制 %o -> %b
+5. 八进制转十进制 %o -> %d
+6. 八进制转十六进制 %o -> %x
+7. 十进制转二进制 %d -> %b
+8. 十进制转八进制 %d -> %o
+9. 十进制转十六进制 %d -> %x
+10. 十六进制转二进制 %x -> %b
+11. 十六进制转八进制 %x -> %o
+12. 十六进制转十进制 %x -> %d
+
+%b    表示为二进制
+%c    该值对应的unicode码值
+%d    表示为十进制
+%o    表示为八进制
+%q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
+%x    表示为十六进制，使用a-f
+%X    表示为十六进制，使用A-F
+%U    表示为Unicode格式：U+1234，等价于"U+%04X"
+%E    用科学计数法表示
+%f    用浮点数表示
+fmt.Printf("十进制%d转成八进制%o",num1,num2)
+return fmt.Sprintf("%.2f KB", b/1024)
+*/
+func C进制16_10(t string) int64 { //十六进制到十进制 文本-整数
+	if parseUint, err := strconv.ParseInt(t, 16, 64); err != nil {
+		panic(err)
+		return 0
+	} else {
+		return parseUint
+	}
+	return 0
+}
+
+func C进制16_10a(t []byte) int64 { //十六进制到十进制 文本-整数
+	a := C字节集到十六进制(t)
+	return C进制16_10(a)
+}
+func C进制8_10(t string) int64 { //八进制到十进制 文本-整数
+	if parseUint, err := strconv.ParseInt(t, 16, 64); err != nil {
+		panic(err)
+		return 0
+	} else {
+		return parseUint
+	}
+	return 0
+}
+
+func C进制8_10a(t []byte) int64 { //十六进制到十进制 字节集-整数
+	a := C字节集到十六进制(t)
+	return C进制8_10(a)
+}
+func C进制10_16(t int64) string { //十进制到十六进制 整数-文本
+	return strconv.FormatInt(t, 16)
+}
+func C进制16_10反(t string) int64 { //十六进制到十进制 文本-整数
+	s := C选择文本(len(t)%2 == 0, t, C文本_自动补零(t, len(t)+1))
+	var x string
+	for i := 0; i < len(s)/2; i++ {
+		x = C取文本中间(s, i*2, 2) + x
+	}
+	return C进制16_10(x)
+}
+func C进制16_10反a(t []byte) int64 { //十六进制到十进制 字节集-整数
+	a := C字节集到十六进制(t)
+	return C进制16_10反(a)
+}