go工具类

我会带着你远行 2023-08-17 15:30 75阅读 0赞

1、解决go的第三方库依赖或者通过`go get github.com/hyper-carrot/go_lib/logging`由于国家不允许进行翻墙，大部分情况无法下载，或者通过翻墙进行下载，但是还有一种比较笨的方法，自己进入github网址进行拉取第三方库。  
2、首先进行配置环境查找GOPATH的地址。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]  
3、找到目录如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70 1]  
`go get`命令会将项目下的所有子目录和源码文件存放到第一个工作区的`src`目录下、`bin`是`exe`运行程序或者`golang`编译可执行文件存放路径、`pkg`一般放入缓存的第三方库、或者`golang`编译包时，生成的`.a`文件存放路径。

**注意：我们go get失败，可以通过 git clone https://github.com/hyper-carrot/go\_lib/logging.git 进行拉取。再放到src目录下。如图所示：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70 2]

package main
    
    import (
    	//标准库
    	"fmt"
    	//程序内部包
    	"io/ioutil"
    	"net/http"
    	"net/url"	
    	"log"
        //
    	"strings"
    	"encoding/json"
    	//"os"
    	// "crypto/tls"
    	// "crypto/x509"
    	// "flag"
    	// "io/ioutil"
    	// "net/http"
    	//第三方库
        // "golang.org/x/net/http2"
    	//随机数
    	"math/rand"
    	"time"	
    	//文件上传
    	"bytes"
    	// "errors"
    	// "github.com/valyala/fasthttp"
    	// "io"
    	// "mime/multipart"
    	// "path"
    	// "path/filepath"
    	// "strings"
    	//
    	// "github.com/golang/glog"
    	//
    	// "bytes"
    	"compress/gzip"
    	"encoding/binary"
    	"github.com/gitstliu/log4go"
        //go 常用库
    	// "github.com/sail-services/sail-go/mod/data/log"
    	// "github.com/sail-services/sail-go/mod/net/service"
    	// sWeb "github.com/sail-services/sail-go/mod/net/web"
    	//裸体图像检测
    	// "github.com/koyachi/go-nude"
    )
    //http get 请求
    func httpGet() {
    	resp, err := http.Get("http://47.98.182.201:7001/v1/tenants/_1LWHJ9M/get-skill-groups")
    	if err != nil {
    		// handle error
    	}
    
    	defer resp.Body.Close()
    	body, err := ioutil.ReadAll(resp.Body)
    	if err != nil {
    		// handle error
    	}
    	fmt.Println(string(body))
    }
    //http post 请求
    func httpPost() {
    	resp, err := http.Post("http://www.01happy.com/demo/accept.php",
    		"application/x-www-form-urlencoded",
    		strings.NewReader("name=cjb"))
    	if err != nil {
    		fmt.Println(err)
    	}
    
    	defer resp.Body.Close()
    	body, err := ioutil.ReadAll(resp.Body)
    	if err != nil {
    		// handle error
    	}
    
    	fmt.Println(string(body))
    }
    //go post 表单提交
    func httpPostForm() {
    	resp, err := http.PostForm("http://www.01happy.com/demo/accept.php",
    		url.Values{"key": {"Value"}, "id": {"123"}})
    
    	if err != nil {
    		// handle error
    	}
    
    	defer resp.Body.Close()
    	body, err := ioutil.ReadAll(resp.Body)
    	if err != nil {
    		// handle error
    	}
    
    	fmt.Println(string(body))
    
    }
    
    //http do 请求
    // func httpDo() {
    // 	client := &http.Client{}
    
    // 	req, err := http.NewRequest("POST", "http://www.01happy.com/demo/accept.php", strings.NewReader("name=cjb"))
    // 	if err != nil {
    // 		// handle error
    // 	}
    // 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    // 	req.Header.Set("Cookie", "name=anny")
    // 	resp, err := client.Do(req)
    // 	defer resp.Body.Close()
    // 	body, err := ioutil.ReadAll(resp.Body)
    // 	if err != nil {
    // 		// handle error
    // 	}
    // 	fmt.Println(string(body))
    // }
    
    // 提供接口服务
    func sayhelloName(w http.ResponseWriter, r *http.Request) {
    	fmt.Fprintf(w, "Hello world!")
    	fmt.Println("你好")
    }
    //json对象
    type ConfigStruct struct {
        Host              string   `json:"host"`
        Port              int      `json:"port"`
        AnalyticsFile     string   `json:"analytics_file"`
        StaticFileVersion int      `json:"static_file_version"`
        StaticDir         string   `json:"static_dir"`
        TemplatesDir      string   `json:"templates_dir"`
        SerTcpSocketHost  string   `json:"serTcpSocketHost"`
        SerTcpSocketPort  int      `json:"serTcpSocketPort"`
        Fruits            []string `json:"fruits"`
    }
    //json 部分对象
    type Other struct {
        SerTcpSocketHost string   `json:"serTcpSocketHost"`
        SerTcpSocketPort int      `json:"serTcpSocketPort"`
        Fruits           []string `json:"fruits"`
    }
    
    // go  https
    func handle(w http.ResponseWriter, r *http.Request) {
        // 记录请求协议
        log.Printf("Got connection: %s", r.Proto)
        // 向客户发送一条消息
        w.Write([]byte("Hello"))
    }
    
    //go http2 请求
    // const url = "https://localhost:8000"
    // var httpVersion = flag.Int("version", 2, "HTTP version")
    
    
    //go 获取随机数据
    
    
    func GetRandomStr(len int) string{
    	originStr := "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz"
    	str := ""
    	bStr := []byte(originStr)
    	rand.Seed(time.Now().Unix())
    	for i:=0;i<len;i++{
    		str += string(bStr[rand.Intn(61)])
    	}
    	return str
    }
    
    // go 文件上传
    // func PostRawData(url string,data []byte) ([]byte,error){
    // 	request := fasthttp.AcquireRequest()
    // 	request.SetRequestURI(url)
    // 	request.Header.SetMethod("POST")
    // 	request.SetBody(data)
    // 	response := fasthttp.AcquireResponse()
    // 	err := requestFellowRedirect(request,response)
    // 	if err != nil{
    // 		return nil,err
    // 	}
    // 	return response.Body(),err
    // }
    
    // func PostFields(url string,fields map[string]string) ([]byte,error){
    // 	//新建一个缓冲，用于存放文件内容
    // 	bodyBufer := &bytes.Buffer{}
    // 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
    // 	bodyWriter := multipart.NewWriter(bodyBufer)
    // 	err := writeFieldsData(bodyWriter,fields)
    // 	if err != nil{
    // 		bodyWriter.Close()
    // 		return nil,err
    // 	}
    // 	//关闭bodyWriter停止写入数据
    // 	bodyWriter.Close()
    // 	contentType := bodyWriter.FormDataContentType()
    // 	//构建request，发送请求
    // 	req := fasthttp.AcquireRequest()
    // 	req.Header.SetContentType(contentType)
    // 	//直接将构建好的数据放入post的body中
    // 	req.SetBody(bodyBufer.Bytes())
    // 	req.Header.SetMethod("POST")
    // 	req.SetRequestURI(url)
    // 	resp := fasthttp.AcquireResponse()
    // 	err = requestFellowRedirect(req,resp)
    // 	if err != nil{
    // 		return nil,err
    // 	}
    // 	return resp.Body(),nil
    // }
    // //支持多文件上传
    // func PostFiles(url string,files map[string]string) ([]byte,error){
    // 	//新建一个缓冲，用于存放文件内容
    // 	bodyBufer := &bytes.Buffer{}
    // 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
    // 	bodyWriter := multipart.NewWriter(bodyBufer)
    
    // 	err := writeFilesData(bodyWriter,files)
    // 	if err != nil{
    // 		bodyWriter.Close()
    // 		return nil,err
    // 	}
    // 	//关闭bodyWriter停止写入数据
    // 	bodyWriter.Close()
    // 	contentType := bodyWriter.FormDataContentType()
    // 	//构建request，发送请求
    // 	request := fasthttp.AcquireRequest()
    // 	request.Header.SetContentType(contentType)
    // 	//直接将构建好的数据放入post的body中
    // 	request.SetBody(bodyBufer.Bytes())
    // 	request.Header.SetMethod("POST")
    // 	request.SetRequestURI(url)
    // 	response := fasthttp.AcquireResponse()
    // 	err = requestFellowRedirect(request,response)
    // 	if err != nil{
    // 		return nil,err
    // 	}
    // 	return response.Body(),nil
    // }
    
    // //支持多文件上传
    // func PostFilesAndFields(url string,files map[string]string,fields map[string]string) ([]byte,error){
    // 	//新建一个缓冲，用于存放文件内容
    // 	bodyBufer := &bytes.Buffer{}
    // 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
    // 	bodyWriter := multipart.NewWriter(bodyBufer)
    
    // 	err := writeFilesData(bodyWriter,files)
    // 	if err != nil{
    // 		bodyWriter.Close()
    // 		return nil,err
    // 	}
    // 	err = writeFieldsData(bodyWriter,fields)
    // 	if err != nil{
    // 		bodyWriter.Close()
    // 		return nil,err
    // 	}
    // 	//关闭bodyWriter停止写入数据
    // 	bodyWriter.Close()
    // 	contentType := bodyWriter.FormDataContentType()
    // 	//构建request，发送请求
    // 	request := fasthttp.AcquireRequest()
    // 	request.Header.SetContentType(contentType)
    // 	//直接将构建好的数据放入post的body中
    // 	request.SetBody(bodyBufer.Bytes())
    // 	request.Header.SetMethod("POST")
    // 	request.SetRequestURI(url)
    // 	response := fasthttp.AcquireResponse()
    // 	err = requestFellowRedirect(request,response)
    // 	if err != nil{
    // 		return nil,err
    // 	}
    // 	return response.Body(),nil
    // }
    
    // func Get(url string) ([]byte,error){
    // 	client := fasthttp.Client{}
    // 	_,resp,err := client.Get(nil,url)
    // 	return resp,err
    // }
    
    // //支持重定向文件下载
    // func DownLoadFileByGet(url,savePath string) (string,error){
    // 	//fasthttp.Do不支持自动重定向，此处自己实现
    // 	req := fasthttp.AcquireRequest()
    // 	req.SetRequestURI(url)
    // 	resp := fasthttp.AcquireResponse()
    // 	err := requestFellowRedirect(req,resp)
    // 	if err != nil{
    // 		return "",err
    // 	}
    // 	return saveFile(savePath,resp)
    // }
    // //用于需要上传form表单下载文件的情况
    // func DownloadFileByPostFields(url,savePath string,fields map[string]string) (string,error){
    // 	//新建一个缓冲，用于存放文件内容
    // 	bodyBufer := &bytes.Buffer{}
    // 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
    // 	bodyWriter := multipart.NewWriter(bodyBufer)
    // 	err := writeFieldsData(bodyWriter,fields)
    // 	if err != nil{
    // 		bodyWriter.Close()
    // 		return "",err
    // 	}
    // 	//关闭bodyWriter停止写入数据
    // 	bodyWriter.Close()
    // 	contentType := bodyWriter.FormDataContentType()
    // 	//构建request，发送请求
    // 	req := fasthttp.AcquireRequest()
    // 	req.Header.SetContentType(contentType)
    // 	//直接将构建好的数据放入post的body中
    // 	req.SetBody(bodyBufer.Bytes())
    // 	req.Header.SetMethod("POST")
    // 	req.SetRequestURI(url)
    // 	resp := fasthttp.AcquireResponse()
    // 	err = requestFellowRedirect(req,resp)
    // 	if err != nil{
    // 		return "",err
    // 	}
    // 	return saveFile(savePath,resp)
    // }
    // //用于需要上传json串等数据下载文件的情况
    // func DownloadFileByPostRawData(url,savePath string,rawData []byte)(string,error){
    // 	req := fasthttp.AcquireRequest()
    // 	req.SetRequestURI(url)
    // 	req.Header.SetMethod("POST")
    // 	req.SetBody(rawData)
    // 	resp := fasthttp.AcquireResponse()
    // 	err := requestFellowRedirect(req,resp)
    // 	if err != nil{
    // 		return "",err
    // 	}
    // 	return saveFile(savePath,resp)
    // }
    
    // func writeFieldsData(bodyWriter *multipart.Writer,fields map[string]string) error{
    // 	for k,v := range fields{
    // 		fieldWriter,err := bodyWriter.CreateFormField(k)
    // 		if err != nil{
    // 			return err
    // 		}
    // 		fieldWriter.Write([]byte(v))
    // 	}
    // 	return nil
    // }
    
    // func writeFilesData(bodyWriter *multipart.Writer,files map[string]string) error{
    // 	for key,val := range files{
    // 		//从bodyWriter生成fileWriter,并将文件内容写入fileWriter,多个文件可进行多次
    // 		fileWriter,err := bodyWriter.CreateFormFile(key,path.Base(val))
    // 		if err != nil{
    // 			return err
    // 		}
    // 		file,err := os.Open(val)
    // 		if err != nil{
    // 			return err
    // 		}
    // 		//不要忘记关闭打开的文件
    // 		_,err = io.Copy(fileWriter,file)
    // 		if err != nil{
    // 			return err
    // 		}
    // 		file.Close()
    // 	}
    // 	return nil
    // }
    //发出请求，如果返回重定向则继续请求重定向地址，直到返回非重定向结果
    // func requestFellowRedirect(req *fasthttp.Request,resp *fasthttp.Response)error{
    // 	for{
    // 		err := fasthttp.Do(req,resp)
    // 		if err != nil{
    // 			return err
    // 		}
    // 		statusCode := resp.StatusCode()
    // 		if statusCode != fasthttp.StatusMovedPermanently &&
    // 			statusCode !=  fasthttp.StatusFound &&
    // 			statusCode !=  fasthttp.StatusSeeOther &&
    // 			statusCode !=  fasthttp.StatusTemporaryRedirect &&
    // 			statusCode !=  fasthttp.StatusPermanentRedirect {
    // 			break
    // 		}
    // 		location := ""
    // 		//获取重定向链接地址
    // 		resp.Header.VisitAll(func (key,val []byte){
    // 			if (string(key) == "Location"){
    // 				location = string(val)
    // 			}
    // 		})
    
    // 		if location == ""{
    // 			return errors.New("redirect response without location")
    // 		}
    // 		resp.Reset()
    // 		req.SetRequestURI(location)
    // 	}
    // 	return nil
    // }
    //根据http请求的response保存文件
    // func saveFile(savePath string,resp *fasthttp.Response)(string,error){
    // 	//先返回文件下载地址
    // 	fileName := ""
    // 	//从header头的Content-disposition获得文件名
    // 	resp.Header.VisitAll(func (key,val []byte){
    // 		if (string(key) == "Content-Disposition"){
    // 			infoStr := string(val)
    // 			stringArr := strings.Split(infoStr,";")
    // 			for _,str := range stringArr{
    // 				if  strings.Index(str,"filename") == 1{
    // 					strArr := strings.Split(str,"=")
    // 					fileName = strings.Trim(strArr[1],"\"")
    // 					break
    // 				}
    // 			}
    // 		}
    // 	})
    // 	if fileName == ""{
    // 		strArr := strings.Split(string(resp.Header.ContentType()),"/")
    // 		fileName = GetRandomStr(30)+"."+strArr[1]
    // 	}
    // 	//有时候上传图片的名称中包含路径名
    // 	fileName =filepath.Base(fileName)
    // 	if savePath == ""{
    // 		savePath = os.TempDir()
    // 	}
    // 	fullFile := savePath+"/"+fileName
    // 	file,err := os.Create(fullFile)
    // 	defer file.Close()
    // 	if err != nil{
    // 		return "",err
    // 	}
    // 	_,err = file.Write(resp.Body())
    // 	if err != nil{
    // 		return "",nil
    // 	}
    // 	return fullFile,nil
    // }
    
    
    
    // func  Test(){
    //    var s []string
    
    //    fmt.ErrorF("failed to write data .")
    //    //空字符串检查
    //    if s==""{}
    //    //非空slice检查
    //    if len(s)>0{} 
    //    //bool值
    //    if b {}
    //    if !b {}
    //    //btye slice string 值相互比较
    //    var s1 []byte
    //    var s2 []byte
    //    bytes.Equal(s1,s2) == 0
    //    bytes.Equal(s1,s2) != 0
    //    //检查是否包含字符串
    //    strings.ContainesRune()
    // }
    
    
    // 1. PanicHandler
    // 通用Panic处理器
    
    // 2. InterfacesToStrings
    // 将Interface数组转换为String数组
    
    // 3. GetFilesWithFolder
    // 获得文件夹下所有文件
    
    // 4. ObjectToJson
    // 将对象转换为JSON
    
    // 5. ObjectsToJson
    // 将对象数组转换为JSON数组
    
    // 6. DecodeGzipBytes
    // 解码GZIP
    
    // 7. EncodeGzipBytes
    // 编码GZIP
    
    // 8. JsonToObject
    // 将JSON转换为对象
    
    // 9. StringToBytes
    // 将String 转换为byte数组
    
    // 10. Int64ToBytes
    // 将int64转为byte数组
    
    // 11. IntToBool
    // 将int转换为bool
    
    // 12. IsGzipEncode
    // 判断HTTP请求是否GZIP
    
    
    type TimeSpan struct {
    	startNS int64
    	endNS   int64
    }
    
    type NodeToRecord interface {
    	ToRecord() string
    }
    
    func PanicHandler() {
    	if r := recover(); r != nil {
    		log4go.Error("Run time Error %v", r)
    		panic(r)
    	}
    }
    
    func InterfacesToStrings(src []interface{}) []string {
    	result := []string{}
    	for _, value := range src {
    		result = append(result, value.(string))
    	}
    	return result
    }
    
    func (this *TimeSpan) Start() {
    	this.startNS = time.Now().UnixNano()
    }
    
    func (this *TimeSpan) End() {
    	this.endNS = time.Now().UnixNano()
    }
    
    func (this *TimeSpan) GetTimeSpanMS() float64 {
    
    	return float64(this.endNS-this.startNS) / 1000000
    }
    
    func GetFilesWithFolder(folderName string) ([]string, error) {
    
    	result := make([]string, 0, 1000)
    
    	infos, readDirError := ioutil.ReadDir(folderName)
    
    	if readDirError != nil {
    		return nil, readDirError
    	}
    
    	for _, info := range infos {
    
    		if !info.IsDir() {
    			result = append(result, folderName+"/"+info.Name())
    		}
    	}
    
    	return result, nil
    }
    
    func ObjectToJson(value interface{}) (string, error) {
    	meta, err := json.Marshal(value)
    	return string(meta), err
    }
    
    func ObjectsToJson(values []interface{}) ([]interface{}, error) {
    	result := [](interface{}){}
    
    	for _, currValue := range values {
    		meta, err := ObjectToJson(currValue)
    
    		if err != nil {
    			return nil, err
    		} else {
    			result = append(result, meta)
    		}
    	}
    
    	return result, nil
    }
    
    func DecodeGzipBytes(meta []byte) ([]byte, error) {
    	b := bytes.Buffer{}
    	b.Write(meta)
    	r, _ := gzip.NewReader(&b)
    	defer r.Close()
    	datas, readErr := ioutil.ReadAll(r)
    
    	if readErr != nil {
    		return nil, readErr
    	}
    
    	return datas, nil
    }
    
    func EncodeGzipBytes(meta []byte) []byte {
    	b := bytes.Buffer{}
    	w := gzip.NewWriter(&b)
    	defer w.Close()
    
    	w.Write(meta)
    	w.Flush()
    
    	return b.Bytes()
    }
    
    func JsonToObject(meta string, result interface{}) error {
    	return json.Unmarshal(StringToBytes(meta), result)
    }
    
    func StringToBytes(value string) []byte {
    	return []byte(value)
    }
    
    func MetaToJsonContent(value string) string {
    	return fmt.Sprintf("{%s}", value)
    }
    
    func Int64ToBytes(value int64) []byte {
    
    	result := []byte{}
    
    	buffer := bytes.NewBuffer(result)
    	binary.Write(buffer, binary.BigEndian, &value)
    
    	return buffer.Bytes()
    }
    
    func IntToBool(value int) bool {
    	if value == 1 {
    		return true
    	} else {
    		return false
    	}
    }
    
    func IsGzipEncode(header http.Header) bool {
    
    	log4go.Debug("header : %v", header)
    
    	value := header["Content-Encoding"]
    
    	return value != nil && strings.EqualFold(value[0], "gzip")
    }
    
    //go 语言常用库
    // var (
    // 	web = &sWeb.Web{
    // 		Project: &sWeb.Project{
    // 			Name:    "HelloWorld",
    // 			Version: "0.1",
    // 			Url:     "helloworld.com",
    // 		},
    // 		Base: &sWeb.Base{
    // 			Port:            8888,                               // 端口
    // 			SecretKey:       `C\WVM(A&yX/dScm503YdD5.,\>(~c>X?`, // AES统一秘钥 (Cookie, CSRF)
    // 			DefaultLang:     "en-US",                            // 默认语言
    // 			I18nLangs:       []string{"en-US", "zh-CN"},         // 语言ID
    // 			I18nNames:       []string{"Engligh", "中文"},          // 语言列表
    // 			PathRootDev:     "../",                              // 开发模式的相对路径
    // 			PathRootRelease: "./",                               // 发布模式的相对路径
    // 			PathLangs:       "langs",                            // 语言文件路径
    // 			PathTemplate:    "html",                             // 模板文件路径
    // 		},
    // 		Pro: &sWeb.Pro{
    // 			PathStatics: [][]string{ // URL绑定静态目录
    // 				{"s", "public"},               // 静态文件目录 (JS, CSS...)
    // 				{"hongbao", "public/hongbao"}, // 推广活动页面 (用HTML写的推广主题)
    // 			},
    // 			StaticFiles: [][]string{ // URL绑定静态文件
    // 				{"/favicon.ico", "public/img/logo_icon.ico"}, // favicon
    // 			},
    // 		},
    // 	}
    // )
    
    // func getIndex(con *service.Context) {
    // 	web.Tpl("index", 100, false, con) // 1.模板文件 2.模板标记(用于主题分类, 例100~199是前台, 200~299是后台, 300~399是专题页面...) 3.是否为PJAX(让网站体验更好) 4.上下文变量
    // }
    
    // func get404(con *service.Context) {
    // 	web.Tpl("404", 200, false, con)
    // }
    
    
    func main() {
    	//httpGet()
    	//httpPost()
    	//httpPostForm()
    	//httpDo()
    
        //https 请求
    	// 在 8000 端口启动服务器
        // 确切地说，如何运行HTTP/1.1服务器。
        srv := &http.Server{Addr:":8000", Handler: http.HandlerFunc(handle)}
        // 用TLS启动服务器，因为我们运行的是http/2，它必须是与TLS一起运行。
        // 确切地说，如何使用TLS连接运行HTTP/1.1服务器。
        log.Printf("Serving on https://0.0.0.0:8000")
    	log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))
    	
    
    	//http 请求
    	http.HandleFunc("/", sayhelloName)
    	err := http.ListenAndServe(":3000", nil)
    	if err != nil {
    		log.Fatal("ListenAndServe: ", err)
    	}
    
        // go  string 转json
    	jsonStr := `{"host": "http://localhost:9090","port": 9090,"analytics_file": "","static_file_version": 1,"static_dir": "E:/Project/goTest/src/","templates_dir": "E:/Project/goTest/src/templates/","serTcpSocketHost": ":12340","serTcpSocketPort": 12340,"fruits": ["apple", "peach"]}`
        //json str 转map
        var dat map[string]interface{}
        if err := json.Unmarshal([]byte(jsonStr), &dat); err == nil {
            fmt.Println("==============json str 转map=======================")
            fmt.Println(dat)
            fmt.Println(dat["host"])
        }
     
        //json str 转struct
        // var config ConfigStruct
        // if err := json.Unmarshal([]byte(jsonStr), &config); err == nil {
        //     fmt.Println("================json str 转struct==")
        //     fmt.Println(config)
        //     fmt.Println(config.Host)
        // }
     
        //json str 转struct(部份字段)
        //var part Other
        // if err := json.Unmarshal([]byte(jsonStr), &part); err == nil {
        //     fmt.Println("================json str 转struct==")
        //     fmt.Println(part)
        //     fmt.Println(part.SerTcpSocketPort)
        // }
     
        //struct 到json str
        // if b, err := json.Marshal(config); err == nil {
        //     fmt.Println("================struct 到json str==")
        //     fmt.Println(string(b))
        // }
     
        //map 到json str
        // fmt.Println("================map 到json str=====================")
        // enc := json.NewEncoder(os.Stdout)
        // enc.Encode(dat)
     
        //array 到 json str
        // arr := []string{"hello", "apple", "python", "golang", "base", "peach", "pear"}
        // lang, err := json.Marshal(arr)
        // if err == nil {
        //     fmt.Println("================array 到 json str==")
        //     fmt.Println(string(lang))
        // }
     
        //json 到 []string
        // var wo []string
        // if err := json.Unmarshal(lang, &wo); err == nil {
        //     fmt.Println("================json 到 []string==")
        //     fmt.Println(wo)
    	// }
    	
    	//go http2.0 
    	// flag.Parse()
    	// client := &http.Client{}
    	// // Create a pool with the server certificate since it is not signed
    	// // by a known CA
    	// caCert, err := ioutil.ReadFile("server.crt")
        //     if err != nil {
     	// 	log.Fatalf("Reading server certificate: %s", err)
    	// }
    	// caCertPool := x509.NewCertPool()
    	// caCertPool.AppendCertsFromPEM(caCert)
    	// // Create TLS configuration with the certificate of the server
    	// tlsConfig := &tls.Config{
    	// 	RootCAs: caCertPool,
    	// }
    
    	// Use the proper transport in the client
    	// switch *httpVersion {
     	// case 1:
    	// 	client.Transport = &http.Transport{
    	// 		TLSClientConfig: tlsConfig,
    	// 	}
    	// case 2:
    	// 	client.Transport = &http2.Transport{
    	// 		TLSClientConfig: tlsConfig,
    	// 	}
    	// }
    	// // Perform the request
    	// resp, err := client.Get(url)
    
    	// if err != nil {
     	// 	log.Fatalf("Failed get: %s", err)
    	// }
    	// defer resp.Body.Close()
    	// body, err := ioutil.ReadAll(resp.Body)
    	// if err != nil {
     	// 	log.Fatalf("Failed reading response body: %s", err)
    	// }
    	// fmt.Printf(
    	// 	"Got response %d: %s %s\n",
    	// 	resp.StatusCode, resp.Proto, string(body))
    		
    
    		// 编码转换 com/data/convert
    		// 加密解密 com/data/crypt
    		// 时间处理 com/data/datetime
    		// 数学计算 com/data/number
    		// 随机数 com/data/random
    		// 切片数据处理 com/data/slice
    		// 字符串数据处理 com/data/strings
    		// ID生成和处理 com/data/uuid
    		// 文件系统 com/sys/fs
    		// 日期处理 mod/data/calendar
    		// Json处理 mod/data/json
    		// 日志Log mod/data/log
    		// 网络数据抓取 mod/net/fetcher
    		// 网络服务框架 mod/net/service (无反射, 性能好, 功能全, 模块化)
    		// 网络服务框架的可选模块 mod/net/service/mod
    		// Web服务端 mod/net/web (开箱即用 100行代码即可包含日志记录, 国际化, 安全加密, 模板功能, 静态文件绑定与路径绑定, 开发模式与发布模式)
    		//web.Log = log.New(os.Stdout, log.LEVEL_DATA, log.DATA_BASIC) // 1.Log输出流(打印到文件还是终端) 2.Log数据显示等级 3.数据详细等级(日期时间代码文件名和行号等)
    		// web.Init()
    		// web.Ser.Rou.Get("/", getIndex)
    		// web.Ser.Rou.NotFound(get404)
    		// web.Run()
    
    		//裸体图像检测
    		// imagePath := "images/test2.jpg"
    		// isNude, err := nude.IsNude(imagePath)
    		// if err != nil {
    		// 	log.Fatal(err)
    		// }
    		// fmt.Printf("isNude = %v\n", isNude)
    }

**推荐：学习go网址：**  
[Go 命令教程][Go]  
[Golang][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]: /images/20230810/fadf1885921d4c1b80d17a50bfa8c939.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70 1]: /images/20230810/4a87c1450af74749a41cd5cb63f1a11a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70 2]: /images/20230810/09b0cb009d9a428d864c72da26fba090.png
[Go]: http://wiki.jikexueyuan.com/project/go-command-tutorial/0.3.html
[Golang]: https://www.yuque.com/lengyuezuixue/vdhg2e