Skip to content

Commit 2a4217d

Browse files
CC11001100CC11001100
committed
add set default
1 parent 05f51ac commit 2a4217d

File tree

6 files changed

+342
-11
lines changed

6 files changed

+342
-11
lines changed

‎README.md‎

Lines changed: 170 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ go get -u github.com/golang-infrastructure/go-variable-parameter
99
```
1010

1111
# 三、Example
12-
12+
## 3.1 TakeFirstParamOrDefault
1313
```go
1414
package main
1515

@@ -23,26 +23,191 @@ type FooOptions struct {
2323
Bar int
2424
}
2525

26-
var DefaultFooOptions = FooOptions{
26+
var DefaultFooOptions = &FooOptions{
2727
Foo: "default foo",
2828
Bar: 10,
2929
}
3030

31-
func Foo(optionsVariableParams ...FooOptions) {
32-
// 如果传递了options则使用传递的，如果没传递则使用默认的
31+
func Foo(optionsVariableParams ...*FooOptions) {
32+
// 如果传递了options则使用传递的取出数组中的第一个元素返回，如果没传递则使用给出的默认值，适合默认值是一个固定的值的时候用
3333
options := variable_parameter.TakeFirstParamOrDefault(optionsVariableParams, DefaultFooOptions)
34+
35+
// 后面的代码就可以直接使用options来操作啦
36+
fmt.Println(options.Foo)
37+
38+
}
39+
40+
func main() {
41+
42+
// 不传递参数
43+
Foo() // Output: default foo
44+
45+
// 传递参数
46+
Foo(&FooOptions{Foo: "custom foo"}) // Output: custom foo
47+
48+
}
49+
```
50+
51+
52+
## 3.2 TakeFirstParamOrDefaultFunc
53+
```go
54+
package main
55+
56+
import (
57+
"fmt"
58+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
59+
"time"
60+
)
61+
62+
type FooOptions struct {
63+
Foo string
64+
Bar int
65+
}
66+
67+
func NewFooOptions() *FooOptions {
68+
69+
// 假装有耗时操作
70+
time.Sleep(time.Second * 1)
71+
72+
return &FooOptions{
73+
Foo: "default foo",
74+
Bar: 10,
75+
}
76+
}
77+
78+
func Foo(optionsVariableParams ...*FooOptions) {
79+
// 如果后面可能会涉及到对options的修改之类的，则options无法使用单例，可能得每次都重新创建一个新的，则可以使用一个默认值的函数，仅在需要默认值的时候才运行
80+
options := variable_parameter.TakeFirstParamOrDefaultFunc(optionsVariableParams, func() *FooOptions {
81+
// 如果初始化比较耗时或者觉得仅在必要的时候才创建比较好可以用这种默认函数的方式，此函数仅在未传递参数时运行
82+
return NewFooOptions()
83+
})
84+
85+
// 后面的代码就可以直接使用options来操作啦
3486
fmt.Println(options.Foo)
3587
}
3688

3789
func main() {
3890

91+
// 传递参数
92+
start := time.Now()
93+
Foo(&FooOptions{Foo: "custom foo"})
94+
cost := time.Now().Sub(start)
95+
fmt.Println("传递参数时耗时：" + cost.String())
96+
// Output:
97+
// custom foo
98+
// 传递参数时耗时：0s
99+
100+
// 不传递参数
101+
start = time.Now()
102+
Foo()
103+
cost = time.Now().Sub(start)
104+
fmt.Println("不传递参数时耗时：" + cost.String())
105+
// Output:
106+
// default foo
107+
// 不传递参数时耗时：1.0136631s
108+
109+
}
110+
```
111+
112+
113+
## 3.3 SetDefaultParam
114+
```go
115+
package main
116+
117+
import (
118+
"fmt"
119+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
120+
)
121+
122+
type FooOptions struct {
123+
Foo string
124+
Bar int
125+
}
126+
127+
var DefaultFooOptions = &FooOptions{
128+
Foo: "default foo",
129+
Bar: 10,
130+
}
131+
132+
func Foo(options ...*FooOptions) {
133+
// 如果没有传递参数的话，则设置一个默认的参数
134+
options = variable_parameter.SetDefaultParam(options, DefaultFooOptions)
135+
136+
// 后面的代码就可以直接使用options[0]来操作而不必担心越界
137+
fmt.Println(options[0].Foo)
138+
}
139+
140+
func main() {
141+
142+
// 传递参数
143+
Foo(&FooOptions{Foo: "custom foo"}) // Output: custom foo
144+
39145
// 不传递参数
40146
Foo() // Output: default foo
41147

148+
}
149+
```
150+
151+
152+
## 3.4 SetDefaultParamByFunc
153+
```go
154+
package main
155+
156+
import (
157+
"fmt"
158+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
159+
"time"
160+
)
161+
162+
type FooOptions struct {
163+
Foo string
164+
Bar int
165+
}
166+
167+
func NewFooOptions() *FooOptions {
168+
169+
// 假装有耗时操作
170+
time.Sleep(time.Second * 1)
171+
172+
return &FooOptions{
173+
Foo: "default foo",
174+
Bar: 10,
175+
}
176+
}
177+
178+
func Foo(options ...*FooOptions) {
179+
// 如果后面可能会涉及到对options[0]的修改之类的，则options[0]无法使用单例，可能得每次都重新创建一个新的，则可以使用一个默认值函数，仅在未传递参数的时候才会执行
180+
options = variable_parameter.SetDefaultParamByFunc(options, func() *FooOptions {
181+
// 如果初始化比较耗时或者觉得仅在必要的时候才创建比较好可以用这种默认函数的方式，此函数仅在未传递参数时运行
182+
return NewFooOptions()
183+
})
184+
185+
// 后面的代码就可以直接使用options[0]来操作啦
186+
fmt.Println(options[0].Foo)
187+
}
188+
189+
func main() {
190+
42191
// 传递参数
43-
Foo(FooOptions{Foo: "custom foo"}) // Output: custom foo
192+
start := time.Now()
193+
Foo(&FooOptions{Foo: "custom foo"})
194+
cost := time.Now().Sub(start)
195+
fmt.Println("传递参数时耗时：" + cost.String())
196+
// Output:
197+
// custom foo
198+
// 传递参数时耗时：0s
199+
200+
// 不传递参数
201+
start = time.Now()
202+
Foo()
203+
cost = time.Now().Sub(start)
204+
fmt.Println("不传递参数时耗时：" + cost.String())
205+
// Output:
206+
// default foo
207+
// 不传递参数时耗时：1.0136631s
44208

45209
}
46210
```
47211

48212

213+

‎examples/main.go‎ renamed to ‎examples/basic_usage/main.go‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,18 @@ type FooOptions struct {
1010
Bar int
1111
}
1212

13-
var DefaultFooOptions = FooOptions{
13+
var DefaultFooOptions = &FooOptions{
1414
Foo: "default foo",
1515
Bar: 10,
1616
}
1717

18-
func Foo(optionsVariableParams ...FooOptions) {
19-
// 如果传递了options则使用传递的，如果没传递则使用默认的
18+
func Foo(optionsVariableParams ...*FooOptions) {
19+
// 如果传递了options则使用传递的取出数组中的第一个元素返回，如果没传递则使用给出的默认值，适合默认值是一个固定的值的时候用
2020
options := variable_parameter.TakeFirstParamOrDefault(optionsVariableParams, DefaultFooOptions)
21+
22+
// 后面的代码就可以直接使用options来操作啦
2123
fmt.Println(options.Foo)
24+
2225
}
2326

2427
func main() {
@@ -27,6 +30,6 @@ func main() {
2730
Foo() // Output: default foo
2831

2932
// 传递参数
30-
Foo(FooOptions{Foo: "custom foo"}) // Output: custom foo
33+
Foo(&FooOptions{Foo: "custom foo"}) // Output: custom foo
3134

3235
}

‎examples/default_func/main.go‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
package main
2+
3+
import (
4+
"fmt"
5+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
6+
"time"
7+
)
8+
9+
type FooOptions struct {
10+
Foo string
11+
Bar int
12+
}
13+
14+
func NewFooOptions() *FooOptions {
15+
16+
// 假装有耗时操作
17+
time.Sleep(time.Second * 1)
18+
19+
return &FooOptions{
20+
Foo: "default foo",
21+
Bar: 10,
22+
}
23+
}
24+
25+
func Foo(optionsVariableParams ...*FooOptions) {
26+
// 如果后面可能会涉及到对options的修改之类的，则options无法使用单例，可能得每次都重新创建一个新的，则可以使用一个默认值的函数，仅在需要默认值的时候才运行
27+
options := variable_parameter.TakeFirstParamOrDefaultFunc(optionsVariableParams, func() *FooOptions {
28+
// 如果初始化比较耗时或者觉得仅在必要的时候才创建比较好可以用这种默认函数的方式，此函数仅在未传递参数时运行
29+
return NewFooOptions()
30+
})
31+
32+
// 后面的代码就可以直接使用options来操作啦
33+
fmt.Println(options.Foo)
34+
}
35+
36+
func main() {
37+
38+
// 传递参数
39+
start := time.Now()
40+
Foo(&FooOptions{Foo: "custom foo"})
41+
cost := time.Now().Sub(start)
42+
fmt.Println("传递参数时耗时：" + cost.String())
43+
// Output:
44+
// custom foo
45+
// 传递参数时耗时：0s
46+
47+
// 不传递参数
48+
start = time.Now()
49+
Foo()
50+
cost = time.Now().Sub(start)
51+
fmt.Println("不传递参数时耗时：" + cost.String())
52+
// Output:
53+
// default foo
54+
// 不传递参数时耗时：1.0136631s
55+
56+
}

‎examples/set_default/main.go‎

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
package main
2+
3+
import (
4+
"fmt"
5+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
6+
)
7+
8+
type FooOptions struct {
9+
Foo string
10+
Bar int
11+
}
12+
13+
var DefaultFooOptions = &FooOptions{
14+
Foo: "default foo",
15+
Bar: 10,
16+
}
17+
18+
func Foo(options ...*FooOptions) {
19+
// 如果没有传递参数的话，则设置一个默认的参数
20+
options = variable_parameter.SetDefaultParam(options, DefaultFooOptions)
21+
22+
// 后面的代码就可以直接使用options[0]来操作而不必担心越界
23+
fmt.Println(options[0].Foo)
24+
}
25+
26+
func main() {
27+
28+
// 传递参数
29+
Foo(&FooOptions{Foo: "custom foo"}) // Output: custom foo
30+
31+
// 不传递参数
32+
Foo() // Output: default foo
33+
34+
}

‎examples/set_default_func/main.go‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
package main
2+
3+
import (
4+
"fmt"
5+
variable_parameter "github.com/golang-infrastructure/go-variable-parameter"
6+
"time"
7+
)
8+
9+
type FooOptions struct {
10+
Foo string
11+
Bar int
12+
}
13+
14+
func NewFooOptions() *FooOptions {
15+
16+
// 假装有耗时操作
17+
time.Sleep(time.Second * 1)
18+
19+
return &FooOptions{
20+
Foo: "default foo",
21+
Bar: 10,
22+
}
23+
}
24+
25+
func Foo(options ...*FooOptions) {
26+
// 如果后面可能会涉及到对options[0]的修改之类的，则options[0]无法使用单例，可能得每次都重新创建一个新的，则可以使用一个默认值函数，仅在未传递参数的时候才会执行
27+
options = variable_parameter.SetDefaultParamByFunc(options, func() *FooOptions {
28+
// 如果初始化比较耗时或者觉得仅在必要的时候才创建比较好可以用这种默认函数的方式，此函数仅在未传递参数时运行
29+
return NewFooOptions()
30+
})
31+
32+
// 后面的代码就可以直接使用options[0]来操作啦
33+
fmt.Println(options[0].Foo)
34+
}
35+
36+
func main() {
37+
38+
// 传递参数
39+
start := time.Now()
40+
Foo(&FooOptions{Foo: "custom foo"})
41+
cost := time.Now().Sub(start)
42+
fmt.Println("传递参数时耗时：" + cost.String())
43+
// Output:
44+
// custom foo
45+
// 传递参数时耗时：0s
46+
47+
// 不传递参数
48+
start = time.Now()
49+
Foo()
50+
cost = time.Now().Sub(start)
51+
fmt.Println("不传递参数时耗时：" + cost.String())
52+
// Output:
53+
// default foo
54+
// 不传递参数时耗时：1.0136631s
55+
56+
}

0 commit comments

Comments
 (0)