vbody

package module
v1.2.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 3, 2022 License: Apache-2.0 Imports: 9 Imported by: 6

README

vbody Build Status

golang vbody，在web的请求与响应中，body使用的JSON数据格式。

列表：

type Reader struct{                                                 // 读取
    M   map[string]interface{}                                          // 记录对象
    A   []interface{}                                                   // 记录数组
    m   sync.RWMutex                                                    // 安全锁
    err error                                                           // 错误
}
    func NewReader(i interface{}) *Reader                               // 读取
    func (T *Reader) NoZero(y bool) *Reader                             // 键名不存在或值为零，强制使用默认。否则仅键名不存在使用默认值。
    func (T *Reader) Err() error                                        // 错误
    func (T *Reader) IsNil(keys ...interface{}) bool                    // 是nil
    func (T *Reader) Has(keys ...interface{}) bool                      // 判断
    func (T *Reader) String(key, def string) string                     // 读取字符串
    func (T *Reader) StringAnyEqual(eq string, keys ... string) bool    // 字符串判断
    func (T *Reader) Bool(key string, def bool) bool                    // 读取布尔值
    func (T *Reader) BoolAnyEqual(eq bool, keys ... string) bool        // 布尔值判断
    func (T *Reader) Float64(key string, def float64) float64           // 读取浮点数
    func (T *Reader) Float64AnyEqual(eq float64, keys ... string) bool  // 浮点数判断
    func (T *Reader) Int64(key string, def int64) int64                 // 读取整数
    func (T *Reader) Int64AnyEqual(eq int64, keys ... string) bool      // 整数判断
    func (T *Reader) Interface(key string, def interface{}) interface{} // 读取接口
    func (T *Reader) NewInterface(key string, def interface{}) *Reader  // 读取接口*
    func (T *Reader) Array(key string, def []interface{}) []interface{} // 读取数组
    func (T *Reader) NewArray(key string, def []interface{}) *Reader    // 读取数组*
    func (T *Reader) Slice(s, e int) []interface{}                      // 读取切片
    func (T *Reader) NewSlice(s, e int) *Reader                         // 读取切片*
    func (T *Reader) Index(i int, def interface{}) interface{}          // 读取数组的单个值
    func (T *Reader) NewIndex(i int, def interface{}) *Reader           // 读取数组的单个值*
    func (T *Reader) IndexString(i int, def string) string              // 读取数组的单个字符串
    func (T *Reader) IndexFloat64(i int, def float64) float64           // 读取数组的单个浮点数
    func (T *Reader) IndexInt64(i int, def int64) int64                 // 读取数组的单个整数
    func (T *Reader) IndexArray(i int, def []interface{}) []interface{} // 读取数组的单个数组
    func (T *Reader) NewIndexArray(i int, def []interface{}) *Reade     // 读取数组的单个数组*
    func (T *Reader) Reset(i interface{}) error                         // 重置
    func (T *Reader) ReadFrom(r io.Reader) error                        // 从r读取导入
    func (T *Reader) MarshalJSON() ([]byte, error)                      // 编码json
    func (T *Reader) UnmarshalJSON(data []byte) error                   // 解码json

type Writer struct{                                                 // 写入
    M map[string]interface{}                                            // 写记录
}
    func NewWriter() *Writer                                            // 写入器
    func (T *Writer) Status(d int)                                      // 状态
    func (T *Writer) Message(s interface{})                             // 信息
    func (T *Writer) Messagef(f string, a ...interface{})               // 信息（支持格式）
    func (T *Writer) SetResult(i interface{})                           // 设置结果
    func (T *Writer) Result(key string, i interface{})                  // 结果
    func (T *Writer) WriteTo(w io.Writer) (n int64, err error)          // 写入到w

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Change added in v1.2.5 

type Change struct {
	// contains filtered or unexported fields
}

func (*Change) Delete added in v1.2.5 

func (T *Change) Delete(key interface{})

func (*Change) Set added in v1.2.5 

func (T *Change) Set(key interface{}, val interface{})

func (*Change) Update added in v1.2.5 

func (T *Change) Update(key interface{}, val interface{})

type Reader 

type Reader struct {
	M map[string]interface{} // 记录对象
	A []interface{}          // 记录数组
	// contains filtered or unexported fields
}

func NewReader 

func NewReader(i interface{}) *Reader

读取 

i interface{}	数据，支持map，array，slice，io.Reader, *string，[]byte。你也可以对 Reader.M 或 Reader.A 进行赋值。
*Reader			读取对象

func (*Reader) Array 

func (T *Reader) Array(key string, def ...[]interface{}) []interface{}

读取值是数组类型的 

key string				键名
def []interface{}		默认值
[]interface{}			读取的数组类型

例如：{"a":[1,3,4,5,6]} Array("a",[7,8,9,0]) == [1,3,4,5,6] 或 Array("b",[7,8,9,0]) == [7,8,9,0]

func (*Reader) Bool 

func (T *Reader) Bool(key string, def ...bool) bool

读取值是布尔值类型的 

key string, def bool	键名，默认值
bool			读取的布尔值

例如：{"a":true} Bool("a",false) == true

func (*Reader) BoolAnyEqual 

func (T *Reader) BoolAnyEqual(eq bool, keys ...string) bool

判断值是否等于eq这个布尔值 

eq bool				判断keys是否等于这个布尔值
keys ... string		支持多个键名判断
bool				值等于eq，返回true

例如：{"a":true}  BoolAnyEqual(false,"a") == false 或 BoolAnyEqual(true,"a") == true

func (*Reader) Change added in v1.2.5 

func (T *Reader) Change() *Change

变更

func (*Reader) Err 

func (T *Reader) Err() error

错误 

error	如果 Reader.Reset 重置有误，可以从这里得到相关错误。

func (*Reader) Float64 

func (T *Reader) Float64(key string, def ...float64) float64

读取值是浮点数类型的 

key, def float64	键名，默认值
float64				读取的浮点数

例如：{"a":123} Float64（"a",123） == 123

func (*Reader) Float64AnyEqual 

func (T *Reader) Float64AnyEqual(eq float64, keys ...string) bool

判断值是否等于eq这个浮点数 

eq string			判断keys是否等于这个浮点数
keys ... string		支持多个键名判断
bool				值等于eq，返回true

例如：{"a":123}  Float64AnyEqual(456,"a") == false 或 Float64AnyEqual(123,"a") == true

func (*Reader) Has 

func (T *Reader) Has(keys ...interface{}) bool

检查键是否存在 

keys ...interface{}		键名，如果需要判断切片的长度，可以传入int类型。当然也可以这样 len(Reader.A)
bool					存在，返回true

例如：{"a":"b"} Has("a") == true 或 Has("b") == false

func (*Reader) Index 

func (T *Reader) Index(i int, def ...interface{}) interface{}

读取值是切片类型的 

i int				索引位置
def nterface{}		默认值
interface{}			读取到的切片值

例如：[1,2,3,4,5,6] Index(1,11) == 1  或 Index(8,22) == 22

func (*Reader) IndexArray 

func (T *Reader) IndexArray(i int, def ...[]interface{}) []interface{}

读取切片类型的值是数组类型的 

i int				索引位置
def []interface{}	默认值
[]interface{}		读取到的切片值

例如：[[1],[2]] IndexArray(1,[]interface{1,2}) == [2] 或 IndexArray(3,[]interface{1,2}) == [1,2]

func (*Reader) IndexFloat64 

func (T *Reader) IndexFloat64(i int, def ...float64) float64

读取切片类型的值是浮点数类型的 

i int				索引位置
def float64			默认值
float64				读取到的浮点数

例如：[1,2,[7,8,9,0],4,5,6] IndexInt64(1,11) == 2  或 IndexInt64(2,22) == 22

func (*Reader) IndexInt64 

func (T *Reader) IndexInt64(i int, def ...int64) int64

读取切片类型的值是整数类型的 

i int				索引位置
def int64			默认值
int64				读取到的整数

例如：[1,2,[7,8,9,0],4,5,6] IndexInt64(1,11) == 2  或 IndexInt64(2,22) == 22

func (*Reader) IndexString 

func (T *Reader) IndexString(i int, def ...string) string

读取切片类型的值是字符串类型的 

i int				索引位置
def string			默认值
string				读取到的切片值

例如：["1","2",[7,8,9,0],"4","5","6"] IndexString(1,"11") == "2"  或 IndexString(2,"22") == "22"

func (*Reader) Int64 

func (T *Reader) Int64(key string, def ...int64) int64

读取值是整数类型的 

key, def int64	键名，默认值
int64				读取的整数

例如：{"a":123} Int64("a",0) == 123 或 Int64("b",456) == 456

func (*Reader) Int64AnyEqual 

func (T *Reader) Int64AnyEqual(eq int64, keys ...string) bool

判断值是否等于eq这个整数 

eq int64			判断keys是否等于这个整数
keys ... int64		支持多个键名判断
bool				值等于eq，返回true

例如：{"a":123}  Int64AnyEqual(456,"a") == false 或 Int64AnyEqual(123,"a") == true

func (*Reader) Interface 

func (T *Reader) Interface(key string, def ...interface{}) interface{}

读取值是接口类型的 

key string			键名
def interface{}		默认值
interface{}			读取的接口类型，需要转换

例如：{"a":"b"} Interface("a","c") == "b" 或 Interface("b","c") == "c"

func (*Reader) IsNil 

func (T *Reader) IsNil(keys ...interface{}) bool

是nil值 

keys ...interface{}		键名，如果需要判断切片的长度，可以传入int类型。
bool					是nil值，返回true

func (*Reader) MarshalJSON 

func (T *Reader) MarshalJSON() ([]byte, error)

Reader转字节串 

[]byte	字节串，如：[]byte(`{"A":1}`)
error	错误

func (*Reader) NewArray 

func (T *Reader) NewArray(key string, def ...[]interface{}) *Reader

读取值是数组类型的 

key string				键名
def []interface{}		默认值
[]interface{}			读取的数组类型

例如：{"a":[1,3,4,5,6]} Array("a",[7,8,9,0]) == *[1,3,4,5,6] 或 Array("b",[7,8,9,0]) == *[7,8,9,0]

func (*Reader) NewIndex 

func (T *Reader) NewIndex(i int, def ...interface{}) *Reader

读取值是切片类型的 

i int				索引位置
def nterface{}		默认值
*Reader				读取到的切片值

例如：[1,2,[7,8,9,0],4,5,6] NewIndex(2,[11,22,33]) == *[7,8,9,0]  或 NewIndex(3,[11,22,33]) == *[] 或 NewIndex(33,[11,22,33]) == *[11,22,33]

func (*Reader) NewIndexArray 

func (T *Reader) NewIndexArray(i int, def ...[]interface{}) *Reader

读取切片类型的值是数组类型的 

i int				索引位置
def []interface{}	默认值
*Reader				读取到的切片值

例如：[[1],[2]] NewIndexArray(1,[]interface{1,2}) == *[2] 或 NewIndexArray(3,[]interface{1,2}) == *[1,2]

func (*Reader) NewInterface 

func (T *Reader) NewInterface(key string, def ...interface{}) *Reader

读取值是接口类型的 

key string			键名
def interface{}		默认值
interface{}			读取的接口类型，需要转换

例如：{"a":{"b":123}} NewInterface("a",*{"b":456}) == *{"b":123} 或 NewInterface("b",*{"b":456}) == *{"b":456}

func (*Reader) NewSlice 

func (T *Reader) NewSlice(s, e int) *Reader

读取值是切片类型的，设定开始和结束位置来读取。 

s, e int		开始，结束。
*Reader			读取到的切片对象

例如：[1,2,3,4,5,6] NewSlice(1,2) == *[2]  或 NewSlice(8,9) == *[]

func (*Reader) NoZero added in v1.2.4 

func (T *Reader) NoZero(y bool) *Reader

值不可以为零值，如果为零值，则读取是def设置值。 y bool true不可以为零，false可以为零值

func (*Reader) ReadFrom 

func (T *Reader) ReadFrom(r io.Reader) (int64, error)

从r读取字节串并解析成Reader 

r io.Reader	字节串读接口
int64		读取长度
error		错误

func (*Reader) Reset 

func (T *Reader) Reset(i interface{}) error

重置，如果需要重置为空，需要先调用一次.Reset(nil) 

i interface{}	支持格式，包括：map,array,slice,io.Reader,*string, []byte
error			错误

func (*Reader) Slice 

func (T *Reader) Slice(s, e int) []interface{}

读取值是切片类型的，设定开始和结束位置来读取。 

s, e int		开始，结束。
[]interface{}	读取到的切片

例如：[1,2,3,4,5,6] Slice(1,2) == [2]  或 Slice(8,9) == []

func (*Reader) String 

func (T *Reader) String(key string, def ...string) string

读取值是字符串类型的 

key, def string	键名，默认值
string			读取的字符串

例如：{"a":"b"} String("a","") == "b"

func (*Reader) StringAnyEqual 

func (T *Reader) StringAnyEqual(eq string, keys ...string) bool

判断值是否等于eq这个字符串 

eq string			判断keys是否等于这个字符串
keys ... string		支持多个键名判断
bool				值等于eq，返回true

例如：{"a":"b"}  StringAnyEqual("","a") == false 或 StringAnyEqual("b","a") == true

func (*Reader) UnmarshalJSON 

func (T *Reader) UnmarshalJSON(data []byte) error

字节串解析成Reader 

data []byte	字节串，如：[]byte(`{"A":1}`)
error		错误

type Writer 

type Writer struct {
	M map[string]interface{} // 写记录
}

func NewWriter 

func NewWriter() *Writer

写，这是http响应的一种特定格式。采用格式为：{"Status":200,"Message":"内容","Result":[{...},{...}]}

func (*Writer) Message 

func (T *Writer) Message(s interface{})

提示内容 

s interface{}	内容

func (*Writer) Messagef 

func (T *Writer) Messagef(f string, a ...interface{})

提示内容，支持fmt.Sprintf 格式 

f string			格式
a ...interface{}	参数

func (*Writer) Result 

func (T *Writer) Result(key string, i interface{})

设置结果 

key string		键名
i interface{}	值

func (*Writer) SetResult 

func (T *Writer) SetResult(i interface{})

设置结果 

i interface{}	结果

func (*Writer) Status 

func (T *Writer) Status(d int)

状态 

d int	状态码

func (*Writer) String 

func (T *Writer) String() string

字符串json格式 

string		json格式

func (*Writer) WriteTo 

func (T *Writer) WriteTo(w io.Writer) (n int64, err error)

写入到w 

w io.Writer	写入接口
n int64		写入长度
err error	错误

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.