test/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf.git synced 2024-12-01 11:48:09 +08:00
Code Issues Actions 15 Packages Projects Releases Wiki Activity

Merge branch 'master' into test_gfile

Browse Source
This commit is contained in:
jroam 2019-04-10 11:28:57 +08:00
commit 4bf9a7950b
39 changed files with 1062 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
README.MD
View File

@ -5,9 +5,8 @@
[![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf)
[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf)
[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
[![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
[![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
<!--
GoFrame is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: cache, logging, containers, timer, validator, database orm, etc. Supporting web server integrated with router, cookie, session, logger, configure, template, https, hooks, rewrites and many more features.
@ -31,7 +30,7 @@ golang version >= 1.9.2
# Documentation
* [GoDoc](https://godoc.org/github.com/gogf/gf)
* [APIDoc](https://godoc.org/github.com/gogf/gf)
* [中文文档](https://goframe.org)
# Architecture
@ -67,28 +66,32 @@ func main() {
# Contributors
- [johng](https://gitee.com/johng)
- [zhaopengme](https://github.com/zhaopengme)
- [wenzi1](https://gitee.com/wenzi1)
- [zseeker](https://gitee.com/zseeker)
- [ymrjqyy](https://gitee.com/ymrjqyy)
- [chenyang351](https://github.com/chenyang351)
- [wxkj](https://gitee.com/wxkj)
- [wxkj001](https://github.com/wxkj001)
- [zhangjinfu](https://gitee.com/zhangjinfu)
- [garfieldkwong](https://gitee.com/garfieldkwong)
- [hailaz](https://gitee.com/hailaz)
- [johng](https://gitee.com/johng)
- [pibigstar](https://github.com/pibigstar)
- [qq1054000800](https://gitee.com/qq1054000800)
- [wenzi1](https://gitee.com/wenzi1)
- [wxkj001](https://github.com/wxkj001)
- [ymrjqyy](https://gitee.com/ymrjqyy)
- [youyixiao](https://github.com/youyixiao)
- [zhangjinfu](https://gitee.com/zhangjinfu)
- [zhaopengme](https://github.com/zhaopengme)
- [zseeker](https://gitee.com/zseeker)
# Donators
- [tiangenglan](https://gitee.com/tiangenglan)
- [zhuhuan12](https://gitee.com/zhuhuan12)
- [zfan_codes](https://gitee.com/zfan_codes)
- [flyke-xu](https://gitee.com/flyke-xu)
- [hailaz](https://gitee.com/hailaz)
- [mg91](https://gitee.com/mg91)
- [wxkj](https://gitee.com/wxkj)
- [pibigstar](https://github.com/pibigstar)
- [flyke-xu](https://gitee.com/flyke-xu)
- [tiangenglan](https://gitee.com/tiangenglan)
- [wxkj](https://gitee.com/wxkj)
- [zhuhuan12](https://gitee.com/zhuhuan12)
- [zfan_codes](https://gitee.com/zfan_codes)

32
README_ZH.MD
View File

@ -5,9 +5,8 @@
[![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf)
[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf)
[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
[![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
[![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
`GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
@ -87,25 +86,28 @@ func main() {
# 贡献者
- [johng](https://gitee.com/johng)
- [zhaopengme](https://github.com/zhaopengme)
- [wenzi1](https://gitee.com/wenzi1)
- [zseeker](https://gitee.com/zseeker)
- [ymrjqyy](https://gitee.com/ymrjqyy)
- [chenyang351](https://github.com/chenyang351)
- [wxkj](https://gitee.com/wxkj)
- [wxkj001](https://github.com/wxkj001)
- [zhangjinfu](https://gitee.com/zhangjinfu)
- [garfieldkwong](https://gitee.com/garfieldkwong)
- [hailaz](https://gitee.com/hailaz)
- [johng](https://gitee.com/johng)
- [pibigstar](https://github.com/pibigstar)
- [qq1054000800](https://gitee.com/qq1054000800)
- [wenzi1](https://gitee.com/wenzi1)
- [wxkj001](https://github.com/wxkj001)
- [ymrjqyy](https://gitee.com/ymrjqyy)
- [youyixiao](https://github.com/youyixiao)
- [zhangjinfu](https://gitee.com/zhangjinfu)
- [zhaopengme](https://github.com/zhaopengme)
- [zseeker](https://gitee.com/zseeker)
# 捐赠者
- [tiangenglan](https://gitee.com/tiangenglan)
- [zhuhuan12](https://gitee.com/zhuhuan12)
- [zfan_codes](https://gitee.com/zfan_codes)
- [flyke-xu](https://gitee.com/flyke-xu)
- [hailaz](https://gitee.com/hailaz)
- [mg91](https://gitee.com/mg91)
- [wxkj](https://gitee.com/wxkj)
- [pibigstar](https://github.com/pibigstar)
- [flyke-xu](https://gitee.com/flyke-xu)
- [tiangenglan](https://gitee.com/tiangenglan)
- [wxkj](https://gitee.com/wxkj)
- [zhuhuan12](https://gitee.com/zhuhuan12)
- [zfan_codes](https://gitee.com/zfan_codes)

48
RELEASE.MD
View File

@ -1,3 +1,51 @@
# `v1.6.0` (2019-04-09)
## 新功能/改进
1. `gcron`定时任务模块增加运行日志记录功能：https://goframe.org/os/gcron/index
1. `gredis`增加全局分组配置功能，并增加更多的配置选项`maxIdle/maxActive/idleTimeout/maxConnLifetime`：https://goframe.org/database/gredis/index
1. `gcfg`模块增加更多的默认配置文件检索路径，并且增加全局分组配置特性，增加`Instance`单例方法：https://goframe.org/os/gcfg/index
1. `gview`模块增加更多的默认配置文件检索路径，并且增加`Instance`单例方法：https://goframe.org/os/gview/index
1. `ghttp`模块新功能及改进：
- 新增`CORS`HTTP(S)跨域请求特性: https://goframe.org/net/ghttp/cors
- 增加`TLSConfig`配置功能；
- 去掉路由注册方法的`error`返回值，当产生注册错误时直接终端打印错误/输出到日志文件；
- 增加在`HTTP Code 302`跳转时的`Set-Cookie`支持；
- 增加对`SESSION ID`的安全性检查；
- 增加对基于`HTTPS`的`WebSocket`支持（`WSS`）：https://goframe.org/net/ghttp/websocket/index
- `Request`对象增加`Error`方法，用于输出自定义错误信息到`WebServer`错误日志中；
- 其他一些改进；
1. `gdb`模块新功能及改进：
- 新增`Instance`单例管理方法；
- 新增`Structs/Scan`链式操作方法，`gdb.DB/TX`新增`GetStructs/GetScan`方法，用于结果集`struct`/`slice`映射转换：https://goframe.org/database/gdb/chaining
- 新增`Safe`链式操作方法（默认非并发安全），用于链式安全控制：https://goframe.org/database/gdb/chaining
- `Where`链式操作方法改进：
- 方法支持任意的`string/map/slice/struct/*struct`类型；
- 逻辑调整，当链式操作中存在多个`Where`方法调用时，自动转换为`And`条件；
- 支持`slice`条件参数，常用在`SELECT IN`查询中，例如：`Where("uid IN(?)", g.Slice{1,2,3})`；
- 支持在`map`类型条件参数的`key`中传递条件，例如：`Where(g.Map{"uid>?", uid})`；
1. `gconv`及`gvalid`模块改进并去掉对私有`struct`方法属性的转换/校验；
1. `gconv.Map`转换方法新增对`json tag`: `-`, `omitempty`的支持: https://goframe.org/util/gconv/map
1. `gstr`模块新增 `ReplaceI/ReplaceIByArray/ReplaceIByMap`大小写非敏感替换方法；
1. `gutil`模块增加`IsEmpty`方法，用于判断给定变量是否为空（整型0, 布尔false, slice/map长度为0, 其他为nil的情况，判断为空），并增加快捷方法`g.IsEmpty`；
1. `gutil`模块增加`Export`方法，用于导出返回格式化打印的变量内容字符串，并增加快捷方法`g.Export`；
1. `gspath`增加缓存及非缓存检索检索方法`Search`/`SearchWithCache`；
1. `gjson`模块增加默认的`UseNumber`功能支持；
1. `gmap`增加`SetIfNotExistFunc/SetIfNotExistFuncLock`方法；
1. 迁移`greuseport`模块到新的仓库：https://github.com/gogf/greuseport
1. 大量的单元测试完善；
## Bug Fix
1. 修复`gqueue`模块的资源竞争问题；
1. 修复`gconv.GTime`转换失败问题；
1. 修复`gconv.String`在转换`int`参数时字节溢出问题；
1. 修复`ghttp.Request`的`HTTP Basic Auth`校验问题；
1. 修复`gxml`针对于非`UTF-8`编码内容转换的并发安全问题；
1. 修复`gtime`部分`Format`（`G`&`j`）格式失效问题；
1. 修复`gudp.Conn`对象的`RemoteAddr`获取客户端连接地址方法问题；
1. 修复`gmap/gcache`模块的`GetOrSetFuncLock`方法，增加对回调方法返回值的`nil`判断，只有非nil返回值才会被保存；
# `v1.5.8` (2019-02-28)
## 新特性

1
TODO.MD
View File

@ -44,7 +44,6 @@
1. 添加sqlite数据库的单元测试用例；
1. gredis增加cluster支持；
# DONE
1. gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；
2. ghttp.Server请求执行中增加服务退出的方法，不再执行后续操作；

7
g/container/container.go
View File

@ -1,7 +0,0 @@
// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package container

7
g/crypto/crypto.go
View File

@ -1,7 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package crypto

7
g/database/database.go
View File

@ -1,7 +0,0 @@
// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package database

2
g/database/gredis/gredis.go
View File

@ -107,7 +107,7 @@ func New(config Config) *Redis {
// return redis instance with default group.
//
// 获取指定分组名称的Redis单例对象，底层根据配置信息公用的连接池（连接池单例）。
func Instance(name...string) *Redis {
func Instance(name ...string) *Redis {
group := DEFAULT_GROUP_NAME
if len(name) > 0 {
group = name[0]

7
g/encoding/encoding.go
View File

@ -1,7 +0,0 @@
// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package encoding

7
g/frame/frame.go
View File

@ -1,7 +0,0 @@
// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package frame

8
g/g.go
View File

@ -9,13 +9,9 @@ package g
import "github.com/gogf/gf/g/container/gvar"
// Universal variable type, like generics.
//
// 动态变量类型，可以用该类型替代interface{}类型
type Var = gvar.Var
// Frequently-used map type alias.
//
// 常用map数据结构(使用别名)
type Map = map[string]interface{}
type MapAnyAny = map[interface{}]interface{}
type MapAnyStr = map[interface{}]string
@ -28,8 +24,6 @@ type MapIntStr = map[int]string
type MapIntInt = map[int]int
// Frequently-used slice type alias.
//
// 常用list数据结构(使用别名)
type List = []Map
type ListAnyStr = []map[interface{}]string
type ListAnyInt = []map[interface{}]int
@ -41,8 +35,6 @@ type ListIntStr = []map[int]string
type ListIntInt = []map[int]int
// Frequently-used slice type alias.
//
// 常用slice数据结构(使用别名)
type Slice = []interface{}
type SliceAny = []interface{}
type SliceStr = []string

22
g/g_func.go
View File

@ -13,38 +13,28 @@ import (
"github.com/gogf/gf/g/util/gutil"
)
// NewVar creates a *Var.
//
// 动态变量
// NewVar returns a *gvar.Var.
func NewVar(i interface{}, unsafe...bool) *Var {
return gvar.New(i, unsafe...)
}
// Wait blocks until all the web servers shutdown.
//
// 阻塞等待HTTPServer执行完成(同一进程多HTTPServer情况下)
func Wait() {
ghttp.Wait()
}
// Dump dumps a variable to stdout with more manually readable.
//
// 格式化打印变量.
func Dump(i...interface{}) {
gutil.Dump(i...)
}
// Export exports a variable to string with more manually readable.
//
// 格式化导出变量.
func Export(i...interface{}) string {
return gutil.Export(i...)
}
// Throw throws a exception, which can be caught by Catch function.
// Throw throws a exception, which can be caught by TryCatch function.
// It always be used in TryCatch function.
//
// 抛出一个异常
func Throw(exception interface{}) {
gutil.Throw(exception)
}
@ -55,12 +45,8 @@ func TryCatch(try func(), catch ... func(exception interface{})) {
}
// IsEmpty checks given value empty or not.
// false: integer(0), bool(false), slice/map(len=0), nil;
// true : other.
//
// 判断给定的变量是否为空。
// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
// 为空时返回true，否则返回false。
// It returns false if value is: integer(0), bool(false), slice/map(len=0), nil;
// or else true.
func IsEmpty(value interface{}) bool {
return empty.IsEmpty(value)
}

12
g/g_logger.go
View File

@ -10,23 +10,17 @@ import (
"github.com/gogf/gf/g/os/glog"
)
// Disable/Enabled debug of logging globally.
//
// 是否显示调试信息
// SetDebug disables/enables debug level for logging globally.
func SetDebug(debug bool) {
glog.SetDebug(debug)
}
// Set the logging level globally.
//
// 设置日志的显示等级
// SetLogLevel sets the logging level globally.
func SetLogLevel(level int) {
glog.SetLevel(level)
}
// Get the global logging level.
//
// 获取设置的日志显示等级
// GetLogLevel returns the global logging level.
func GetLogLevel() int {
return glog.GetLevel()
}

33
g/g_object.go
View File

@ -17,59 +17,42 @@ import (
"github.com/gogf/gf/g/os/gcfg"
)
// Get an instance of http server with specified name.
//
// HTTPServer单例对象
// Server returns an instance of http server with specified name.
func Server(name...interface{}) *ghttp.Server {
return ghttp.GetServer(name...)
}
// Get an instance of tcp server with specified name.
//
// TCPServer单例对象
// TCPServer returns an instance of tcp server with specified name.
func TCPServer(name...interface{}) *gtcp.Server {
return gtcp.GetServer(name...)
}
// Get an instance of udp server with specified name.
//
// UDPServer单例对象
// UDPServer returns an instance of udp server with specified name.
func UDPServer(name...interface{}) *gudp.Server {
return gudp.GetServer(name...)
}
// Get an instance of template engine object with specified name.
//
// 核心对象：View
// View returns an instance of template engine object with specified name.
func View(name...string) *gview.View {
return gins.View(name...)
}
// Get an instance of config object with specified default config file name.
//
// Config配置管理对象,
// 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
// Config returns an instance of config object with specified name.
func Config(file...string) *gcfg.Config {
return gins.Config(file...)
}
// Get an instance of database ORM object with specified configuration group name.
//
// 数据库操作对象，使用了连接池
// Database returns an instance of database ORM object with specified configuration group name.
func Database(name...string) gdb.DB {
return gins.Database(name...)
}
// Alias of Database.
//
// (别名)Database
// Alias of Database. See Database.
func DB(name...string) gdb.DB {
return gins.Database(name...)
}
// Get an instance of redis client with specified configuration group name.
//
// Redis操作对象，使用了连接池
// Redis returns an instance of redis client with specified configuration group name.
func Redis(name...string) *gredis.Redis {
return gins.Redis(name...)
}

5
g/g_setting.go
View File

@ -8,9 +8,8 @@ package g
import "github.com/gogf/gf/g/net/ghttp"
// SetServerGraceful enables/disables graceful reload feature of ghttp Web Server.
//
// 是否开启WebServer的平滑重启特性。
// SetServerGraceful enables/disables graceful/hot reload feature of http Web Server.
// This feature is disabled in default.
func SetServerGraceful(enabled bool) {
ghttp.SetGraceful(enabled)
}

1
g/net/net.go
View File

@ -1 +0,0 @@
package net

62
g/os/gcfg/gcfg.go
View File

@ -100,12 +100,13 @@ func (c *Config) filePath(file...string) (path string) {
return path
}
// 设置配置管理器的配置文件存放目录绝对路径
// SetPath sets the configuration directory path for file search.
// The param <path> can be absolute or relative path, but absolute path is suggested.
func (c *Config) SetPath(path string) error {
// 判断绝对路径(或者工作目录下目录)
// Absolute path.
realPath := gfile.RealPath(path)
if realPath == "" {
// 判断相对路径
// Relative path.
c.paths.RLockFunc(func(array []string) {
for _, v := range array {
if path, _ := gspath.Search(v, path); path != "" {
@ -115,7 +116,7 @@ func (c *Config) SetPath(path string) error {
}
})
}
// 目录不存在错误处理
// Path not exist.
if realPath == "" {
buffer := bytes.NewBuffer(nil)
if c.paths.Len() > 0 {
@ -132,13 +133,13 @@ func (c *Config) SetPath(path string) error {
glog.Error(err)
return err
}
// 路径必须为目录类型
// Should be a directory.
if !gfile.IsDir(realPath) {
err := errors.New(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" should be directory type`, path))
glog.Error(err)
return err
}
// 重复判断
// Repeated path check.
if c.paths.Search(realPath) != -1 {
return nil
}
@ -149,19 +150,23 @@ func (c *Config) SetPath(path string) error {
return nil
}
// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
// SetViolenceCheck sets whether to perform level conflict check.
// This feature needs to be enabled when there is a level symbol in the key name.
// The default is off.
// Turning on this feature is quite expensive,
// and it is not recommended to allow separators in the key names.
// It is best to avoid this on the application side.
func (c *Config) SetViolenceCheck(check bool) {
c.vc.Set(check)
c.Clear()
}
// 添加配置管理器的配置文件搜索路径
// AddPath adds a absolute or relative path to the search paths.
func (c *Config) AddPath(path string) error {
// 判断绝对路径(或者工作目录下目录)
// Absolute path.
realPath := gfile.RealPath(path)
if realPath == "" {
// 判断相对路径
// Relative path.
c.paths.RLockFunc(func(array []string) {
for _, v := range array {
if path, _ := gspath.Search(v, path); path != "" {
@ -171,7 +176,6 @@ func (c *Config) AddPath(path string) error {
}
})
}
// 目录不存在错误处理
if realPath == "" {
buffer := bytes.NewBuffer(nil)
if c.paths.Len() > 0 {
@ -188,13 +192,12 @@ func (c *Config) AddPath(path string) error {
glog.Error(err)
return err
}
// 路径必须为目录类型
if !gfile.IsDir(realPath) {
err := errors.New(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" should be directory type`, path))
glog.Error(err)
return err
}
// 重复判断
// Repeated path check.
if c.paths.Search(realPath) != -1 {
return nil
}
@ -203,8 +206,10 @@ func (c *Config) AddPath(path string) error {
return nil
}
// 查找配置文件，获取指定配置文件的绝对路径，默认获取默认的配置文件路径；
// 当指定的配置文件不存在时，返回空字符串，并且不会报错。
// GetFilePath returns the absolute path of the specified configuration file.
// If <file> is not passed, it returns the configuration file path of the default name.
// If the specified configuration file does not exist,
// an empty string is returned.
func (c *Config) GetFilePath(file...string) (path string) {
name := c.name.Val()
if len(file) > 0 {
@ -225,19 +230,20 @@ func (c *Config) GetFilePath(file...string) (path string) {
return
}
// 设置配置管理对象的默认文件名称
// SetFileName sets the default configuration file name.
func (c *Config) SetFileName(name string) {
//glog.Debug("[gcfg] SetFileName:", name)
c.name.Set(name)
}
// 获取配置管理对象的默认文件名称
// GetFileName returns the default configuration file name.
func (c *Config) GetFileName() string {
return c.name.Val()
}
// 添加配置文件到配置管理器中，第二个参数为非必须，如果不输入表示添加进入默认的配置名称中
// 内部带缓存控制功能。
// getJson returns a gjson.Json object for the specified <file> content.
// It would print error if file reading fails.
// If any error occurs, it return nil.
func (c *Config) getJson(file...string) *gjson.Json {
name := c.name.Val()
if len(file) > 0 {
@ -255,7 +261,8 @@ func (c *Config) getJson(file...string) *gjson.Json {
}
if j, err := gjson.LoadContent(content); err == nil {
j.SetViolenceCheck(c.vc.Val())
// 添加配置文件监听，如果有任何变化，删除文件内容缓存，下一次查询会自动更新
// Add monitor for this configuration file,
// any changes of this file will refresh its cache in Config object.
if filePath != "" {
gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
c.jsons.Remove(name)
@ -277,7 +284,6 @@ func (c *Config) getJson(file...string) *gjson.Json {
return nil
}
// 获取配置项，当不存在时返回nil
func (c *Config) Get(pattern string, file...string) interface{} {
if j := c.getJson(file...); j != nil {
return j.Get(pattern)
@ -285,7 +291,6 @@ func (c *Config) Get(pattern string, file...string) interface{} {
return nil
}
// 获得配置项，返回动态变量
func (c *Config) GetVar(pattern string, file...string) gvar.VarRead {
if j := c.getJson(file...); j != nil {
return gvar.New(j.Get(pattern), true)
@ -293,7 +298,6 @@ func (c *Config) GetVar(pattern string, file...string) gvar.VarRead {
return gvar.New(nil, true)
}
// 判断指定的配置项是否存在
func (c *Config) Contains(pattern string, file...string) bool {
if j := c.getJson(file...); j != nil {
return j.Contains(pattern)
@ -301,8 +305,6 @@ func (c *Config) Contains(pattern string, file...string) bool {
return false
}
// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
func (c *Config) GetMap(pattern string, file...string) map[string]interface{} {
if j := c.getJson(file...); j != nil {
return j.GetMap(pattern)
@ -310,8 +312,6 @@ func (c *Config) GetMap(pattern string, file...string) map[string]interface{} {
return nil
}
// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换
// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
func (c *Config) GetArray(pattern string, file...string) []interface{} {
if j := c.getJson(file...); j != nil {
return j.GetArray(pattern)
@ -319,7 +319,6 @@ func (c *Config) GetArray(pattern string, file...string) []interface{} {
return nil
}
// 返回指定json中的string
func (c *Config) GetString(pattern string, file...string) string {
if j := c.getJson(file...); j != nil {
return j.GetString(pattern)
@ -341,7 +340,6 @@ func (c *Config) GetInterfaces(pattern string, file...string) []interface{} {
return nil
}
// 返回指定json中的bool
func (c *Config) GetBool(pattern string, file...string) bool {
if j := c.getJson(file...); j != nil {
return j.GetBool(pattern)
@ -349,7 +347,6 @@ func (c *Config) GetBool(pattern string, file...string) bool {
return false
}
// 返回指定json中的float32
func (c *Config) GetFloat32(pattern string, file...string) float32 {
if j := c.getJson(file...); j != nil {
return j.GetFloat32(pattern)
@ -357,7 +354,6 @@ func (c *Config) GetFloat32(pattern string, file...string) float32 {
return 0
}
// 返回指定json中的float64
func (c *Config) GetFloat64(pattern string, file...string) float64 {
if j := c.getJson(file...); j != nil {
return j.GetFloat64(pattern)
@ -372,7 +368,6 @@ func (c *Config) GetFloats(pattern string, file...string) []float64 {
return nil
}
// 返回指定json中的float64->int
func (c *Config) GetInt(pattern string, file...string) int {
if j := c.getJson(file...); j != nil {
return j.GetInt(pattern)
@ -416,7 +411,6 @@ func (c *Config) GetInts(pattern string, file...string) []int {
return nil
}
// 返回指定json中的float64->uint
func (c *Config) GetUint(pattern string, file...string) uint {
if j := c.getJson(file...); j != nil {
return j.GetUint(pattern)

8
g/os/gtime/gtime.go
View File

@ -147,11 +147,7 @@ func parseDateStr(s string) (year, month, day int) {
return
}
year, _ = strconv.Atoi(array[2])
day, _ = strconv.Atoi(array[1])
}
// 年是否为缩写，如果是，那么需要补上前缀
if year < 100 {
year = int(time.Now().Year()/100)*100 + year
day, _ = strconv.Atoi(array[0])
}
return
}
@ -308,7 +304,7 @@ func FuncCost(f func()) int64 {
return Nanosecond() - t
}
// 判断锁给字符串是否为数字
// 判断所给字符串是否为数字
func isNumeric(s string) bool {
length := len(s)
if length == 0 {

7
g/os/gtime/gtime_format.go
View File

@ -9,7 +9,8 @@ package gtime
import (
"bytes"
"github.com/gogf/gf/g/text/gregex"
"strings"
"github.com/gogf/gf/g/text/gstr"
"strings"
)
var (
@ -126,8 +127,8 @@ func (t *Time) Format(format string) string {
result := t.Time.Format(f)
// 有几个转换的符号需要特殊处理
switch runes[i] {
case 'j': buffer.WriteString(strings.Replace(result, "=j=0", "", -1))
case 'G': buffer.WriteString(strings.Replace(result, "=G=0", "", -1))
case 'j': buffer.WriteString(gstr.ReplaceByArray(result, []string{"=j=0", "", "=j=", ""}))
case 'G': buffer.WriteString(gstr.ReplaceByArray(result, []string{"=G=0", "", "=G=", ""}))
case 'u': buffer.WriteString(strings.Replace(result, "=u=.", "", -1))
default:
buffer.WriteString(result)

68
g/os/gtime/gtime_z_bench_test.go
View File

@ -4,50 +4,70 @@
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gtime
package gtime_test
import (
"testing"
"testing"
"github.com/gogf/gf/g/os/gtime"
)
func Benchmark_Second(b *testing.B) {
for i := 0; i < b.N; i++ {
Second()
}
for i := 0; i < b.N; i++ {
gtime.Second()
}
}
func Benchmark_Millisecond(b *testing.B) {
for i := 0; i < b.N; i++ {
Millisecond()
}
for i := 0; i < b.N; i++ {
gtime.Millisecond()
}
}
func Benchmark_Microsecond(b *testing.B) {
for i := 0; i < b.N; i++ {
Microsecond()
}
for i := 0; i < b.N; i++ {
gtime.Microsecond()
}
}
func Benchmark_Nanosecond(b *testing.B) {
for i := 0; i < b.N; i++ {
Nanosecond()
}
for i := 0; i < b.N; i++ {
gtime.Nanosecond()
}
}
func Benchmark_StrToTime(b *testing.B) {
for i := 0; i < b.N; i++ {
StrToTime("2018-02-09T20:46:17.897Z")
}
for i := 0; i < b.N; i++ {
gtime.StrToTime("2018-02-09T20:46:17.897Z")
}
}
func Benchmark_ParseTimeFromContent(b *testing.B) {
for i := 0; i < b.N; i++ {
ParseTimeFromContent("2018-02-09T20:46:17.897Z")
}
for i := 0; i < b.N; i++ {
gtime.ParseTimeFromContent("2018-02-09T20:46:17.897Z")
}
}
func Benchmark_NewFromTimeStamp(b *testing.B) {
for i := 0; i < b.N; i++ {
NewFromTimeStamp(1542674930)
}
}
for i := 0; i < b.N; i++ {
gtime.NewFromTimeStamp(1542674930)
}
}
func Benchmark_Date(b *testing.B) {
for i := 0; i < b.N; i++ {
gtime.Date()
}
}
func Benchmark_Datetime(b *testing.B) {
for i := 0; i < b.N; i++ {
gtime.Datetime()
}
}
func Benchmark_SetTimeZone(b *testing.B) {
for i := 0; i < b.N; i++ {
gtime.SetTimeZone("Asia/Shanghai")
}
}

234
g/os/gtime/gtime_z_unit_basic_test.go Normal file
View File

@ -0,0 +1,234 @@
package gtime_test
import (
"testing"
"time"
"github.com/gogf/gf/g/os/gtime"
"github.com/gogf/gf/g/test/gtest"
)
func Test_SetTimeZone(t *testing.T) {
gtest.Case(t, func() {
gtime.SetTimeZone("Asia/Shanghai")
gtest.Assert(time.Local.String(), "Asia/Shanghai")
})
}
func Test_Nanosecond(t *testing.T) {
gtest.Case(t, func() {
nanos := gtime.Nanosecond()
timeTemp := time.Unix(0, nanos)
gtest.Assert(nanos, timeTemp.UnixNano())
})
}
func Test_Microsecond(t *testing.T) {
gtest.Case(t, func() {
micros := gtime.Microsecond()
timeTemp := time.Unix(0, micros*1e3)
gtest.Assert(micros, timeTemp.UnixNano()/1e3)
})
}
func Test_Millisecond(t *testing.T) {
gtest.Case(t, func() {
millis := gtime.Millisecond()
timeTemp := time.Unix(0, millis*1e6)
gtest.Assert(millis, timeTemp.UnixNano()/1e6)
})
}
func Test_Second(t *testing.T) {
gtest.Case(t, func() {
s := gtime.Second()
timeTemp := time.Unix(s, 0)
gtest.Assert(s, timeTemp.Unix())
})
}
func Test_Date(t *testing.T) {
gtest.Case(t, func() {
gtest.Assert(gtime.Date(), time.Now().Format("2006-01-02"))
})
}
func Test_Datetime(t *testing.T) {
gtest.Case(t, func() {
datetime := gtime.Datetime()
timeTemp, err := gtime.StrToTime(datetime, "Y-m-d H:i:s")
if err != nil {
t.Error("test fail")
}
gtest.Assert(datetime, timeTemp.Time.Format("2006-01-02 15:04:05"))
})
}
func Test_StrToTime(t *testing.T) {
gtest.Case(t, func() {
//正常日期列表
//正则的原因，日期"06.01.02"，"2006.01"，"2006..01"无法覆盖gtime.go的百分百
var testDatetimes = []string{
"2006-01-02 15:04:05",
"2006/01/02 15:04:05",
"2006.01.02 15:04:05.000",
"2006.01.02 - 15:04:05",
"2006.01.02 15:04:05 +0800 CST",
"2006-01-02T20:05:06+05:01:01",
"2006-01-02T14:03:04Z01:01:01",
"2006-01-02T15:04:05Z",
"02-jan-2006 15:04:05",
"02/jan/2006 15:04:05",
"02.jan.2006 15:04:05",
"02.jan.2006:15:04:05",
}
for _, item := range testDatetimes {
timeTemp, err := gtime.StrToTime(item)
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
}
//正常日期列表，时间00:00:00
var testDates = []string{
"2006.01.02",
"2006.01.02 00:00",
"2006.01.02 00:00:00.000",
}
for _, item := range testDates {
timeTemp, err := gtime.StrToTime(item)
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 00:00:00")
}
//测试格式化formatToStdLayout
var testDateFormats = []string{
"Y-m-d H:i:s",
"\\T\\i\\m\\e Y-m-d H:i:s",
"Y-m-d H:i:s\\",
"Y-m-j G:i:s.u",
"Y-m-j G:i:su",
}
var testDateFormatsResult = []string{
"2007-01-02 15:04:05",
"Time 2007-01-02 15:04:05",
"2007-01-02 15:04:05",
"2007-01-02 15:04:05.000",
"2007-01-02 15:04:05.000",
}
for index, item := range testDateFormats {
timeTemp, err := gtime.StrToTime(testDateFormatsResult[index], item)
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05.000"), "2007-01-02 15:04:05.000")
}
//异常日期列表
var testDatesFail = []string{
"2006.01",
"06..02",
"20060102",
}
for _, item := range testDatesFail {
_, err := gtime.StrToTime(item)
if err == nil {
t.Error("test fail")
}
}
//test err
_, err := gtime.StrToTime("2006-01-02 15:04:05", "aabbccdd")
if err == nil {
t.Error("test fail")
}
})
}
func Test_ConvertZone(t *testing.T) {
gtest.Case(t, func() {
//现行时间
nowUTC := time.Now().UTC()
testZone := "America/Los_Angeles"
//转换为洛杉矶时间
t1, err := gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
if err != nil {
t.Error("test fail")
}
//使用洛杉矶时区解析上面转换后的时间
laStr := t1.Time.Format("2006-01-02 15:04:05")
loc, err := time.LoadLocation(testZone)
t2, err := time.ParseInLocation("2006-01-02 15:04:05", laStr, loc)
//判断是否与现行时间匹配
gtest.Assert(t2.UTC().Unix(), nowUTC.Unix())
})
//test err
gtest.Case(t, func() {
//现行时间
nowUTC := time.Now().UTC()
//t.Log(nowUTC.Unix())
testZone := "errZone"
//错误时间输入
_, err := gtime.ConvertZone(nowUTC.Format("06..02 15:04:05"), testZone, "")
if err == nil {
t.Error("test fail")
}
//错误时区输入
_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
if err == nil {
t.Error("test fail")
}
//错误时区输入
_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, testZone)
if err == nil {
t.Error("test fail")
}
})
}
func Test_StrToTimeFormat(t *testing.T) {
gtest.Case(t, func() {
})
}
func Test_ParseTimeFromContent(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文", "Y-m-d H:i:s")
gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
timeTemp1 := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文")
gtest.Assert(timeTemp1.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
timeTemp2 := gtime.ParseTimeFromContent("我是中文02.jan.2006 15:04:05我也是中文")
gtest.Assert(timeTemp2.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
//test err
timeTempErr := gtime.ParseTimeFromContent("我是中文", "Y-m-d H:i:s")
if timeTempErr != nil {
t.Error("test fail")
}
})
}
func Test_FuncCost(t *testing.T) {
gtest.Case(t, func() {
gtime.FuncCost(func() {
})
})
}

54
g/os/gtime/gtime_z_unit_format_test.go Normal file
View File

@ -0,0 +1,54 @@
package gtime_test
import (
"testing"
"github.com/gogf/gf/g/os/gtime"
"github.com/gogf/gf/g/test/gtest"
)
func Test_Format(t *testing.T) {
gtest.Case(t, func() {
timeTemp, err := gtime.StrToTime("2006-01-11 15:04:05", "Y-m-d H:i:s")
timeTemp.ToZone("Asia/Shanghai")
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp.Format("\\T\\i\\m\\e中文Y-m-j G:i:s.u\\"), "Time中文2006-01-11 15:04:05.000")
gtest.Assert(timeTemp.Format("d D j l"), "11 Wed 11 Wednesday")
gtest.Assert(timeTemp.Format("F m M n"), "January 01 Jan 1")
gtest.Assert(timeTemp.Format("Y y"), "2006 06")
gtest.Assert(timeTemp.Format("a A g G h H i s u .u"), "pm PM 3 15 03 15 04 05 000 .000")
gtest.Assert(timeTemp.Format("O P T"), "+0800 +08:00 CST")
gtest.Assert(timeTemp.Format("r"), "Wed, 11 Jan 06 15:04 CST")
gtest.Assert(timeTemp.Format("c"), "2006-01-11T15:04:05+08:00")
//补零
timeTemp1, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp1.Format("Y-m-d h:i:s"), "2006-01-02 03:04:05")
//不补零
timeTemp2, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
if err != nil {
t.Error("test fail")
}
gtest.Assert(timeTemp2.Format("Y-n-j G:i:s"), "2006-1-2 3:04:05")
})
}
func Test_Layout(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.Layout("2006-01-02 15:04:05"), timeTemp.Time.Format("2006-01-02 15:04:05"))
})
}

189
g/os/gtime/gtime_z_unit_time_test.go Normal file
View File

@ -0,0 +1,189 @@
package gtime_test
import (
"testing"
"time"
"github.com/gogf/gf/g/os/gtime"
"github.com/gogf/gf/g/test/gtest"
)
func Test_New(t *testing.T) {
gtest.Case(t, func() {
timeNow := time.Now()
timeTemp := gtime.New(timeNow)
gtest.Assert(timeTemp.Time.UnixNano(), timeNow.UnixNano())
timeTemp1 := gtime.New()
gtest.Assert(timeTemp1.Time, time.Time{})
})
}
func Test_NewFromStr(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStr("20060102")
if timeTemp1 != nil {
t.Error("test fail")
}
})
}
func Test_NewFromStrFormat(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromStrFormat("2006-01-02 15:04:05", "Y-m-d H:i:s")
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStrFormat("2006-01-02 15:04:05", "aabbcc")
if timeTemp1 != nil {
t.Error("test fail")
}
})
}
func Test_NewFromStrLayout(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromStrLayout("2006-01-02 15:04:05", "2006-01-02 15:04:05")
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
timeTemp1 := gtime.NewFromStrLayout("2006-01-02 15:04:05", "aabbcc")
if timeTemp1 != nil {
t.Error("test fail")
}
})
}
func Test_NewFromTimeStamp(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromTimeStamp(1554459846000)
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2019-04-05 18:24:06")
timeTemp1 := gtime.NewFromTimeStamp(0)
gtest.Assert(timeTemp1.Format("Y-m-d H:i:s"), "0001-01-01 00:00:00")
})
}
func Test_tSecond(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.Second(), timeTemp.Time.Unix())
})
}
func Test_tNanosecond(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.Nanosecond(), timeTemp.Time.UnixNano())
})
}
func Test_tMicrosecond(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.Microsecond(), timeTemp.Time.UnixNano()/1e3)
})
}
func Test_tMillisecond(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.Millisecond(), timeTemp.Time.UnixNano()/1e6)
})
}
func Test_String(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
gtest.Assert(timeTemp.String(), timeTemp.Time.Format("2006-01-02 15:04:05"))
})
}
func Test_Clone(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Clone()
gtest.Assert(timeTemp.Time.Unix(), timeTemp1.Time.Unix())
})
}
func Test_ToTime(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Time
gtest.Assert(timeTemp.ToTime().UnixNano(), timeTemp1.UnixNano())
})
}
func Test_Add(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
timeTemp.Add(time.Second)
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:06")
})
}
func Test_ToZone(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
//
timeTemp.ToZone("America/Los_Angeles")
gtest.Assert(timeTemp.Time.Location().String(), "America/Los_Angeles")
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
t.Error("test fail")
}
timeTemp.ToLocation(loc)
gtest.Assert(timeTemp.Time.Location().String(), "Asia/Shanghai")
timeTemp1 := timeTemp.ToZone("errZone")
if timeTemp1 != nil {
t.Error("test fail")
}
})
}
func Test_AddDate(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
timeTemp.AddDate(1, 2, 3)
gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2007-03-05 15:04:05")
})
}
func Test_UTC(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Time
timeTemp.UTC()
gtest.Assert(timeTemp.UnixNano(), timeTemp1.UTC().UnixNano())
})
}
func Test_Local(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Time
timeTemp.Local()
gtest.Assert(timeTemp.UnixNano(), timeTemp1.Local().UnixNano())
})
}
func Test_Round(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Time
timeTemp.Round(time.Hour)
gtest.Assert(timeTemp.UnixNano(), timeTemp1.Round(time.Hour).UnixNano())
})
}
func Test_Truncate(t *testing.T) {
gtest.Case(t, func() {
timeTemp := gtime.Now()
timeTemp1 := timeTemp.Time
timeTemp.Truncate(time.Hour)
gtest.Assert(timeTemp.UnixNano(), timeTemp1.Truncate(time.Hour).UnixNano())
})
}

1
g/os/os.go
View File

@ -1 +0,0 @@
package os

120
g/test/gtest/gtest.go
View File

@ -4,9 +4,7 @@
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
// Package gtest provides simple and useful test utils.
//
// 测试模块.
// Package gtest provides convenient test utils for unit testing.
package gtest
import (
@ -19,7 +17,9 @@ import (
"testing"
)
// 封装一个测试用例
// Case creates an unit test case.
// The param <t> is the pointer to testing.T of stdlib (*testing.T).
// The param <f> is the callback function for unit test case.
func Case(t *testing.T, f func()) {
defer func() {
if err := recover(); err != nil {
@ -30,14 +30,11 @@ func Case(t *testing.T, f func()) {
f()
}
// 断言判断, 相等
// Assert checks <value> and <expect> EQUAL.
func Assert(value, expect interface{}) {
rvValue := reflect.ValueOf(value)
rvExpect := reflect.ValueOf(expect)
if rvValue.Kind() == reflect.Ptr {
if rvValue.IsNil() {
value = nil
}
if isNil(value) {
value = nil
}
if rvExpect.Kind() == reflect.Map {
if err := compareMap(value, expect); err != nil {
@ -50,21 +47,13 @@ func Assert(value, expect interface{}) {
}
}
// 断言判断, 相等, 包括数据类型
// AssertEQ checks <value> and <expect> EQUAL, including their TYPES.
func AssertEQ(value, expect interface{}) {
// 类型判断
t1 := reflect.TypeOf(value)
t2 := reflect.TypeOf(expect)
if t1 != t2 {
panic(fmt.Sprintf(`[ASSERT] EXPECT TYPE %v == %v`, t1, t2))
}
rvValue := reflect.ValueOf(value)
// Value assert.
rvExpect := reflect.ValueOf(expect)
if rvValue.Kind() == reflect.Ptr {
if rvValue.IsNil() {
value = nil
}
}
if isNil(value) {
value = nil
}
if rvExpect.Kind() == reflect.Map {
if err := compareMap(value, expect); err != nil {
panic(err)
@ -74,17 +63,20 @@ func AssertEQ(value, expect interface{}) {
if fmt.Sprintf("%v", value) != fmt.Sprintf("%v", expect) {
panic(fmt.Sprintf(`[ASSERT] EXPECT %v == %v`, value, expect))
}
// Type assert.
t1 := reflect.TypeOf(value)
t2 := reflect.TypeOf(expect)
if t1 != t2 {
panic(fmt.Sprintf(`[ASSERT] EXPECT TYPE %v[%v] == %v[%v]`, value, t1, expect, t2))
}
}
// 断言判断, 不相等
// AssertNE checks <value> and <expect> NOT EQUAL.
func AssertNE(value, expect interface{}) {
rvValue := reflect.ValueOf(value)
rvExpect := reflect.ValueOf(expect)
if rvValue.Kind() == reflect.Ptr {
if rvValue.IsNil() {
value = nil
}
}
if isNil(value) {
value = nil
}
if rvExpect.Kind() == reflect.Map {
if err := compareMap(value, expect); err == nil {
panic(fmt.Sprintf(`[ASSERT] EXPECT %v != %v`, value, expect))
@ -96,7 +88,9 @@ func AssertNE(value, expect interface{}) {
}
}
// 断言判断, value > expect; 注意: 仅有字符串、整形、浮点型才可以比较
// AssertGT checks <value> is GREATER THAN <expect>.
// Notice that, only string, integer and float types can be compared by AssertGT,
// others are invalid.
func AssertGT(value, expect interface{}) {
passed := false
switch reflect.ValueOf(expect).Kind() {
@ -117,7 +111,9 @@ func AssertGT(value, expect interface{}) {
}
}
// 断言判断, value >= expect; 注意: 仅有字符串、整形、浮点型才可以比较
// AssertGTE checks <value> is GREATER OR EQUAL THAN <expect>.
// Notice that, only string, integer and float types can be compared by AssertGTE,
// others are invalid.
func AssertGTE(value, expect interface{}) {
passed := false
switch reflect.ValueOf(expect).Kind() {
@ -138,7 +134,9 @@ func AssertGTE(value, expect interface{}) {
}
}
// 断言判断, value < expect; 注意: 仅有字符串、整形、浮点型才可以比较
// AssertLT checks <value> is LESS EQUAL THAN <expect>.
// Notice that, only string, integer and float types can be compared by AssertLT,
// others are invalid.
func AssertLT(value, expect interface{}) {
passed := false
switch reflect.ValueOf(expect).Kind() {
@ -159,7 +157,9 @@ func AssertLT(value, expect interface{}) {
}
}
// 断言判断, value <= expect; 注意: 仅有字符串、整形、浮点型才可以比较
// AssertLTE checks <value> is LESS OR EQUAL THAN <expect>.
// Notice that, only string, integer and float types can be compared by AssertLTE,
// others are invalid.
func AssertLTE(value, expect interface{}) {
passed := false
switch reflect.ValueOf(expect).Kind() {
@ -180,16 +180,18 @@ func AssertLTE(value, expect interface{}) {
}
}
// 断言判断, value IN expect; 注意: expect必须为slice类型。
// 注意：value参数可以为普通变量，也可以为slice类型。
// AssertIN checks <value> is IN <expect>.
// The <expect> should be a slice,
// but the <value> can be a slice or a basic type variable.
// TODO map support.
func AssertIN(value, expect interface{}) {
passed := true
switch reflect.ValueOf(expect).Kind() {
case reflect.Slice, reflect.Array:
expectSlice := gconv.Interfaces(expect)
for _, v1 := range gconv.Interfaces(value) {
result := false
for _, v2 := range gconv.Interfaces(expect) {
for _, v2 := range expectSlice {
if v1 == v2 {
result = true
break
@ -206,7 +208,10 @@ func AssertIN(value, expect interface{}) {
}
}
// 断言判断, value NOT IN expect; 注意: expect必须为slice类型
// AssertNI checks <value> is NOT IN <expect>.
// The <expect> should be a slice,
// but the <value> can be a slice or a basic type variable.
// TODO map support.
func AssertNI(value, expect interface{}) {
passed := true
switch reflect.ValueOf(expect).Kind() {
@ -230,31 +235,30 @@ func AssertNI(value, expect interface{}) {
}
}
// 提示错误不退出进程执行
// Error panics with given <message>.
func Error(message...interface{}) {
panic(fmt.Sprintf("[ERROR] %s", fmt.Sprint(message...)))
}
// 提示错误并退出进程执行
// Fatal prints <message> to stderr and exit the process.
func Fatal(message...interface{}) {
fmt.Fprintf(os.Stderr, "[FATAL] %s\n%s", fmt.Sprint(message...), getBacktrace())
os.Exit(1)
}
// Map比较，如果相等返回nil，否则返回错误信息.
// compareMap compares two maps, returns nil if they are equal, or else returns error.
func compareMap(value, expect interface{}) error {
rvValue := reflect.ValueOf(value)
rvExpect := reflect.ValueOf(expect)
if rvValue.Kind() == reflect.Ptr {
if rvValue.IsNil() {
value = nil
}
}
if isNil(value) {
value = nil
}
if rvExpect.Kind() == reflect.Map {
if rvValue.Kind() == reflect.Map {
if rvExpect.Len() == rvValue.Len() {
// 将两个map类型转换为同一个map类型, 才能执行比较,
// 直接使用 rvValue.MapIndex(key).Interface() 当key类型不一致时会报错。
// Turn two interface maps to the same type for comparison.
// Direct use of rvValue.MapIndex(key).Interface() will panic
// when the key types are inconsistent.
mValue := make(map[string]string)
mExpect := make(map[string]string)
ksValue := rvValue.MapKeys()
@ -280,7 +284,8 @@ func compareMap(value, expect interface{}) error {
return nil
}
// 获取文件调用回溯字符串，参数skip表示调用端往上多少级开始回溯
// getBacktrace returns the caller backtrace content from getBacktrace.
// The param <skip> indicates the skip count of the caller backtrace from getBacktrace.
func getBacktrace(skip...int) string {
customSkip := 0
if len(skip) > 0 {
@ -289,7 +294,7 @@ func getBacktrace(skip...int) string {
backtrace := ""
index := 1
from := 0
// 首先定位业务文件开始位置
// Ignore current gtest lines and find the beginning index of caller file.
for i := 0; i < 10; i++ {
if _, file, _, ok := runtime.Caller(i); ok {
if reg, _ := regexp.Compile(`gtest\.go$`); !reg.MatchString(file) {
@ -298,7 +303,7 @@ func getBacktrace(skip...int) string {
}
}
}
// 从业务文件开始位置根据自定义的skip开始backtrace
// Get the caller backtrace from business caller file.
goRoot := runtime.GOROOT()
for i := from + customSkip; i < 10000; i++ {
if _, file, cline, ok := runtime.Caller(i); ok && file != "" {
@ -320,4 +325,15 @@ func getBacktrace(skip...int) string {
}
}
return backtrace
}
// isNil checks whether <value> is nil.
func isNil(value interface{}) bool {
rv := reflect.ValueOf(value)
switch rv.Kind() {
case reflect.Slice, reflect.Array, reflect.Map, reflect.Ptr, reflect.Func:
return rv.IsNil()
default:
return value == nil
}
}

239
g/text/gregex/gregex_z_unit_test.go Normal file
View File

@ -0,0 +1,239 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
// go test *.go -bench=".*"
package gregex_test
import (
"github.com/gogf/gf/g/test/gtest"
"github.com/gogf/gf/g/text/gregex"
"strings"
"testing"
)
func Test_Quote(t *testing.T) {
gtest.Case(t, func() {
s1 := `[foo]` //`\[foo\]`
gtest.Assert(gregex.Quote(s1), `\[foo\]`)
})
}
func Test_Validate(t *testing.T) {
gtest.Case(t, func() {
var s1 = `(.+):(\d+)`
gtest.Assert(gregex.Validate(s1), nil)
s1 = `((.+):(\d+)`
gtest.Assert(gregex.Validate(s1) == nil, false)
})
}
func Test_IsMatch(t *testing.T) {
gtest.Case(t, func() {
var pattern = `(.+):(\d+)`
s1 := []byte(`sfs:2323`)
gtest.Assert(gregex.IsMatch(pattern, s1), true)
s1 = []byte(`sfs2323`)
gtest.Assert(gregex.IsMatch(pattern, s1), false)
s1 = []byte(`sfs:`)
gtest.Assert(gregex.IsMatch(pattern, s1), false)
})
}
func Test_IsMatchString(t *testing.T) {
gtest.Case(t, func() {
var pattern = `(.+):(\d+)`
s1 := `sfs:2323`
gtest.Assert(gregex.IsMatchString(pattern, s1), true)
s1 = `sfs2323`
gtest.Assert(gregex.IsMatchString(pattern, s1), false)
s1 = `sfs:`
gtest.Assert(gregex.IsMatchString(pattern, s1), false)
})
}
func Test_Match(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
s := "acbb" + wantSubs + "dd"
subs, err := gregex.Match(re, []byte(s))
gtest.Assert(err, nil)
if string(subs[0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs)
}
if string(subs[1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
}
})
}
func Test_MatchString(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
s := "acbb" + wantSubs + "dd"
subs, err := gregex.MatchString(re, s)
gtest.Assert(err, nil)
if string(subs[0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs)
}
if string(subs[1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
}
})
}
func Test_MatchAll(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
s := "acbb" + wantSubs + "dd"
s = s + `其他的` + s
subs, err := gregex.MatchAll(re, []byte(s))
gtest.Assert(err, nil)
if string(subs[0][0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs)
}
if string(subs[0][1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[0][1], "aab")
}
if string(subs[1][0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[1][0], wantSubs)
}
if string(subs[1][1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
}
})
}
func Test_MatchAllString(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
s := "acbb" + wantSubs + "dd"
subs, err := gregex.MatchAllString(re, s+`其他的`+s)
gtest.Assert(err, nil)
if string(subs[0][0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs)
}
if string(subs[0][1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[0][1], "aab")
}
if string(subs[1][0]) != wantSubs {
t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[1][0], wantSubs)
}
if string(subs[1][1]) != "aab" {
t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
}
})
}
func Test_Replace(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
replace := "12345"
s := "acbb" + wantSubs + "dd"
wanted := "acbb" + replace + "dd"
replacedStr, err := gregex.Replace(re, []byte(replace), []byte(s))
gtest.Assert(err, nil)
if string(replacedStr) != wanted {
t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
}
})
}
func Test_ReplaceString(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
replace := "12345"
s := "acbb" + wantSubs + "dd"
wanted := "acbb" + replace + "dd"
replacedStr, err := gregex.ReplaceString(re, replace, s)
gtest.Assert(err, nil)
if replacedStr != wanted {
t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
}
})
}
func Test_ReplaceFun(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
//replace :="12345"
s := "acbb" + wantSubs + "dd"
wanted := "acbb[x" + wantSubs + "y]dd"
wanted = "acbb" + "3个a" + "dd"
replacedStr, err := gregex.ReplaceFunc(re, []byte(s), func(s []byte) []byte {
if strings.Index(string(s), "aaa") >= 0 {
return []byte("3个a")
}
return []byte("[x" + string(s) + "y]")
})
gtest.Assert(err, nil)
if string(replacedStr) != wanted {
t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
}
})
}
func Test_ReplaceStringFunc(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
wantSubs := "aaabb"
//replace :="12345"
s := "acbb" + wantSubs + "dd"
wanted := "acbb[x" + wantSubs + "y]dd"
wanted = "acbb" + "3个a" + "dd"
replacedStr, err := gregex.ReplaceStringFunc(re, s, func(s string) string {
if strings.Index(s, "aaa") >= 0 {
return "3个a"
}
return "[x" + s + "y]"
})
gtest.Assert(err, nil)
if replacedStr != wanted {
t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
}
})
}
func Test_Split(t *testing.T) {
gtest.Case(t, func() {
re := "a(a+b+)b"
matched := "aaabb"
item0 := "acbb"
item1 := "dd"
s := item0 + matched + item1
gtest.Assert(gregex.IsMatchString(re, matched), true)
items := gregex.Split(re, s) //split string with matched
if items[0] != item0 {
t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
}
if items[1] != item1 {
t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
}
})
gtest.Case(t, func() {
re := "a(a+b+)b"
notmatched := "aaxbb"
item0 := "acbb"
item1 := "dd"
s := item0 + notmatched + item1
gtest.Assert(gregex.IsMatchString(re, notmatched), false)
items := gregex.Split(re, s) //split string with notmatched then nosplitting
if items[0] != s {
t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
}
})
}

185
g/text/gstr/gstr.go
View File

@ -5,8 +5,6 @@
// You can obtain one at https://github.com/gogf/gf.
// Package gstr provides functions for string handling.
//
// 字符串处理.
package gstr
import (
@ -20,9 +18,8 @@ import (
"unicode/utf8"
)
// Replace returns a copy of the string <origin> with string <search> replaced by <replace>.
//
// 字符串替换(大小写敏感)
// Replace returns a copy of the string <origin>
// in which string <search> replaced by <replace> case-sensitively.
func Replace(origin, search, replace string, count...int) string {
n := -1
if len(count) > 0 {
@ -31,10 +28,8 @@ func Replace(origin, search, replace string, count...int) string {
return strings.Replace(origin, search, replace, n)
}
// Replace returns a copy of the string <origin> with string <search> replaced by <replace>
// with case-insensitive.
//
// 字符串替换(大小写不敏感)
// Replace returns a copy of the string <origin>
// in which string <search> replaced by <replace> case-insensitively.
func ReplaceI(origin, search, replace string, count...int) string {
n := -1
if len(count) > 0 {
@ -59,23 +54,20 @@ func ReplaceI(origin, search, replace string, count...int) string {
return origin
}
// Count counts the number of <substr> appears in <s>. It returns 0 if no <substr> found in <s>.
//
// 计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
// Count counts the number of <substr> appears in <s>.
// It returns 0 if no <substr> found in <s>.
func Count(s, substr string) int {
return strings.Count(s, substr)
}
// Count counts the number of <substr> appears in <s>, case-insensitive. It returns 0 if no <substr> found in <s>.
//
// (非大小写敏感)计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
// Count counts the number of <substr> appears in <s>, case-insensitively.
// It returns 0 if no <substr> found in <s>.
func CountI(s, substr string) int {
return strings.Count(ToLower(s), ToLower(substr))
}
// Replace string by array/slice.
//
// 使用map进行字符串替换(大小写敏感)
// ReplaceByArray returns a copy of <origin>,
// which is replaced by a slice in order, case-sensitively.
func ReplaceByArray(origin string, array []string) string {
for i := 0; i < len(array); i += 2 {
if i + 1 >= len(array) {
@ -86,9 +78,8 @@ func ReplaceByArray(origin string, array []string) string {
return origin
}
// Replace string by array/slice with case-insensitive.
//
// 使用map进行字符串替换(大小写不敏感)
// ReplaceIByArray returns a copy of <origin>,
// which is replaced by a slice in order, case-insensitively.
func ReplaceIByArray(origin string, array []string) string {
for i := 0; i < len(array); i += 2 {
if i + 1 >= len(array) {
@ -99,9 +90,8 @@ func ReplaceIByArray(origin string, array []string) string {
return origin
}
// Replace string by map.
//
// 使用map进行字符串替换(大小写敏感)
// ReplaceByMap returns a copy of <origin>,
// which is replaced by a map in unordered way, case-sensitively.
func ReplaceByMap(origin string, replaces map[string]string) string {
for k, v := range replaces {
origin = Replace(origin, k, v)
@ -109,9 +99,8 @@ func ReplaceByMap(origin string, replaces map[string]string) string {
return origin
}
// Replace string by map with case-insensitive.
//
// 使用map进行字符串替换(大小写不敏感)
// ReplaceIByMap returns a copy of <origin>,
// which is replaced by a map in unordered way, case-insensitively.
func ReplaceIByMap(origin string, replaces map[string]string) string {
for k, v := range replaces {
origin = ReplaceI(origin, k, v)
@ -120,21 +109,16 @@ func ReplaceIByMap(origin string, replaces map[string]string) string {
}
// ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.
// 字符串转换为小写
func ToLower(s string) string {
return strings.ToLower(s)
}
// ToUpper returns a copy of the string s with all Unicode letters mapped to their upper case.
//
// 字符串转换为大写
func ToUpper(s string) string {
return strings.ToUpper(s)
}
// UcFirst returns a copy of the string s with the first letter mapped to its upper case.
//
// 字符串首字母转换为大写
func UcFirst(s string) string {
if len(s) == 0 {
return s
@ -146,8 +130,6 @@ func UcFirst(s string) string {
}
// LcFirst returns a copy of the string s with the first letter mapped to its lower case.
//
// 字符串首字母转换为小写
func LcFirst(s string) string {
if len(s) == 0 {
return s
@ -158,16 +140,12 @@ func LcFirst(s string) string {
return s
}
// Uppercase the first character of each word in a string.
//
// 大写字符串中每个单词的第一个字符。
// UcWords uppercase the first character of each word in a string.
func UcWords(str string) string {
return strings.Title(str)
}
// IsLetterLower tests whether the given byte b is in lower case.
//
// 判断给定字符是否小写
func IsLetterLower(b byte) bool {
if b >= byte('a') && b <= byte('z') {
return true
@ -176,8 +154,6 @@ func IsLetterLower(b byte) bool {
}
// IsLetterUpper tests whether the given byte b is in upper case.
//
// 判断给定字符是否大写
func IsLetterUpper(b byte) bool {
if b >= byte('A') && b <= byte('Z') {
return true
@ -186,8 +162,6 @@ func IsLetterUpper(b byte) bool {
}
// IsNumeric tests whether the given string s is numeric.
//
// 判断锁给字符串是否为数字.
func IsNumeric(s string) bool {
length := len(s)
if length == 0 {
@ -201,9 +175,7 @@ func IsNumeric(s string) bool {
return true
}
// Returns the portion of string specified by the start and length parameters.
//
// 字符串截取，支持中文
// SubStr returns a portion of string <str> specified by the <start> and <length> parameters.
func SubStr(str string, start int, length...int) (substr string) {
// 将字符串的转换成[]rune
rs := []rune(str)
@ -229,12 +201,10 @@ func SubStr(str string, start int, length...int) (substr string) {
return string(rs[start : end])
}
// Returns the portion of string specified by the <length> parameters,
// if the length of str is greater than <length>,
// then the <suffix> will be appended to the result.
//
// 字符串长度截取限制，超过长度限制被截取并在字符串末尾追加指定的内容，支持中文
func StrLimit(str string, length int, suffix...string) (string) {
// StrLimit returns a portion of string <str> specified by <length> parameters,
// if the length of <str> is greater than <length>,
// then the <suffix> will be appended to the result string.
func StrLimit(str string, length int, suffix...string) string {
rs := []rune(str)
if len(str) < length {
return str
@ -246,9 +216,7 @@ func StrLimit(str string, length int, suffix...string) (string) {
return string(rs[0 : length]) + addStr
}
// Reverse a string.
//
// 字符串反转.
// Reverse returns a string which is the reverse of <str>.
func Reverse(str string) string {
runes := []rune(str)
for i, j := 0, len(runes) - 1; i < j; i, j = i + 1, j - 1 {
@ -257,13 +225,11 @@ func Reverse(str string) string {
return string(runes)
}
// Format a number with grouped thousands.
// decimals: Sets the number of decimal points.
// decPoint: Sets the separator for the decimal point.
// thousandsSep: Sets the thousands separator.
// NumberFormat formats a number with grouped thousands.
// <decimals>: Sets the number of decimal points.
// <decPoint>: Sets the separator for the decimal point.
// <thousandsSep>: Sets the thousands separator.
// See http://php.net/manual/en/function.number-format.php.
//
// 以千位分隔符方式格式化一个数字.
func NumberFormat(number float64, decimals int, decPoint, thousandsSep string) string {
neg := false
if number < 0 {
@ -305,14 +271,10 @@ func NumberFormat(number float64, decimals int, decPoint, thousandsSep string) s
return s
}
// Split a string into smaller chunks.
// ChunkSplit splits a string into smaller chunks.
// Can be used to split a string into smaller chunks which is useful for
// e.g. converting BASE64 string output to match RFC 2045 semantics.
// It inserts end every chunkLen characters.
//
// 将字符串分割成小块。使用此函数将字符串分割成小块非常有用。
// 例如将BASE64的输出转换成符合RFC2045语义的字符串。
// 它会在每 chunkLen 个字符后边插入 end。
func ChunkSplit(body string, chunkLen int, end string) string {
if end == "" {
end = "\r\n"
@ -336,51 +298,37 @@ func ChunkSplit(body string, chunkLen int, end string) string {
// Compare returns an integer comparing two strings lexicographically.
// The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
//
// 比较两个字符串。
func Compare(a, b string) int {
return strings.Compare(a, b)
}
// Equal reports whether s and t, interpreted as UTF-8 strings,
// are equal under Unicode case-folding, case-insensitive.
//
// 比较两个字符串是否相等（不区分大小写）。
// Equal reports whether <a> and <b>, interpreted as UTF-8 strings,
// are equal under Unicode case-folding, case-insensitively.
func Equal(a, b string) bool {
return strings.EqualFold(a, b)
}
// Return the words used in a string.
//
// 分割字符串中的单词。
// Fields returns the words used in a string as slice.
func Fields(str string) []string {
return strings.Fields(str)
}
// Contains reports whether substr is within str.
//
// 判断是否substr存在于str中。
// Contains reports whether <substr> is within <str>, case-sensitively.
func Contains(str, substr string) bool {
return strings.Contains(str, substr)
}
// Contains reports whether substr is within str, case-insensitive.
//
// 判断是否substr存在于str中(不区分大小写)。
// ContainsI reports whether substr is within str, case-insensitively.
func ContainsI(str, substr string) bool {
return PosI(str, substr) != -1
}
// ContainsAny reports whether any Unicode code points in chars are within s.
//
// 判断是否s中是否包含chars指定的任意字符。
// ContainsAny reports whether any Unicode code points in <chars> are within <s>.
func ContainsAny(s, chars string) bool {
return strings.ContainsAny(s, chars)
}
// Return information about words used in a string.
//
// 返回字符串中单词的使用情况。
// CountWords returns information about words' count used in a string.
func CountWords(str string) map[string]int {
m := make(map[string]int)
buffer := bytes.NewBuffer(nil)
@ -400,7 +348,7 @@ func CountWords(str string) map[string]int {
return m
}
// Return information about words used in a string.
// CountChars returns information about chars' count used in a string.
//
// 返回字符串中字符的使用情况。
func CountChars(str string, noSpace...bool) map[string]int {
@ -418,10 +366,8 @@ func CountChars(str string, noSpace...bool) map[string]int {
return m
}
// Wraps a string to a given number of characters.
// WordWrap wraps a string to a given number of characters.
// TODO: Enable cut param, see http://php.net/manual/en/function.wordwrap.php.
//
// 使用字符串断点将字符串打断为指定数量的字串。
func WordWrap(str string, width int, br string) string {
if br == "" {
br = "\n"
@ -479,24 +425,19 @@ func WordWrap(str string, width int, br string) string {
return buf.String()
}
// Get string length of unicode.
//
// UTF-8字符串长度。
// RuneLen returns string length of unicode.
func RuneLen(str string) int {
return utf8.RuneCountInString(str)
}
// Repeat returns a new string consisting of multiplier copies of the string input.
//
// 按照指定大小创建重复的字符串。
func Repeat(input string, multiplier int) string {
return strings.Repeat(input, multiplier)
}
// Returns part of haystack string starting from and including the first occurrence of needle to the end of haystack.
// Str returns part of <haystack> string starting from and including
// the first occurrence of <needle> to the end of <haystack>.
// See http://php.net/manual/en/function.strstr.php.
//
// 查找字符串的首次出现。返回 haystack 字符串从 needle 第一次出现的位置开始到 haystack 结尾的字符串。
func Str(haystack string, needle string) string {
if needle == "" {
return ""
@ -508,9 +449,7 @@ func Str(haystack string, needle string) string {
return haystack[idx + len([]byte(needle)) - 1 : ]
}
// Randomly shuffles a string.
//
// 将字符串打乱。
// Shuffle randomly shuffles a string.
func Shuffle(str string) string {
runes := []rune(str)
s := make([]rune, len(runes))
@ -520,54 +459,40 @@ func Shuffle(str string) string {
return string(s)
}
// Split a string by a string, to an array.
//
// 此函数返回由字符串组成的数组，每个元素都是 str 的一个子串，它们被字符串 delimiter 作为边界点分割出来。
// Split splits string <str> by a string <delimiter>, to an array.
func Split(str, delimiter string) []string {
return strings.Split(str, delimiter)
}
// Join concatenates the elements of a to create a single string. The separator string
// sep is placed between elements in the resulting string.
//
// 用sep将字符串数组array连接为一个字符串。
func Join(array []string, sep string) string {
return strings.Join(array, sep)
}
// Split a string by a string, to an array.
// Explode splits string <str> by a string <delimiter>, to an array.
// See http://php.net/manual/en/function.explode.php.
//
// 此函数返回由字符串组成的数组，每个元素都是 str 的一个子串，它们被字符串 delimiter 作为边界点分割出来。
func Explode(delimiter, str string) []string {
return Split(str, delimiter)
}
// Join array elements with a string.
// Implode joins array elements <pieces> with a string <glue>.
// http://php.net/manual/en/function.implode.php
//
// 用glue将字符串数组pieces连接为一个字符串。
func Implode(glue string, pieces []string) string {
return strings.Join(pieces, glue)
}
// Generate a single-byte string from a number.
//
// 返回相对应于 ascii 所指定的单个字符。
// Chr return the ascii string of a number(0-255).
func Chr(ascii int) string {
return string(ascii)
}
// Convert the first byte of a string to a value between 0 and 255.
//
// 解析 char 二进制值第一个字节为 0 到 255 范围的无符号整型类型。
// Ord converts the first byte of a string to a value between 0 and 255.
func Ord(char string) int {
return int(char[0])
}
// HideStr replaces part of the the string by percentage from the middle.
//
// 按照百分比从字符串中间向两边隐藏字符(主要用于姓名、手机号、邮箱地址、身份证号等的隐藏)，支持utf-8中文，支持email格式。
// HideStr replaces part of the the string <str> to <hide> by <percentage> from the <middle>.
func HideStr(str string, percent int, hide string) string {
array := strings.Split(str, "@")
if len(array) > 1 {
@ -593,10 +518,8 @@ func HideStr(str string, percent int, hide string) string {
return buffer.String()
}
// Inserts HTML line breaks before all newlines in a string.
// \n\r, \r\n, \r, \n
//
// 在字符串 string 所有新行之前插入 '<br />' 或 '<br>'，并返回。
// Nl2Br inserts HTML line breaks(<br>|<br />) before all newlines in a string:
// \n\r, \r\n, \r, \n.
func Nl2Br(str string, isXhtml...bool) string {
r, n, runes := '\r', '\n', []rune(str)
var br []byte
@ -628,9 +551,7 @@ func Nl2Br(str string, isXhtml...bool) string {
return buf.String()
}
// Quote string with slashes.
//
// 转义字符串中的单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。
// AddSlashes quotes chars('"\) with slashes.
func AddSlashes(str string) string {
var buf bytes.Buffer
for _, char := range str {
@ -643,9 +564,7 @@ func AddSlashes(str string) string {
return buf.String()
}
// Un-quotes a quoted string.
//
// 反转义字符串。
// StripSlashes un-quotes a quoted string by AddSlashes.
func StripSlashes(str string) string {
var buf bytes.Buffer
l, skip := len(str), false
@ -665,8 +584,6 @@ func StripSlashes(str string) string {
// Returns a version of str with a backslash character (\) before every character that is among:
// .\+*?[^]($)
//
// 转义字符串，转义的特殊字符包括：.\+*?[^]($)。
func QuoteMeta(str string) string {
var buf bytes.Buffer
for _, char := range str {

4
g/text/gstr/gstr_levenshtein.go
View File

@ -6,13 +6,11 @@
package gstr
// Calculate Levenshtein distance between two strings.
// Levenshtein calculates Levenshtein distance between two strings.
// costIns: Defines the cost of insertion.
// costRep: Defines the cost of replacement.
// costDel: Defines the cost of deletion.
// See http://php.net/manual/en/function.levenshtein.php.
//
// 计算两个字符串之间的编辑距离(Levenshtein distance)。
func Levenshtein(str1, str2 string, costIns, costRep, costDel int) int {
var maxLen = 255
l1 := len(str1)

3
g/text/gstr/gstr_parse.go
View File

@ -12,7 +12,7 @@ import (
"strings"
)
// Parses the string into map[string]interface{}.
// Parse parses the string into map[string]interface{}.
//
// f1=m&f2=n -> map[f1:m f2:n]
// f[a]=m&f[b]=n -> map[f:map[a:m b:n]]
@ -23,7 +23,6 @@ import (
// f=m&f[a]=n -> error
// a .[[b=c -> map[a___[b:c]
//
// 将字符串解析成Map。
func Parse(s string) (result map[string]interface{}, err error) {
result = make(map[string]interface{})
parts := strings.Split(s, "&")

28
g/text/gstr/gstr_pos.go
View File

@ -8,10 +8,9 @@ package gstr
import "strings"
// Find the position of the first occurrence of a substring in a string.
// It returns -1, if none found.
//
// 返回 needle 在 haystack 中首次出现的数字位置，找不到返回-1。
// Pos returns the position of the first occurrence of <needle>
// in <haystack> from <startOffset>, case-sensitively.
// It returns -1, if not found.
func Pos(haystack, needle string, startOffset...int) int {
length := len(haystack)
offset := 0
@ -32,10 +31,9 @@ func Pos(haystack, needle string, startOffset...int) int {
return pos + offset
}
// Find the position of the first occurrence of a case-insensitive substring in a string.
// It returns -1, if none found.
//
// 返回在字符串 haystack 中 needle 首次出现的数字位置（不区分大小写），找不到返回-1。
// PosI returns the position of the first occurrence of <needle>
// in <haystack> from <startOffset>, case-insensitively.
// It returns -1, if not found.
func PosI(haystack, needle string, startOffset...int) int {
length := len(haystack)
offset := 0
@ -56,10 +54,9 @@ func PosI(haystack, needle string, startOffset...int) int {
return pos + offset
}
// Find the position of the last occurrence of a substring in a string.
// It returns -1, if none found.
//
// 查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
// PosR returns the position of the last occurrence of <needle>
// in <haystack> from <startOffset>, case-sensitively.
// It returns -1, if not found.
func PosR(haystack, needle string, startOffset...int) int {
offset := 0
if len(startOffset) > 0 {
@ -82,10 +79,9 @@ func PosR(haystack, needle string, startOffset...int) int {
return pos
}
// Find the position of the last occurrence of a case-insensitive substring in a string.
// It returns -1, if none found.
//
// 以不区分大小写的方式查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
// PosR returns the position of the last occurrence of <needle>
// in <haystack> from <startOffset>, case-insensitively.
// It returns -1, if not found.
func PosRI(haystack, needle string, startOffset...int) int {
offset := 0
if len(startOffset) > 0 {

4
g/text/gstr/gstr_similartext.go
View File

@ -6,10 +6,8 @@
package gstr
// Calculate the similarity between two strings.
// SimilarText calculates the similarity between two strings.
// See http://php.net/manual/en/function.similar-text.php.
//
// 计算两个字符串的相似度。
func SimilarText(first, second string, percent *float64) int {
var similarText func(string, string, int, int) int
similarText = func(str1, str2 string, len1, len2 int) int {

4
g/text/gstr/gstr_soundex.go
View File

@ -6,10 +6,8 @@
package gstr
// Calculate the soundex key of a string.
// Soundex calculates the soundex key of a string.
// See http://php.net/manual/en/function.soundex.php.
//
// 计算字符串的SOUNDEX值，SOUNDEX为由四个字符组成的代码以评估两个字符串的相似性。
func Soundex(str string) string {
if str == "" {
panic("str: cannot be an empty string")

20
g/text/gstr/gstr_trim.go
View File

@ -8,9 +8,7 @@ package gstr
import "strings"
// Strip whitespace (or other characters) from the beginning and end of a string.
//
// 去除字符串首尾处的空白字符（或者其他字符）。
// Trim strips whitespace (or other characters) from the beginning and end of a string.
func Trim(str string, characterMask ...string) string {
if len(characterMask) > 0 {
return strings.Trim(str, characterMask[0])
@ -19,9 +17,7 @@ func Trim(str string, characterMask ...string) string {
}
}
// Strip whitespace (or other characters) from the beginning of a string.
//
// 去除字符串首的空白字符（或者其他字符）。
// TrimLeft strips whitespace (or other characters) from the beginning of a string.
func TrimLeft(str string, characterMask ...string) string {
mask := ""
if len(characterMask) == 0 {
@ -32,9 +28,7 @@ func TrimLeft(str string, characterMask ...string) string {
return strings.TrimLeft(str, mask)
}
// Strip all of the given <cut> string from the beginning of a string.
//
// 去除字符串首的给定字符串。
// TrimLeftStr strips all of the given <cut> string from the beginning of a string.
func TrimLeftStr(str string, cut string) string {
for str[0 : len(cut)] == cut {
str = str[len(cut) : ]
@ -42,9 +36,7 @@ func TrimLeftStr(str string, cut string) string {
return str
}
// Strip whitespace (or other characters) from the end of a string.
//
// 去除字符串尾的空白字符（或者其他字符）。
// TrimRight strips whitespace (or other characters) from the end of a string.
func TrimRight(str string, characterMask ...string) string {
mask := ""
if len(characterMask) == 0 {
@ -55,9 +47,7 @@ func TrimRight(str string, characterMask ...string) string {
return strings.TrimRight(str, mask)
}
// Strip all of the given <cut> string from the end of a string.
//
// 去除字符串尾的给定字符串。
// TrimRightStr strips all of the given <cut> string from the end of a string.
func TrimRightStr(str string, cut string) string {
for {
length := len(str)

53
g/text/gstr/gstr_z_bench_test.go
View File

@ -1,53 +0,0 @@
// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
// go test *.go -bench=".*"
package gstr_test
import (
"github.com/gogf/gf/g/text/gstr"
"testing"
)
var (
str = "This is the test string for gstr."
bytes = []byte(str)
)
func Benchmark_StringToBytes(b *testing.B) {
for i := 0; i < b.N; i++ {
if []byte(str) != nil {
}
}
}
func Benchmark_BytesToString(b *testing.B) {
for i := 0; i < b.N; i++ {
if string(bytes) != "" {
}
}
}
func Benchmark_Parse1(b *testing.B) {
for i := 0; i < b.N; i++ {
gstr.Parse("a=1&b=2")
}
}
func Benchmark_Parse2(b *testing.B) {
for i := 0; i < b.N; i++ {
gstr.Parse("m[]=1&m[]=2")
}
}
func Benchmark_Parse3(b *testing.B) {
for i := 0; i < b.N; i++ {
gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
}
}

1
g/util/util.go
View File

@ -1 +0,0 @@
package util

16
geg/os/gcron/gcron-log.go Normal file
View File

@ -0,0 +1,16 @@
package main
import (
"github.com/gogf/gf/g/os/gcron"
"github.com/gogf/gf/g/os/glog"
"time"
)
func main() {
gcron.SetLogLevel(glog.LEVEL_ALL)
gcron.Add("* * * * * ?", func() {
glog.Println("test")
})
time.Sleep(3 * time.Second)
}

11
geg/os/gtime/gtime_strtotime.go
View File

@ -2,6 +2,7 @@ package main
import (
"fmt"
"github.com/gogf/gf/g/os/glog"
"github.com/gogf/gf/g/os/gtime"
"time"
)
@ -19,15 +20,11 @@ func main() {
"2018-02-09",
"2017/12/14 04:51:34 +0805 LMT",
"2018/02/09 12:00:15",
"18/02/09 12:16",
"18/02/09 12",
"18/02/09 +0805 LMT",
"01/Nov/2018:13:28:13 +0800",
"01-Nov-2018 11:50:28 +0805 LMT",
"01-Nov-2018T15:04:05Z07:00",
"01-Nov-2018T01:19:15+08:00",
"01-Nov-2018 11:50:28 +0805 LMT",
"01/Nov/18 11:50:28",
"01/Nov/2018 11:50:28",
"01/Nov/2018:11:50:28",
"01.Nov.2018:11:50:28",
@ -35,12 +32,12 @@ func main() {
}
cstLocal, _ := time.LoadLocation("Asia/Shanghai")
for _, s := range array {
fmt.Println(s)
if t, err := gtime.StrToTime(s); err == nil {
fmt.Println(t.String())
fmt.Println(s)
fmt.Println(t.UTC().String())
fmt.Println(t.In(cstLocal).String())
} else {
panic(err)
glog.Error(s, err)
}
fmt.Println()
}

9
geg/other/test.go
View File

@ -1,11 +1,12 @@
package main
import (
"fmt"
"github.com/gogf/gf/g/os/gcfg"
"github.com/gogf/gf/g/test/gtest"
)
func test() []byte {
return nil
}
func main() {
fmt.Println(gcfg.Instance().GetString("viewpath"))
fmt.Println(gcfg.Instance().GetString("database.default.0.host"))
gtest.Assert(test(), nil)
}

2
version.go
View File

@ -1,4 +1,4 @@
package gf
const VERSION = "v1.5.23"
const VERSION = "v1.6.0"
const AUTHORS = "john<john@goframe.org>"