### /判斷文件路徑判斷文件是否是符合要求的圖片格式，jpeg,jpg,gif,png,bmp,tif,tiff//@path string 文件路徑
```
func IsImage(path string) bool {
slice := strings.Split(path, ".")
ext := strings.ToLower(strings.TrimSpace(slice[len(slice)-1]))
exts := map[string]string{"jpeg": "jpeg", "jpg": "jpg", "gif": "gif", "png": "png", "bmp": "bmp", "tif": "tif", "tiff": "tiff"}
_, ok := exts[ext]return ok}
```
// 圖片縮放居中裁剪
//圖片縮放居中裁剪
//@param file 圖片文件
//@param width 圖片寬度
//@param height 圖片高度
//@return err 錯誤
```
func CropImage(file string, width, height int) (err error) {
var img image.Image
img, err = imaging.Open(file)
if err != nil {
return
}
ext := strings.ToLower(filepath.Ext(file))
switch ext {
case ".jpeg", ".jpg", ".png", ".gif":
img = imaging.Fill(img, width, height, imaging.Center, imaging.CatmullRom)
default:
err = errors.New("unsupported image format")
return
}
return imaging.Save(img, file)
}
```
// 刪除切片中的指定key，并返回
```
func DeleteSlice(slice []string, keys ...string) []string {
if len(keys) == 0 {
return slice
}
for _, key := range keys {
var tmpSlice []string
for _, item := range slice {
if item != key {
tmpSlice = append(tmpSlice, item)
}
}
slice = tmpSlice
}
return slice
}
```
//比較兩個內容的字符串類型是否相等
```
func Equal(itf1, itf2 interface{}) bool {
return fmt.Sprintf("%v", itf1) == fmt.Sprintf("%v", itf2)
}
```
//MD5加密函數
//@str string 需要進行加密的字符串
```
func MD5Crypt(str string) string {
h := md5.New()
h.Write([]byte(str))
return hex.EncodeToString(h.Sum(nil))
}
```
//時間戳格式化
//@timestamp int 時間戳
//@format string 時間格式，如："2006-01-02 15:04:05"
```
func TimestampFormat(timestamp int, format ...string) string {
formats := "2006-01-02 15:04:05"
if len(format) > 0 {
formats = format[0]
}
return time.Unix(int64(timestamp), 0).Format(formats)
}
```
//將字符串或者其他可轉化數字的內容格式化成int數字類型返回
//@param a interface{} 需要轉化成數字的內容
```
func Interface2Int(a interface{}) int {
i, _ := strconv.Atoi(fmt.Sprintf("%v", a))
return i
}
```
//生成url鏈接
//@param prefix 前綴
//@param params 參數
//@return urlstr 返回組裝后的url
```
func BuildURL(prefix string, params ...interface{}) (urlstr string) {
var (
l int
url []string
)
url = append(url, "/"+strings.Trim(prefix, "/"))
l = len(params)
if l != (l/2)*2 {
l = (l / 2) * 2
}
if l > 0 {
for i := 0; i < l; {
k := fmt.Sprintf("%v", params[i])
v := fmt.Sprintf("%v", params[i+1])
if len(k) > 0 && v != "0" {
url = append(url, fmt.Sprintf("%v/%v", k, v))
}
i += 2
}
}
urlstr = strings.TrimRight(strings.Join(url, "/"), "/")
//fmt.Println("BuildURL:", prefix, params, len(params), url)
return
}
```
//圖片文件信息
```
type Info struct {
Width, Height int //圖片寬高
Size int64 //圖片文件大小
Md5 string //圖片md5
ModTime int //圖片修改時間戳
Ext string //圖片后綴
}
```
//判斷文件路徑判斷文件是否是符合要求的圖片格式，jpeg,jpg,gif,png,bmp,tif,tiff
//@path string 文件路徑
```
func IsImage(path string) bool {
slice := strings.Split(path, ".")
ext := strings.ToLower(strings.TrimSpace(slice[len(slice)-1]))
exts := map[string]string{"jpeg": "jpeg", "jpg": "jpg", "gif": "gif", "png": "png", "bmp": "bmp", "tif": "tif", "tiff": "tiff"}
_, ok := exts[ext]
return ok
}
```
//獲取文件的MD5
//@path string 文件路徑
```
func FileMd5(path string) (string, error) {
var md5str string
var err error
var file *os.File
file, err = os.Open(path)
defer file.Close()
if err != nil {
return md5str, err
}
md5h := md5.New()
_, err = io.Copy(md5h, file)
if err == nil {
md5str = fmt.Sprintf("%x", md5h.Sum(nil))
}
return md5str, err
}
```
//根據字符串后綴，比如根據文件路徑獲取后綴等
//@str string 字符串或者文件路徑
//@seg string 分隔符
```
func GetSuffix(str, seg string) string {
slice := strings.Split(str, seg)
l := len(slice)
if l > 1 {
return slice[(l - 1)]
}
return ""
}
```
//將interface{}轉為字符串，適合bool，數字等
//@v interface{} 需要轉化為字符串的值
```
func Interface2String(v interface{}) string {
return fmt.Sprintf("%v", v)
}
```
//整型計算
```
func CalcInt(num1 interface{}, oper string, num2 interface{}) int {
val := 0
n1 := Interface2Int(num1)
n2 := Interface2Int(num2)
switch oper {
case "+":
val = n1 + n2
case "-":
val = n1 - n2
case "*":
val = n1 * n2
case "%":
if n2 != 0 {
val = n1 % n2
}
case "/":
if n2 != 0 {
val = n1 / n2
}
}
return val
}
```
//根據切片或數組下表，移除元素
```
func DelSlice(slice []interface{}, index int) []interface{} {
return append(slice[:index], slice[index+1:]...)
}
```
//sha1加密
//@param str string 需要加密的字符串
//@return string 加密后的字符串
```
func MySha1(str string) string {
return fmt.Sprintf("%x", sha1.New().Sum([]byte(str)))
}
```
//設置緩存
```
func CacheSet(key string, value interface{}, t time.Duration) error {
bc, err := cache.NewCache("file", CACHE_CONF)
if err == nil {
return bc.Put(key, value, t)
}
return err
}
```
//獲取緩存
```
func CacheGet(key string) (interface{}, error) {
bc, err := cache.NewCache("file", CACHE_CONF)
if err == nil && bc.IsExist(key) {
return bc.Get(key), nil
}
return nil, err
}
```
//獲取指定個數的隨機字符串
//@param size int 指定的字符串個數
//@param kind int 0，純數字；1，小寫字母；2，大寫字母；3，數字+大小寫字母
//@return string 返回生成的隨機字符串
```
func RandStr(size int, kind int) string {
ikind, kinds, result := kind, [][]int{[]int{10, 48}, []int{26, 97}, []int{26, 65}}, make([]byte, size)
isAll := kind > 2 || kind < 0
rand.Seed(time.Now().UnixNano())
for i := 0; i < size; i++ {
if isAll { // random ikind
ikind = rand.Intn(3)
}
scope, base := kinds[ikind][0], kinds[ikind][1]
result[i] = uint8(base + rand.Intn(scope))
}
return string(result)
}
```
//轉換字節大小
```
func FormatByte(size int) string {
fsize := float64(size)
//字節單位
units := [6]string{"B", "KB", "MB", "GB", "TB", "PB"}
var i int
for i = 0; fsize >= 1024 && i < 5; i++ {
fsize /= 1024
}
num := fmt.Sprintf("%.2f", fsize)
return string(num) + " " + units[i]
}
```
//獲取文檔擴展名分類以及擴展名分類對應的catenum數字
//@param ext 擴展名
//@return extCate 文檔類型(字符串)
//@return extNum 文檔類型(整型)
```
func GetExtCate(ext string) (extCate string, extNum int) {
ext = strings.ToLower(strings.TrimLeft(ext, "."))
extNum = EXT_NUM_OTHER
switch ext {
case "doc", "docx", "rtf", "wps", "odt":
extCate = EXT_CATE_WORD
extNum = EXT_NUM_WORD
case "ppt", "pptx", "pps", "ppsx", "dps", "odp", "pot":
extCate = EXT_CATE_PPT
extNum = EXT_NUM_PPT
case "xls", "xlsx", "et", "ods":
extCate = EXT_CATE_EXCEL
extNum = EXT_NUM_EXCEL
case "pdf":
extCate = EXT_CATE_PDF
extNum = EXT_NUM_PDF
case "txt":
extCate = EXT_CATE_TEXT
extNum = EXT_NUM_TEXT
case EXT_CATE_OTHER_UMD, EXT_CATE_OTHER_CHM, EXT_CATE_OTHER_EPUB, EXT_CATE_OTHER_MOBI: // cate other
extCate = ext
}
return
}
```
//分頁函數
//rollPage:展示分頁的個數
//totalRows：總記錄
//currentPage:每頁顯示記錄數
//urlPrefix:url鏈接前綴
//urlParams:url鍵值對參數
```
func Paginations(rollPage, totalRows, listRows, currentPage int, urlPrefix string, urlParams ...interface{}) string {
var (
htmlPage, path string
pages []int
params []string
)
if listRows <= 0 {
listRows = 10
}
//總頁數
totalPage := totalRows / listRows
if totalRows%listRows > 0 {
totalPage += 1
}
//只有1頁的時候，不分頁
if totalPage < 2 {
return ""
}
params_len := len(urlParams)
if params_len > 0 {
if params_len%2 > 0 {
params_len = params_len - 1
}
for i := 0; i < params_len; {
key := strings.TrimSpace(fmt.Sprintf("%v", urlParams[i]))
val := strings.TrimSpace(fmt.Sprintf("%v", urlParams[i+1]))
//鍵存在，同時值不為0也不為空
if len(key) > 0 && len(val) > 0 && val != "0" {
params = append(params, key, val)
}
i = i + 2
}
}
path = strings.Trim(urlPrefix, "/")
if len(params) > 0 {
path = path + "/" + strings.Trim(strings.Join(params, "/"), "/")
}
//最后再處理一次“/”，是為了防止urlPrifix參數為空時，出現多余的“/”
path = "/" + strings.Trim(path, "/") + "/p/"
if currentPage > totalPage {
currentPage = totalPage
}
if currentPage < 1 {
currentPage = 1
}
index := 0
rp := rollPage * 2
for i := rp; i > 0; i-- {
p := currentPage + rollPage - i
if p > 0 && p <= totalPage {
pages = append(pages, p)
}
}
for k, v := range pages {
if v == currentPage {
index = k
}
}
pages_len := len(pages)
if currentPage > 1 {
htmlPage += fmt.Sprintf(`<li><a class="num" href="`+path+`1">1..</a></li><li><a class="num" href="`+path+`%d"><<</a></li>`, currentPage-1)
}
if pages_len <= rollPage {
for _, v := range pages {
if v == currentPage {
htmlPage += fmt.Sprintf(`<li class="active"><a href="javascript:void(0);">%d</a></li>`, v)
} else {
htmlPage += fmt.Sprintf(`<li><a class="num" href="`+path+`%d">%d</a></li>`, v, v)
}
}
} else {
index_min := index - rollPage/2
index_max := index + rollPage/2
page_slice := make([]int, 0)
if index_min > 0 && index_max < pages_len { //切片索引未越界
page_slice = pages[index_min:index_max]
} else {
if index_min < 0 {
page_slice = pages[0:rollPage]
} else if index_max > pages_len {
page_slice = pages[(pages_len - rollPage):pages_len]
} else {
page_slice = pages[index_min:index_max]
}
}
for _, v := range page_slice {
if v == currentPage {
htmlPage += fmt.Sprintf(`<li class="active"><a href="javascript:void(0);">%d</a></li>`, v)
} else {
htmlPage += fmt.Sprintf(`<li><a class="num" href="`+path+`%d">%d</a></li>`, v, v)
}
}
}
if currentPage < totalPage {
htmlPage += fmt.Sprintf(`<li><a class="num" href="`+path+`%d">>></a></li><li><a class="num" href="`+path+`%d">..%d</a></li>`, currentPage+1, totalPage, totalPage)
}
return htmlPage
}
```
//將字符串切片轉成interface切片
```
func StringSliceToInterfaceSlice(slice []string) (ret []interface{}) {
for _, v := range slice {
ret = append(ret, v)
}
return ret
}
```
//將字符串切片數組轉成map
```
func StringSliceToMap(slice []string) (maps map[string]string) {
maps = make(map[string]string)
for _, v := range slice {
maps[v] = v
}
return maps
}
```
//分詞
//@param str 需要分詞的文字
```
func SegWord(str interface{}) (wds string) {
//如果已經成功加載字典
if Segmenter.Dictionary() != nil {
wds = sego.SegmentsToString(Segmenter.Segment([]byte(fmt.Sprintf("%v", str))), true)
var wdslice []string
slice := strings.Split(wds, " ")
for _, wd := range slice {
w := strings.Split(wd, "/")[0]
if (strings.Count(w, "") - 1) >= 2 {
if Interface2Int(w) == 0 { //如果為0，則表示非數字
wdslice = append(wdslice, w)
}
}
}
wds = strings.Join(wdslice, ",")
}
return
}
```
//url請求處理
```
func UrlEscape(str string) string {
return strings.TrimSpace(url.QueryEscape(strings.Replace(str, "/", " ", -1)))
}
```
//字符串截取
```
func SubStr(str interface{}, start, length int) string {
v := fmt.Sprintf("%v", str)
if start < 0 {
start = 0
}
slice := strings.Split(v, "")
l := len(slice)
if l == 0 || start > l {
return ""
}
if start+length+1 > l {
return strings.Join(slice[start:], "")
}
return strings.Join(slice[start:length], "")
}
```
//文件下載，這里只是簡單的文檔下載，復雜點的，需要根據Content-Type去做處理
//@param fileUrl 文件下載URL連接
//@param savePath 文件存放文件夾
//@param cookies COOKIE
//@return md5str 文檔的md5
//@return localFile 本地存放文件，err為nil時才需要處理文件，否則不需要處理
//@return filename 文件下載時的文件名
//@return err 錯誤
```
func DownFile(fileUrl, savePath string, cookies string) (md5str, localFile, filename string, err error) {
var (
resp *http.Response //響應內容
ext string //文件擴展名
)
//創建HTTP請求
req := crawl.BuildRequest("get", fileUrl, "", cookies, "mac", true, false)
resp, err = req.DoRequest()
if err != nil {
return
}
defer resp.Body.Close()
if resp.StatusCode >= 300 {
err = errors.New(fmt.Sprintf("HTTP響應頭錯誤：%v。文件下載地址：%v", resp.Status, fileUrl))
return
}
if attachmentArr := strings.Split(resp.Header.Get("Content-Disposition"), "="); len(attachmentArr) == 2 {
filename = strings.Trim(attachmentArr[1], `"'`)
ext = filepath.Ext(filename)
}
if len(ext) == 0 {
filepath.Ext(fileUrl)
}
ext = strings.ToLower(ext)
os.MkdirAll(savePath, 0777)
tmpFile := strings.TrimSuffix(savePath, "/") + "/" + MD5Crypt(filename) + ext
if err = req.ToFile(tmpFile); err != nil {
return
}
//計算文檔md5
if md5str, err = FileMd5(tmpFile); err != nil {
return
}
//重命名文檔
localFile = strings.TrimSuffix(savePath, "/") + "/" + md5str + ext
err = os.Rename(tmpFile, localFile) //重命名文件
return
}
```
//數字變化范圍
//@param val int 需要處理的參數數字
//@param min int 最小值
//@param max int 最大值
//@return int 返回最大值與最小值之間的值
```
func NumberRange(val, min, max int) int {
if val < min {
return min
}
if val > max {
return max
}
return val
}
```
//首字母大寫
```
func UpperFirst(str string) string {
if len(str) > 0 {
strings.Replace(str, str[0:1], strings.ToUpper(str[0:1]), 1)
}
return str
}
```
//頁數處理，處理頁數為0或者頁數為空的時候的顯示
```
func HandlePageNum(PageNum interface{}) string {
pn := strings.TrimSpace(fmt.Sprintf("%v", PageNum))
if pn == "0" || pn == "" {
return " -- "
}
return pn
}
```
- go環境搭建
- 解決go get網絡慢的問題
- beego的安裝
- bee的安裝
- 編輯器
- go module
- 配置文件詳解
- 配置文件其他說明
- 路由方法
- 路由
- 數據校驗
- 校驗函數
- 頁面跳轉
- 獲取前端數據
- json文件的獲取
- xsrf的用法
- xsrf的防護
- srfs和json的搭配
- flash的用法
- 過濾器
- url反轉
- 各類數據的處理
- 模板函數
- 內置模板函數
- 自定義模板函數
- 模板
- 模板處理
- 模板渲染
- 視圖文件的處理
- 靜態文件
- 請求方式判斷
- 驗證碼
- 另一種方法
- 分頁類
- session
- 登錄判斷
- orm模塊
- 使用方法
- mysql的安裝
- 安裝orm及驅動
- 建立模型
- 自定義模型
- 增刪改查
- 高級查詢
- 常見問題匯總
- 代碼收藏
- 打包部署
- go build打包
- utils收藏
- 新goer容易犯的錯
- 字符串操作