随笔---平衡

美国首富开始造卫星的互联网了，我想我们应该怎么做，怎么才能给国家做这个事情，就是要做到这个事情，我们需要那些产业链。

其实我们还有很多事情可以做，就算不用原创，我们单单追着美国大哥走，也能学到好多东西呢。

所以还是要继续深造，感觉将来的东西还是非常有趣的。

包括机器人啊，各种高科技。

另外，我还有另外一个愿望，我还是想有机会买下一个上市公司的。

当然这个也不怎么花时间精力，更多也是等而已，反正是都是赌的。

也是看概率的事情，目标当然是每个月6%的收益率，那么一年的收益率就有100%以上当然这是理想的情况。

但是至少还有组合的基石在，这样我就能大胆放心地去创了

package common

import "bytes"
import "time"
import "strings"
import "strconv"
import "fmt"
import "encoding/json"
import "encoding/csv"
import "io/ioutil"
import "io"
import "math"
import "log"
import "os"
import "path/filepath"
import "net/http"
import "bufio"
import "os/exec"
import "archive/zip"
import "mime/multipart"
import "reflect"
import "net"

// ------------------------- common version ----------------------
var CommonVersion string = "v0.1.15"
var Desciption string = "Add DoSomething function."

func DoSomething(){
	// 占位函数
	log.Println("do something")
}

func Pass(){
	// 如题,作用类似python 中的pass

}

/* ----------------------------进程相关----------------------------*/
func SimpleExec(args ...string){
    // function : 执行子进程
    // param : 子进程shell命令
    var arg []string
	if len(args) > 1 {
		arg = args[1:]
	}
    cmd := exec.Command(args[0], arg...)
    log.Println("exec command : ",cmd.String())
    err:= cmd.Run()
    if (err!=nil){
        log.Println("exec error : ",err)
    }
}

func StdinExec(input string,args ...string){
	// function : 
	// param args : 子进程shell命令
	// param input : stdin 后续输入,比如Ubuntu权限问题
	var arg []string
	if len(args) > 1 {
		arg = args[1:]
	}
    cmd := exec.Command(args[0], arg...)
	cmd.Stdin = strings.NewReader(input)
    log.Println("exec command : ",cmd.String())
    err:= cmd.Run()
    if (err!=nil){
        log.Println("exec error : ",err)
    }
}

func RedirectErrorExec(redirectPath string,args ...string){
	// 重定向的子进程执行
	var arg []string
	if len(args) > 1 {
		arg = args[1:]
	}
	
	f, _ := os.OpenFile(redirectPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	defer f.Close()
	
    cmd := exec.Command(args[0], arg...)
    log.Println("exec command : ",cmd.String())
	cmd.Stderr = f     // 捕获异常输出
	err:= cmd.Run()
    if (err!=nil){
        log.Println("exec error : ",err)
    }
}

func RedirectStdoutExec(redirectPath string,args ...string){
	// 重定向的子进程执行
	var arg []string
	if len(args) > 1 {
		arg = args[1:]
	}
	
	f, _ := os.OpenFile(redirectPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	defer f.Close()
	
    cmd := exec.Command(args[0], arg...)
    log.Println("exec command : ",cmd.String())
	cmd.Stdout = f     // 捕获异常输出
	err:= cmd.Run()
    if (err!=nil){
        log.Println("exec error : ",err)
    }
}

/*-----------------------------网络请求-----------------------------*/
func Get(url string) (string,error){
	// get请求
	res,err:=http.Get(url)
	if err!=nil{
		log.Println("http get address : ",url,"http error : ",err)
	}

	body,err:=ioutil.ReadAll(res.Body)
	return string(body),err
}

func GetHTMLResponse(address string)(*http.Response,error){
	// function : 通过一个网址获取该网页的html对象
	// param address : 网页链接
	// return : 一个http的返回对象
	resp,err:=http.Get(address)
	if err != nil{
		fmt.Println("请求获取html失败 :",err)
	}

	return resp,err
}


func Post(url string, data interface{}, contentType string) string {
    // example:
    // var url string="http://192.168.209.128:8080/paramPostServer?"+quantity
	// data:=map[string]string{"execFilePath":"string aaa","resultPath":"string bbb"}
	// var result string=Post(url,data,"application/json")
    // 超时时间：5秒
    client := &http.Client{Timeout: 5 * time.Second}
    jsonStr, _ := json.Marshal(data)
    resp, err := client.Post(url, contentType, bytes.NewBuffer(jsonStr))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    result, _ := ioutil.ReadAll(resp.Body)
    return string(result)
}

func post(url string)(string,error){
	// function : http post requests
	// TODO : 未完成
	resp, err := http.Post(url,
        "application/x-www-form-urlencoded",
        strings.NewReader("name=hasaki"))
    if err != nil {
        log.Println("--->http post error : ",err)
    }
 
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Println("--->translate post respone error : ",err)
		return "",err
    }
 
    return string(body),nil
}

func PostFile(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
    // function : 上传单个文件到服务器上
    // param url : 服务器地址
    // param param : form参数
    // param paramName : 服务器上指定的键值,如果服务器上对不上这个名称,服务器会报500
    // param path : 本地文件的路径
    // example
    // path := "D:/pratice/hasakiPic/Mimipigeon/0.jpg"
    // extraParams := map[string]string{
    //    "title":       "My Document",
    // }
    // request, err := newfileUploadRequest("http://127.0.0.1:8080/uploadFile", extraParams, "file", path)
    // if err != nil {
    //    log.Println(err)
    // }
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
 
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile(paramName, filepath.Base(path))
    if err != nil {
        return nil, err
    }
    _, err = io.Copy(part, file)
 
    for key, val := range params {
        _ = writer.WriteField(key, val)
    }
    err = writer.Close()
    if err != nil {
        return nil, err
    }
 
    request, err := http.NewRequest("POST", uri, body)
    request.Header.Add("Content-Type", writer.FormDataContentType())
    return request, err
}

func RequestStatusCheck(status string,code string)bool{
	// http请求返回状态码检查
	if StrInStrings(code,status){
		return true
	}else{
		return false
	}
}

func SaveFileFromNet(url string,savePath string){
	// function : 保存网络文件到本地
	// param savePath : 保存在本地路径  xxx/xxx.jpg
	// param url : link of file
    res, err := http.Get(url)
    if err != nil {
        log.Println("common function save file from Net error")
        return
	}
	if strings.Index(res.Status,"200")==-1{
		log.Println("save file from net function return status code : ",res.Status)
		return
	}
    defer res.Body.Close()
    // 获得get请求响应的reader对象 Note : 这里有文件大小的限制
    reader := bufio.NewReaderSize(res.Body, 1024 * 1024)
    
    file, err := os.Create(savePath)
    if err != nil {
        panic(err)
    }
    // 获得文件的writer对象
    writer := bufio.NewWriter(file)
    io.Copy(writer, reader)
}

func SavePic(url string,savePath string){
	// function : 保存图片到本地
	// param savePath : 图片保存路径  xxx/xxx.jpg
	// param url : 图片网上的地址
    imgPath := savePath
    imgUrl := url
    
    res, err := http.Get(imgUrl)
    if err != nil {
        fmt.Println("common function save picture error")
        return
	}
	if strings.Index(res.Status,"200")==-1{
		fmt.Println("save pictrue function return status code : ",res.Status)
		return
	}
    defer res.Body.Close()
    // 获得get请求响应的reader对象
    reader := bufio.NewReaderSize(res.Body, 64 * 1024)
    
    file, err := os.Create(imgPath)
    if err != nil {
        panic(err)
    }
    // 获得文件的writer对象
    writer := bufio.NewWriter(file)
    io.Copy(writer, reader)
}

func LocalIPv4s() ([]string, error) {
	var ips []string
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		return ips, err
	}

	for _, a := range addrs {
		if ipnet, ok := a.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.To4() != nil {
			ips = append(ips, ipnet.IP.String())
		}
	}

	return ips, nil
}

func LocalIP() string {
	// example :
	// ip := ipv4.LocalIP()
	// fmt.Println(ip)
	// ips, _ := ipv4.LocalIPv4s()
	// fmt.Println(ips)
	ips, _ := LocalIPv4s()
	return ips[0]
}

/*-----------------------------路径相关----------------------------*/
func ExePath()string{
	// function : 返回golang二进制文件的启动位置,golang代码打包之后，这个就会
	// 返回当前程序的路径，如果是通过go run 来运行则会返回一个临时启动的执行路径
	// example : if D:\xxx\abc.exe  result->  D:\xxx
	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
	if err!=nil{
		PrintError(err)
		return ""
	}
	return dir
}

/*-----------------------------定制日志----------------------------*/
func Logging(module string,content string,logFile string){
	// function : 记录普通级别的信息
	// param module : trace/info/warning/error
	// param logFile : 需要写入到文件的路径
	switch module{
	case "trace":
		trace:=log.New(ioutil.Discard,"trace :",log.Ldate|log.Ltime|log.Lshortfile)
		trace.Println(content)
		break
	case "info":
		info:=log.New(os.Stdout,"info :",log.Ldate|log.Ltime|log.Lshortfile)
		info.Println(content)
		break
	case "warning":
		warning:=log.New(os.Stdout,"warning :",log.Ldate|log.Ltime|log.Lshortfile)
		warning.Println(content)
		break
	case "error":
		// 如果用户传过来的地址是个空值的情况就直接打印内容即可
		if len(logFile)<2{
			print(content)
			return
		}
		file,err:=os.OpenFile(logFile,os.O_CREATE|os.O_WRONLY|os.O_APPEND,0666)
		if err!=nil{
			log.Fatalln("common.go logging function failed to open error log file:",err)
		}
		err2:=log.New(io.MultiWriter(file,os.Stderr),"error :",log.Ldate|log.Ltime|log.Lshortfile)
		err2.Println(content)
		break
	default:
		return
	}
}

//---------------------------- 打印相关 ------------------------------------
func Print(content interface{}){
	// function : 简化打印
	fmt.Println(content)
}

func Debug(msg ...string){
    // 带有时间的打印
    log.Println(msg)
}

func PrintError(content error){
	// function : 错误提示
	panic(content)
}

func PrintLocal(content string){
	// function : 写入日志到本地txt文件，日志文件的路径默认在执行文件的同一目录
	dir:=ExePath()
	if len(dir)<2{
		return
	}
	err:=Mkdir(dir+"/log")
	if err!=nil{
		fmt.Println(err)
	}
}

func DateJudge(firstDate string,lastDate string)(bool){
	/*
	function : 判断前后时间是否一致，如果一致则返回真，否则假
	param firstDate : 第一个时间 格式：2019-12-21 20:05
	param lastDate : 第二个时间
	return : 如果一致则返回真，否则假
	*/
	if firstDate==lastDate{
		return true
	}else{
		return false
	}
}
/* ------------------------------ 字符串处理 ------------------------------ */
func StrInStrings(str string,totalString string) bool{
	// 判断一串字符是否在另外一串字符之间
	// param str : 需要判断的字符
	// param totalString : 顾名思义,完整的字符串
	// return : 如果存在则返回true,否则就返回false
	if strings.Index(totalString,str)!=-1{
		// 如果字符串包含则返回非-1整型索引，如果不包含则返回-1
		return true
	}else{
		return false
	}
}

func StrJoin(first string,last string,mid string)(string){
	/*
	function : 拼接合成字符串
	param first : 第一段字符串
	param mid : 中间分割的字符串
	param last : 最后一段字符串
	return : 返回拼接好的字符串
	*/
	return strings.Join([]string{first,last},mid)
}

func StringsJoin(stringList []string , mid string)string{
	// 把一个字符串列表合成有一个字符串,字符串的分割就用mid
	return strings.Join(stringList,mid)
}

func StringsReplace(originStrings string,targetStrings string,replaceSrtings string)string{
	// 字符串替换
	// origin : 原始数据
	// target : 需要被替换的数据
	// replace : 插入字符
	result := strings.Replace(originStrings,targetStrings,replaceSrtings,-1)
	return result
}

/*----------------------------------文件操作--------------------------------*/
func FileExist(path string) bool {
	// 判断文件是否存在
	_, err := os.Lstat(path)
	return !os.IsNotExist(err)
}

func FileSize(filePath string) int64 {
	// 获取文件的大小
	fi,err:=os.Stat(filePath)
	if err!=nil{
		log.Println("common package FileSize function err : ",err)
	}
	return fi.Size()
}

func GetFileNameFromAbsPath(absPath string)string{
    // 从绝对路径中获取文件名
    // abs path example : \\\\192.168.89.200/research/Research/Hasaki/automatedScriptError/hasakiTest.txt
	// return hasakiTest.txt
    fi,err:=os.Stat(absPath)
	if err!=nil{
		log.Println("common package GetFileNameFromAbsPath function err : ",err)
	}
	return fi.Name()
}

func MakeDir(dirPath string){
	// 创建目录
	err:=os.Mkdir(dirPath,os.ModePerm)
	if err!=nil{
		log.Println(err)
	}
}

func CreateFile(filePath string){
	// 创建一个新的文件
	_, err := os.Create(filePath) //创建文件
	if err != nil {
		log.Println("common package createFile function err : ",err)
	}
}

func DeleteFile(filePath string){
	// 删除指定的文件
	err := os.Remove(filePath)
	if err!=nil{
		log.Println("common package delete file err : ",err)
	}
}

func DeleteDir(dir string){
	// 删除整个目录
	err:=os.RemoveAll(dir)
	if err!=nil{
		log.Println("common package delete dir err : ",err)
	}
}

func ReadTxt(path string) []string {
	// 返回txt文件的所有文本数据
	var emptyList []string
	f, err1 := os.Open(path)
	if err1!=nil{
		log.Println("common file -> ReadTxt function err1->",err1)
		return emptyList
	}
	defer f.Close()
	// 一次性读取全部文本数据
	var b = make([]byte, 4096)
	_, err2 := f.Read(b)
	if err2 != nil {
		log.Println("common file -> ReadTxt function err2->",err2)
		return emptyList
	}

	l := strings.Split(string(b), "\r\n")
	return l
}

func ReadJson(path string)(map[string]interface{}){
	/*
	function : 读取json文件并转换成[]map类型
	param path : 需要读取的json文件的路径
	return : 返回
	*/
	byteValue, err := ioutil.ReadFile(path)
	if err!=nil{
		fmt.Println("读取json文件报错,读取的文件地址:",path)
	}

	var result map[string]interface{}
	err = json.Unmarshal(byteValue, &result)
	if err != nil {
		fmt.Println("解析json 错误",err)
	}
	
	return result
}

func WriteJson(path string,mapData interface{}){
	// function : 写入json 文件
	// param mapData : map类型数据
	if jsonData,err:=json.Marshal(mapData);err==nil{
		err := ioutil.WriteFile(path, jsonData, 0644)
		fmt.Println("写入json",err)
	}else{
		fmt.Println("结果错误",err)
	}
}

func ReadJsonForList(path string)([]map[string]interface{}){
	/*
	function : 读取json文件并转换成map类型
	param path : 需要读取的json文件的路径
	return : 返回[]类型的json
	*/
	byteValue, err := ioutil.ReadFile(path)
	if err!=nil{
		log.Println("读取json文件报错,读取的文件地址:",path)
	}

	var result []map[string]interface{}
	
	err = json.Unmarshal(byteValue, &result)
	if err != nil {
		log.Println("解析json 错误",err)
		emptyList:=result
		return emptyList
	}
	
	return result
}

func ReadCSV(path string)[][]string{
	// function : 从本地加载CSV文件，并返回到上层,读取csv
	// 注意到,读取csv的数据是[][]string类型
	// param path : CSV文件路径
	var tampData [][]string
	f, err := os.Open(path)
	if err != nil{
		log.Println("Read CSV Function Open File Error: ", err)
		return tampData
	}
	 
	reader := csv.NewReader(f)
	
	// 可以一次性读完
	csvList, err := reader.ReadAll()
	if err != nil{
		log.Println("Read CSV Function Read All Error: ", err)
		return tampData
	}
	
	return csvList
}

func Mkdir(filePath string)error{
	// function : 创建文件夹
	// param filePath : 文件夹路径
	err:=os.Mkdir(filePath,os.ModePerm)
	return err
}

func GetAllFile(pathname string) ([]string,error) {
	// 获取一个目录下所有的文件
	var nameList []string
	rd, err := ioutil.ReadDir(pathname)
	for _, fi := range rd {
		nameList=append(nameList,fi.Name())
	}
	return nameList,err
}

func Unzip(zipFile string, destDir string) error {
	// 压缩文件
	// param zipFile : 需要压缩的文件夹 xxx/abc.zip
	// param destDir : 压缩之后的路径 xxx/abc   unzip file --> xxx/abc/abc 
    zipReader, err := zip.OpenReader(zipFile)
    if err != nil {
        return err
    }
    defer zipReader.Close()

    for _, f := range zipReader.File {
        fpath := filepath.Join(destDir, f.Name)
        if f.FileInfo().IsDir() {
            os.MkdirAll(fpath, os.ModePerm)
        } else {
            if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
                return err
            }

            inFile, err := f.Open()
            if err != nil {
                return err
            }
            defer inFile.Close()

            outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
            if err != nil {
                return err
            }
            defer outFile.Close()

            _, err = io.Copy(outFile, inFile)
            if err != nil {
                return err
            }
        }
    }
    return nil
}

func MoveFile(oldFile string,newFile string){
	// 剪切文件到新的地方
	err := os.Rename(oldFile, newFile)
	if err!=nil{
		log.Println("common function Move File Error : ",err)
	}
}

func CopyFile(oldFile, destFile string) {
	// 文件复制
	originalFile, err := os.Open(oldFile)   // 打开原始文件
	if err != nil {
		log.Fatal(err)
	}
	defer originalFile.Close()
	
	newFile, err := os.Create(destFile)    // 创建新的文件作为目标文件
	if err != nil {
		log.Fatal(err)
	}
	defer newFile.Close()
	
	_, err = io.Copy(newFile, originalFile)   // 从源中复制字节到目标文件
	if err != nil {
		log.Fatal(err)
	}
}

/* ----------------------------时间相关的操作----------------------*/
func Sleep(n int){
	/*
	function : 睡眠函数
	param n : 睡眠的秒数
	秒:time.Second
	分钟:time.Minute
	小时:time.Hour
	微妙:time.Nanosecond
	*/
	if n<0{
		return
	}

	for i:=0;i<=n;i++{
		time.Sleep(time.Second)
	}
}

func SleepMin(n int){
	// function : 睡眠多少分钟
	// param n : 睡眠的分钟数
	if n<0{
		return
	}
	for i:=0;i<=n;i++{
		time.Sleep(time.Minute)
	}
}

func SleepHour(h int){
	// function : 睡眠的小时数
	if h<0{
		return
	}
	for i:=0;i<h;i++{
		time.Sleep(time.Hour)
	}
}

func NowTime(m string)(string){
	// function : 返回需要的当前时间字符串
	// return : 返回需要的时间字符串
	now:=time.Now().Format("2006-01-02 15:04:05")
	if m=="day"{
		return string([]byte(now[:10]))              // 返回的示例：2019-12-30
	}else{
		now:=time.Now().Unix()
		return string(now)
	}
}

func TimeCompare(time1 string,time2 string)bool{
	// 比较字符串时间的大小 t1早过t2? , 大于则返回true否则返回false
	//先把时间字符串格式化成相同的时间类型
	t1, err1 := time.Parse("2006/01/02", time1)
	t2, err2 := time.Parse("2006/01/02", time2)
	if err1 != nil || err2 != nil{
		log.Println("common package TimeCompare function error 1 : ",err1, "error2" ,err2)
	}
	if t1.Before(t2) {
		return true
	}else{
		return false
	}
}

func TimeFormat(t time.Time)string{
	// 返回2020-8-4 00:00:00格式的时间字符串
	timeString := t.Format("2006-01-02 15:04:05")
	return timeString
}

func Hour()int{
	// 当前时间的小时数据
	now := time.Now()
	hour, _, _ := now.Clock()
	return hour
}

func WeekDay()int{
	// 返回今天是星期几
	now := time.Now()
	wd:=now.Weekday().String()
	var weekDayNum int
	switch wd {
	case "Monday":
		weekDayNum=1
	case "Tuesday":
		weekDayNum=2
	case "Wednesday":
		weekDayNum=3
	case "Thursday":
		weekDayNum=4
	case "Friday":
		weekDayNum=5
	case "Saturday":
		weekDayNum=6
	case "Sunday":
		weekDayNum=7
	}
	return weekDayNum
}

func IntegralPoint()(bool){
	// function : 判断当前时间是否为整点
	// 如果不为整点则返回false
	time:=NowTime("day")
	if strings.Index(time,"00:00:")!=-1{
		return true
	}else{
		return false
	}
}

/* ------------------------------ 算法相关 ----------------------------- */
func ListReverse(l []string)  {
    // 对字符串数组进行reverse
    // example:
    // a:=[]string{"1","2","3"}
    // listReverse(a)
    // fmt.Println(a)  --> "3","2","1"
    for i:=0; i < int(len(l)/2) ;i++{
        li := len(l) - i -1
        l[i],l[li] = l[li],l[i]
    }
}

func CalculateArrayLengh(targetList []string) string{
	// 计算数组长度
	var lengh int = len(targetList)
	return strconv.Itoa(lengh)
}

/*--------------------------------数学相关-------------------------------*/
func Min(a, b int) int {
	// function : 判断两个整型的大小
	if a <= b {
		return a
	}
	return b
}

func Max(a, b int) int {
	// function : 判断两个整型的大小
	if a >= b {
		return a
	}
	return b
}

/*--------------------------------类型转换-------------------------------*/
func Type(data interface{}){
	// 检查数据类型
	log.Println("Type of the data : ",reflect.TypeOf(data))
}

func IntToStr(num int)(string){
	/*
	function : 整型转换成字符串
	param num : 整型
	return : ...
	*/
	return strconv.Itoa(num)
}

func StructToJson(s interface{})string{
	// function : 结构体转json字符串
	// return : 返回json字符串
	var data string
	if dataU,err:=json.MarshalIndent(s,"","    ");err==nil{
		// fmt.Println(fmt.Sprintf("%T",dataU)) []uint8
		data=string(dataU)
	}else{
		fmt.Println("结构体转json结果错误",err)
	}
	return data
}

func Float64ToInt(f float64)int{
	// function : float64转int
	return int(math.Floor(f))
}

func Uint8ToStr(uint8Data []uint8) string {
	// function : uint8转字符串
	return string(uint8Data)
}

func JsonToMap(jsonStr string) map[string]interface{}{
	// function : json转map
	var returnData map[string]interface{}
	err:=json.Unmarshal([]byte(jsonStr),&returnData)
	if err!=nil{
		fmt.Println("json转map报错",jsonStr,"错误原因:",err)
	}
	return returnData
}

func Uint8ToMap(uint8Data []uint8) interface{}{
	// uint8转map
	var returnData map[string]interface{}
	err:=json.Unmarshal(uint8Data,&returnData)
	if err!=nil{
		fmt.Println("uint8转map",uint8Data,err)
	}
	return returnData
}

func MapToByte(mapData map[string]interface{}) []byte {
	// function : map 转 byte数组
	mJson,_:=json.Marshal(mapData)
	mJsonStr:=string(mJson)
	mByte:=[]byte(mJsonStr)
	return mByte
}

/* --------------------- 字符串处理 --------------------------*/
func DeleteBlank(str string)string{
	// 删除字符串中的空格
	str = DeteleStrInStr(str," ")
	return str
}

func DeteleStrInStr(str string,dstr string)string{
	// 删除字符串中指定的字符
	str = strings.Replace(str, dstr, "", -1)
	return str
}