美国首富开始造卫星的互联网了，我想我们应该怎么做，怎么才能给国家做这个事情，就是要做到这个事情，我们需要那些产业链。
其实我们还有很多事情可以做，就算不用原创，我们单单追着美国大哥走，也能学到好多东西呢。
所以还是要继续深造，感觉将来的东西还是非常有趣的。
包括机器人啊，各种高科技。
另外，我还有另外一个愿望，我还是想有机会买下一个上市公司的。
当然这个也不怎么花时间精力，更多也是等而已，反正是都是赌的。
也是看概率的事情，目标当然是每个月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
}
