| Bad | Good |
|---|---|
| 51 | 52 | ```go 53 | type Handler struct { 54 | // ... 55 | } 56 | 57 | 58 | 59 | func (h *Handler) ServeHTTP( 60 | w http.ResponseWriter, 61 | r *http.Request, 62 | ) { 63 | ... 64 | } 65 | ``` 66 | 67 | | 68 | 69 | ```go 70 | type Handler struct { 71 | // ... 72 | } 73 | 74 | var _ http.Handler = (*Handler)(nil) 75 | 76 | func (h *Handler) ServeHTTP( 77 | w http.ResponseWriter, 78 | r *http.Request, 79 | ) { 80 | // ... 81 | } 82 | ``` 83 | 84 | |
| Bad | Good |
|---|---|
| 177 | 178 | ```go 179 | mu := new(sync.Mutex) 180 | mu.Lock() 181 | ``` 182 | 183 | | 184 | 185 | ```go 186 | var mu sync.Mutex 187 | mu.Lock() 188 | ``` 189 | 190 | |
| 200 | 201 | ```go 202 | type smap struct { 203 | sync.Mutex // only for unexported types 204 | 205 | data map[string]string 206 | } 207 | 208 | func newSMap() *smap { 209 | return &smap{ 210 | data: make(map[string]string), 211 | } 212 | } 213 | 214 | func (m *smap) Get(k string) string { 215 | m.Lock() 216 | defer m.Unlock() 217 | 218 | return m.data[k] 219 | } 220 | ``` 221 | 222 | | 223 | 224 | ```go 225 | type SMap struct { 226 | mu sync.Mutex 227 | 228 | data map[string]string 229 | } 230 | 231 | func NewSMap() *SMap { 232 | return &SMap{ 233 | data: make(map[string]string), 234 | } 235 | } 236 | 237 | func (m *SMap) Get(k string) string { 238 | m.mu.Lock() 239 | defer m.mu.Unlock() 240 | 241 | return m.data[k] 242 | } 243 | ``` 244 | 245 | |
| インターナルな型やmutexのインタフェースを実装している必要がある場合には埋め込みを使う | 250 |公開されている型にはプライベートなフィールドを使う | 251 |
| Bad | Good |
|---|---|
| 266 | 267 | ```go 268 | func (d *Driver) SetTrips(trips []Trip) { 269 | d.trips = trips 270 | } 271 | 272 | trips := ... 273 | d1.SetTrips(trips) 274 | 275 | // ここで値が変わると d1.trips[0] も変わる 276 | trips[0] = ... 277 | ``` 278 | 279 | | 280 |281 | 282 | ```go 283 | func (d *Driver) SetTrips(trips []Trip) { 284 | d.trips = make([]Trip, len(trips)) 285 | copy(d.trips, trips) 286 | } 287 | 288 | trips := ... 289 | d1.SetTrips(trips) 290 | 291 | // d1.trips に変更が及ばない 292 | trips[0] = ... 293 | ``` 294 | 295 | | 296 |
| Bad | Good |
|---|---|
| 308 | 309 | ```go 310 | type Stats struct { 311 | mu sync.Mutex 312 | counters map[string]int 313 | } 314 | 315 | // Snapshot returns the current stats. 316 | func (s *Stats) Snapshot() map[string]int { 317 | s.mu.Lock() 318 | defer s.mu.Unlock() 319 | 320 | return s.counters 321 | } 322 | 323 | // snapshot は mutex で守られない 324 | // レースコンディションが起きる 325 | snapshot := stats.Snapshot() 326 | ``` 327 | 328 | | 329 | 330 | ```go 331 | type Stats struct { 332 | mu sync.Mutex 333 | counters map[string]int 334 | } 335 | 336 | func (s *Stats) Snapshot() map[string]int { 337 | s.mu.Lock() 338 | defer s.mu.Unlock() 339 | 340 | result := make(map[string]int, len(s.counters)) 341 | for k, v := range s.counters { 342 | result[k] = v 343 | } 344 | return result 345 | } 346 | 347 | // snapshot はただのコピーなので変更しても影響はない 348 | snapshot := stats.Snapshot() 349 | ``` 350 | 351 | |
| Bad | Good |
|---|---|
| 361 | 362 | ```go 363 | p.Lock() 364 | if p.count < 10 { 365 | p.Unlock() 366 | return p.count 367 | } 368 | 369 | p.count++ 370 | newCount := p.count 371 | p.Unlock() 372 | 373 | return newCount 374 | 375 | // easy to miss unlocks due to multiple returns 376 | ``` 377 | 378 | | 379 | 380 | ```go 381 | p.Lock() 382 | defer p.Unlock() 383 | 384 | if p.count < 10 { 385 | return p.count 386 | } 387 | 388 | p.count++ 389 | return p.count 390 | 391 | // more readable 392 | ``` 393 | 394 | |
| Bad | Good |
|---|---|
| 412 | 413 | ```go 414 | // Ought to be enough for anybody! 415 | c := make(chan int, 64) 416 | ``` 417 | 418 | | 419 | 420 | ```go 421 | // Size of one 422 | c := make(chan int, 1) // or 423 | // Unbuffered channel, size of zero 424 | c := make(chan int) 425 | ``` 426 | 427 | |
| Bad | Good |
|---|---|
| 438 | 439 | ```go 440 | type Operation int 441 | 442 | const ( 443 | Add Operation = iota 444 | Subtract 445 | Multiply 446 | ) 447 | 448 | // Add=0, Subtract=1, Multiply=2 449 | ``` 450 | 451 | | 452 | 453 | ```go 454 | type Operation int 455 | 456 | const ( 457 | Add Operation = iota + 1 458 | Subtract 459 | Multiply 460 | ) 461 | 462 | // Add=1, Subtract=2, Multiply=3 463 | ``` 464 | 465 | |
| Bad | Good |
|---|---|
| 506 | 507 | ```go 508 | func isActive(now, start, stop int) bool { 509 | return start <= now && now < stop 510 | } 511 | ``` 512 | 513 | | 514 | 515 | ```go 516 | func isActive(now, start, stop time.Time) bool { 517 | return (start.Before(now) || start.Equal(now)) && now.Before(stop) 518 | } 519 | ``` 520 | 521 | |
| Bad | Good |
|---|---|
| 531 | 532 | ```go 533 | func poll(delay int) { 534 | for { 535 | // ... 536 | time.Sleep(time.Duration(delay) * time.Millisecond) 537 | } 538 | } 539 | 540 | poll(10) // was it seconds or milliseconds? 541 | ``` 542 | 543 | | 544 | 545 | ```go 546 | func poll(delay time.Duration) { 547 | for { 548 | // ... 549 | time.Sleep(delay) 550 | } 551 | } 552 | 553 | poll(10*time.Second) 554 | ``` 555 | 556 | |
| Bad | Good |
|---|---|
| 584 | 585 | ```go 586 | // {"interval": 2} 587 | type Config struct { 588 | Interval int `json:"interval"` 589 | } 590 | ``` 591 | 592 | | 593 | 594 | ```go 595 | // {"intervalMillis": 2000} 596 | type Config struct { 597 | IntervalMillis int `json:"intervalMillis"` 598 | } 599 | ``` 600 | 601 | |
| No error matching | Error matching |
|---|---|
| 639 | 640 | ```go 641 | // package foo 642 | 643 | func Open() error { 644 | return errors.New("could not open") 645 | } 646 | 647 | // package bar 648 | 649 | if err := foo.Open(); err != nil { 650 | // Can't handle the error. 651 | panic("unknown error") 652 | } 653 | ``` 654 | 655 | | 656 | 657 | ```go 658 | // package foo 659 | 660 | var ErrCouldNotOpen = errors.New("could not open") 661 | 662 | func Open() error { 663 | return ErrCouldNotOpen 664 | } 665 | 666 | // package bar 667 | 668 | if err := foo.Open(); err != nil { 669 | if errors.Is(err, foo.ErrCouldNotOpen) { 670 | // handle the error 671 | } else { 672 | panic("unknown error") 673 | } 674 | } 675 | ``` 676 | 677 | |
| No error matching | Error matching |
|---|---|
| 686 | 687 | ```go 688 | // package foo 689 | 690 | func Open(file string) error { 691 | return fmt.Errorf("file %q not found", file) 692 | } 693 | 694 | // package bar 695 | 696 | if err := foo.Open("testfile.txt"); err != nil { 697 | // Can't handle the error. 698 | panic("unknown error") 699 | } 700 | ``` 701 | 702 | | 703 | 704 | ```go 705 | // package foo 706 | 707 | type NotFoundError struct { 708 | File string 709 | } 710 | 711 | func (e *NotFoundError) Error() string { 712 | return fmt.Sprintf("file %q not found", e.File) 713 | } 714 | 715 | func Open(file string) error { 716 | return &NotFoundError{File: file} 717 | } 718 | 719 | 720 | // package bar 721 | 722 | if err := foo.Open("testfile.txt"); err != nil { 723 | var notFound *NotFoundError 724 | if errors.As(err, ¬Found) { 725 | // handle the error 726 | } else { 727 | panic("unknown error") 728 | } 729 | } 730 | ``` 731 | 732 | |
| Bad | Good |
|---|---|
| 790 | 791 | ```go 792 | s, err := store.New() 793 | if err != nil { 794 | return fmt.Errorf( 795 | "failed to create new store: %w", err) 796 | } 797 | ``` 798 | 799 | | 800 | 801 | ```go 802 | s, err := store.New() 803 | if err != nil { 804 | return fmt.Errorf( 805 | "new store: %w", err) 806 | } 807 | ``` 808 | 809 | |
| 810 | 811 | ``` 812 | failed to x: failed to y: failed to create new store: the error 813 | ``` 814 | 815 | | 816 | 817 | ``` 818 | x: y: new store: the error 819 | ``` 820 | 821 | |
| Description | Code |
|---|---|
| 900 | 901 | **悪い例**: エラーをログに書き出してから返す。 902 | 903 | より上位の呼び出し先も同様にエラーをログに出力する可能性があるので、アプリケーションログに多くのノイズが混ざりこのログの価値が薄まります。 904 | 905 | | 906 | 907 | ```go 908 | u, err := getUser(id) 909 | if err != nil { 910 | // BAD: See description 911 | log.Printf("Could not get user %q: %v", id, err) 912 | return err 913 | } 914 | ``` 915 | 916 | |
| 918 | 919 | **良い例**: エラーをラップして返す。 920 | 921 | より上位の呼び出し側がエラーを処理します。 `%w` を使うと、[`errors.Is`]や[`errors.As`]を使ってエラーマッチさせることができます。 922 | 923 | | 924 | 925 | ```go 926 | u, err := getUser(id) 927 | if err != nil { 928 | return fmt.Errorf("get user %q: %w", id, err) 929 | } 930 | ``` 931 | 932 | |
| 934 | 935 | **良い例**: エラーをログに出力し、処理を継続する。 936 | 937 | もしその処理が絶対必要でないなら、品質は下がりますが復旧して処理を続けることができます。 938 | | 939 | 940 | ```go 941 | if err := emitMetrics(); err != nil { 942 | // メトリクスの書き出し失敗は処理を止めるほどではない 943 | log.Printf("Could not emit metrics: %v", err) 944 | } 945 | 946 | ``` 947 | 948 | |
| 950 | 951 | **良い例**: エラーマッチさせて処理を継続する。 952 | 953 | もし呼び出し元がエラーを定義していて、そのエラーが復旧可能なら、エラーを確認して処理を継続しましょう。 954 | その他のエラーだった場合はエラーをラップして返しましょう。 955 | 956 | ラップされたエラーは上位の呼び出し元で処理させましょう。 957 | | 958 | 959 | ```go 960 | tz, err := getUserTimeZone(id) 961 | if err != nil { 962 | if errors.Is(err, ErrUserNotFound) { 963 | // もしユーザーがみつからないなら UTC を使う 964 | tz = time.UTC 965 | } else { 966 | return fmt.Errorf("get user %q: %w", id, err) 967 | } 968 | } 969 | ``` 970 | 971 | |
| Bad | Good |
|---|---|
| 982 | 983 | ```go 984 | t := i.(string) 985 | ``` 986 | 987 | | 988 | 989 | ```go 990 | t, ok := i.(string) 991 | if !ok { 992 | // 安全にエラーを処理する 993 | } 994 | ``` 995 | 996 | |
| Bad | Good |
|---|---|
|
1008 |
1009 | ```go
1010 | func foo(bar string) {
1011 | if len(bar) == 0 {
1012 | panic("bar must not be empty")
1013 | }
1014 | // ...
1015 | }
1016 |
1017 | func main() {
1018 | if len(os.Args) != 2 {
1019 | fmt.Println("USAGE: foo |
1027 |
1028 | ```go
1029 | func foo(bar string) error {
1030 | if len(bar) == 0 {
1031 | return errors.New("bar must not be empty")
1032 | }
1033 | // ...
1034 | return nil
1035 | }
1036 |
1037 | func main() {
1038 | if len(os.Args) != 2 {
1039 | fmt.Println("USAGE: foo |
| Bad | Good |
|---|---|
| 1066 | 1067 | ```go 1068 | // func TestFoo(t *testing.T) 1069 | 1070 | f, err := ioutil.TempFile("", "test") 1071 | if err != nil { 1072 | panic("failed to set up test") 1073 | } 1074 | ``` 1075 | 1076 | | 1077 | 1078 | ```go 1079 | // func TestFoo(t *testing.T) 1080 | 1081 | f, err := ioutil.TempFile("", "test") 1082 | if err != nil { 1083 | t.Fatal("failed to set up test") 1084 | } 1085 | ``` 1086 | 1087 | |
| Bad | Good |
|---|---|
| 1102 | 1103 | ```go 1104 | type foo struct { 1105 | running int32 // アトミックな操作が必要な変数 1106 | } 1107 | 1108 | func (f* foo) start() { 1109 | if atomic.SwapInt32(&f.running, 1) == 1 { 1110 | // すでに実行中 1111 | return 1112 | } 1113 | // Fooを開始 1114 | } 1115 | 1116 | func (f *foo) isRunning() bool { 1117 | return f.running == 1 // 競合条件! --> 別スレッドから実行されたatomic.SwapInt32による値の更新が見えないことが起こりうる 1118 | } 1119 | ``` 1120 | 1121 | | 1122 | 1123 | ```go 1124 | type foo struct { 1125 | running atomic.Bool 1126 | } 1127 | 1128 | func (f *foo) start() { 1129 | if f.running.Swap(true) { 1130 | // すでに実行中 1131 | return 1132 | } 1133 | // Fooを開始 1134 | } 1135 | 1136 | func (f *foo) isRunning() bool { 1137 | return f.running.Load() // 読み出し操作がアトミックなため決定論的な振る舞いにになる(実はこの振る舞いはGoのメモリバリア指定がデフォルトSeqCstであることに依存するが、本項では深く触れない) 1138 | } 1139 | ``` 1140 | 1141 | |
| Bad | Good |
|---|---|
| 1153 | 1154 | ```go 1155 | // sign.go 1156 | 1157 | var _timeNow = time.Now 1158 | 1159 | func sign(msg string) string { 1160 | now := _timeNow() 1161 | return signWithTime(msg, now) 1162 | } 1163 | ``` 1164 | 1165 | | 1166 | 1167 | ```go 1168 | // sign.go 1169 | 1170 | type signer struct { 1171 | now func() time.Time 1172 | } 1173 | 1174 | func newSigner() *signer { 1175 | return &signer{ 1176 | now: time.Now, 1177 | } 1178 | } 1179 | 1180 | func (s *signer) Sign(msg string) string { 1181 | now := s.now() 1182 | return signWithTime(msg, now) 1183 | } 1184 | ``` 1185 | |
| 1187 | 1188 | ```go 1189 | // sign_test.go 1190 | 1191 | func TestSign(t *testing.T) { 1192 | oldTimeNow := _timeNow 1193 | _timeNow = func() time.Time { 1194 | return someFixedTime 1195 | } 1196 | defer func() { _timeNow = oldTimeNow }() 1197 | 1198 | assert.Equal(t, want, sign(give)) 1199 | } 1200 | ``` 1201 | 1202 | | 1203 | 1204 | ```go 1205 | // sign_test.go 1206 | 1207 | func TestSigner(t *testing.T) { 1208 | s := newSigner() 1209 | s.now = func() time.Time { 1210 | return someFixedTime 1211 | } 1212 | 1213 | assert.Equal(t, want, s.Sign(give)) 1214 | } 1215 | ``` 1216 | 1217 | |
| Bad | Good |
|---|---|
| 1245 | 1246 | ```go 1247 | // ConcreteList is a list of entities. 1248 | type ConcreteList struct { 1249 | *AbstractList 1250 | } 1251 | ``` 1252 | 1253 | | 1254 | 1255 | ```go 1256 | // ConcreteList is a list of entities. 1257 | type ConcreteList struct { 1258 | list *AbstractList 1259 | } 1260 | 1261 | // Add adds an entity to the list. 1262 | func (l *ConcreteList) Add(e Entity) { 1263 | return l.list.Add(e) 1264 | } 1265 | 1266 | // Remove removes an entity from the list. 1267 | func (l *ConcreteList) Remove(e Entity) { 1268 | return l.list.Remove(e) 1269 | } 1270 | ``` 1271 | 1272 | |
| Bad | Good |
|---|---|
| 1294 | 1295 | ```go 1296 | // AbstractList is a generalized implementation 1297 | // for various kinds of lists of entities. 1298 | type AbstractList interface { 1299 | Add(Entity) 1300 | Remove(Entity) 1301 | } 1302 | 1303 | // ConcreteList is a list of entities. 1304 | type ConcreteList struct { 1305 | AbstractList 1306 | } 1307 | ``` 1308 | 1309 | | 1310 | 1311 | ```go 1312 | // ConcreteList is a list of entities. 1313 | type ConcreteList struct { 1314 | list *AbstractList 1315 | } 1316 | 1317 | // Add adds an entity to the list. 1318 | func (l *ConcreteList) Add(e Entity) { 1319 | return l.list.Add(e) 1320 | } 1321 | 1322 | // Remove removes an entity from the list. 1323 | func (l *ConcreteList) Remove(e Entity) { 1324 | return l.list.Remove(e) 1325 | } 1326 | ``` 1327 | 1328 | |
| Bad | Good |
|---|---|
| 1353 | 1354 | ```go 1355 | var error string 1356 | // `error` はビルトインの型を隠す 1357 | 1358 | // or 1359 | 1360 | func handleErrorMessage(error string) { 1361 | // `error` はビルトインの型を隠す 1362 | } 1363 | ``` 1364 | 1365 | | 1366 | 1367 | ```go 1368 | var errorMessage string 1369 | // `error` はビルトインの型のまま 1370 | 1371 | // or 1372 | 1373 | func handleErrorMessage(msg string) { 1374 | // `error` はビルトインの型のまま 1375 | } 1376 | ``` 1377 | 1378 | |
| 1380 | 1381 | ```go 1382 | type Foo struct { 1383 | // これらのフィールドは 1384 | // 技術的にはシャドウイングを引き起こしませんが、 1385 | // `error` や `string` という文字列は曖昧です。 1386 | error error 1387 | string string 1388 | } 1389 | 1390 | func (f Foo) Error() error { 1391 | // `error` と `f.error` は見た目が似ている 1392 | return f.error 1393 | } 1394 | 1395 | func (f Foo) String() string { 1396 | // `string` と `f.string` は見た目が似ている 1397 | return f.string 1398 | } 1399 | ``` 1400 | 1401 | | 1402 | 1403 | ```go 1404 | type Foo struct { 1405 | // `error` や `string` という文字列は明確に型名を指します 1406 | err error 1407 | str string 1408 | } 1409 | 1410 | func (f Foo) Error() error { 1411 | return f.err 1412 | } 1413 | 1414 | func (f Foo) String() string { 1415 | return f.str 1416 | } 1417 | ``` 1418 | 1419 | |
| Bad | Good |
|---|---|
| 1441 | 1442 | ```go 1443 | type Foo struct { 1444 | // ... 1445 | } 1446 | 1447 | var _defaultFoo Foo 1448 | 1449 | func init() { 1450 | _defaultFoo = Foo{ 1451 | // ... 1452 | } 1453 | } 1454 | ``` 1455 | 1456 | | 1457 | 1458 | ```go 1459 | var _defaultFoo = Foo{ 1460 | // ... 1461 | } 1462 | 1463 | // もしくはテスト可能性に配慮してこのようにします 1464 | 1465 | var _defaultFoo = defaultFoo() 1466 | 1467 | func defaultFoo() Foo { 1468 | return Foo{ 1469 | // ... 1470 | } 1471 | } 1472 | ``` 1473 | 1474 | |
| 1476 | 1477 | ```go 1478 | type Config struct { 1479 | // ... 1480 | } 1481 | 1482 | var _config Config 1483 | 1484 | func init() { 1485 | // 悪い例: 現在のディレクトリに依存している 1486 | cwd, _ := os.Getwd() 1487 | 1488 | // 悪い例: I/O 1489 | raw, _ := os.ReadFile( 1490 | path.Join(cwd, "config", "config.yaml"), 1491 | ) 1492 | 1493 | yaml.Unmarshal(raw, &_config) 1494 | } 1495 | ``` 1496 | 1497 | | 1498 | 1499 | ```go 1500 | type Config struct { 1501 | // ... 1502 | } 1503 | 1504 | func loadConfig() Config { 1505 | cwd, err := os.Getwd() 1506 | // handle err 1507 | 1508 | raw, err := os.ReadFile( 1509 | path.Join(cwd, "config", "config.yaml"), 1510 | ) 1511 | // handle err 1512 | 1513 | var config Config 1514 | yaml.Unmarshal(raw, &config) 1515 | 1516 | return config 1517 | } 1518 | ``` 1519 | 1520 | |
| Bad | Good |
|---|---|
| 1538 | 1539 | ```go 1540 | func main() { 1541 | body := readFile(path) 1542 | fmt.Println(body) 1543 | } 1544 | 1545 | func readFile(path string) string { 1546 | f, err := os.Open(path) 1547 | if err != nil { 1548 | log.Fatal(err) 1549 | } 1550 | 1551 | b, err := io.ReadAll(f) 1552 | if err != nil { 1553 | log.Fatal(err) 1554 | } 1555 | 1556 | return string(b) 1557 | } 1558 | ``` 1559 | 1560 | | 1561 | 1562 | ```go 1563 | func main() { 1564 | body, err := readFile(path) 1565 | if err != nil { 1566 | log.Fatal(err) 1567 | } 1568 | fmt.Println(body) 1569 | } 1570 | 1571 | func readFile(path string) (string, error) { 1572 | f, err := os.Open(path) 1573 | if err != nil { 1574 | return "", err 1575 | } 1576 | 1577 | b, err := io.ReadAll(f) 1578 | if err != nil { 1579 | return "", err 1580 | } 1581 | 1582 | return string(b), nil 1583 | } 1584 | ``` 1585 | 1586 | |
| Bad | Good |
|---|---|
| 1605 | 1606 | ```go 1607 | package main 1608 | 1609 | func main() { 1610 | args := os.Args[1:] 1611 | if len(args) != 1 { 1612 | log.Fatal("missing file") 1613 | } 1614 | name := args[0] 1615 | 1616 | f, err := os.Open(name) 1617 | if err != nil { 1618 | log.Fatal(err) 1619 | } 1620 | defer f.Close() 1621 | 1622 | // もしここで log.Fatal を呼ぶと、 1623 | // f.Close は実行されません。 1624 | 1625 | b, err := io.ReadAll(f) 1626 | if err != nil { 1627 | log.Fatal(err) 1628 | } 1629 | 1630 | // ... 1631 | } 1632 | ``` 1633 | 1634 | | 1635 | 1636 | ```go 1637 | package main 1638 | 1639 | func main() { 1640 | if err := run(); err != nil { 1641 | log.Fatal(err) 1642 | } 1643 | } 1644 | 1645 | func run() error { 1646 | args := os.Args[1:] 1647 | if len(args) != 1 { 1648 | return errors.New("missing file") 1649 | } 1650 | name := args[0] 1651 | 1652 | f, err := os.Open(name) 1653 | if err != nil { 1654 | return err 1655 | } 1656 | defer f.Close() 1657 | 1658 | b, err := io.ReadAll(f) 1659 | if err != nil { 1660 | return err 1661 | } 1662 | 1663 | // ... 1664 | } 1665 | ``` 1666 | 1667 | |
| Bad | Good |
|---|---|
| 1678 | 1679 | ```go 1680 | type Stock struct { 1681 | Price int 1682 | Name string 1683 | } 1684 | 1685 | bytes, err := json.Marshal(Stock{ 1686 | Price: 137, 1687 | Name: "UBER", 1688 | }) 1689 | ``` 1690 | 1691 | | 1692 | 1693 | ```go 1694 | type Stock struct { 1695 | Price int `json:"price"` 1696 | Name string `json:"name"` 1697 | // 安全に Name フィールドを name に変換できる 1698 | } 1699 | 1700 | bytes, err := json.Marshal(Stock{ 1701 | Price: 137, 1702 | Name: "UBER", 1703 | }) 1704 | ``` 1705 | 1706 | |
| Bad | Good |
|---|---|
| 1734 | 1735 | ```go 1736 | go func() { 1737 | for { 1738 | flush() 1739 | time.Sleep(delay) 1740 | } 1741 | }() 1742 | ``` 1743 | 1744 | | 1745 | 1746 | ```go 1747 | var ( 1748 | stop = make(chan struct{}) // ゴルーチンに停止を伝える 1749 | done = make(chan struct{}) // ゴルーチンが停止したことを伝える 1750 | ) 1751 | go func() { 1752 | defer close(done) 1753 | 1754 | ticker := time.NewTicker(delay) 1755 | defer ticker.Stop() 1756 | for { 1757 | select { 1758 | case <-ticker.C: 1759 | flush() 1760 | case <-stop: 1761 | return 1762 | } 1763 | } 1764 | }() 1765 | 1766 | // Elsewhere... 1767 | close(stop) // ゴルーチンに停止シグナルを送る 1768 | <-done // そしてゴルーチンが止まるのを待つ 1769 | ``` 1770 | 1771 | |
| 1773 | 1774 | ゴルーチンを止める方法は無い。プログラムが終了するまで残り続ける 1775 | 1776 | | 1777 | 1778 | ゴルーチンは `close(stop)` で停止できる。そして `<-done` で待つこともできる。 1779 | 1780 | |
| Bad | Good |
|---|---|
| 1827 | 1828 | ```go 1829 | func init() { 1830 | go doWork() 1831 | } 1832 | 1833 | func doWork() { 1834 | for { 1835 | // ... 1836 | } 1837 | } 1838 | ``` 1839 | 1840 | | 1841 | 1842 | ```go 1843 | type Worker struct{ /* ... */ } 1844 | 1845 | func NewWorker(...) *Worker { 1846 | w := &Worker{ 1847 | stop: make(chan struct{}), 1848 | done: make(chan struct{}), 1849 | // ... 1850 | } 1851 | go w.doWork() 1852 | } 1853 | 1854 | func (w *Worker) doWork() { 1855 | defer close(w.done) 1856 | for { 1857 | // ... 1858 | case <-w.stop: 1859 | return 1860 | } 1861 | } 1862 | 1863 | // Shutdown はワーカーに終了を伝え、 1864 | // ワーカーが終了するのを待ちます。 1865 | func (w *Worker) Shutdown() { 1866 | close(w.stop) 1867 | <-w.done 1868 | } 1869 | ``` 1870 | 1871 | |
| 1873 | 1874 | ユーザーがこのパッケージを公開すると、ゴルーチンを無条件に作成し、止める方法はありません。 1875 | 1876 | | 1877 | 1878 | ユーザーがリクエストすると、ワーカーを起動します。`Shutdown` メソッドで、ワーカーを停止し使っているリソースを開放できる手段も提供しています。 1879 | 1880 | [Wait for goroutines to exit]( #wait-for-gorutines-to-exit ) でも話したように、ワーカーが複数ゴルーチンを使う場合は `WaitGroup` を使いましょう。 1881 | 1882 | |
| Bad | Good |
|---|---|
| 1896 | 1897 | ```go 1898 | for i := 0; i < b.N; i++ { 1899 | s := fmt.Sprint(rand.Int()) 1900 | } 1901 | ``` 1902 | 1903 | | 1904 | 1905 | ```go 1906 | for i := 0; i < b.N; i++ { 1907 | s := strconv.Itoa(rand.Int()) 1908 | } 1909 | ``` 1910 | 1911 | |
| 1913 | 1914 | ``` 1915 | BenchmarkFmtSprint-4 143 ns/op 2 allocs/op 1916 | ``` 1917 | 1918 | | 1919 | 1920 | ``` 1921 | BenchmarkStrconv-4 64.2 ns/op 1 allocs/op 1922 | ``` 1923 | 1924 | |
| Bad | Good |
|---|---|
| 1935 | 1936 | ```go 1937 | for i := 0; i < b.N; i++ { 1938 | w.Write([]byte("Hello world")) 1939 | } 1940 | ``` 1941 | 1942 | | 1943 | 1944 | ```go 1945 | data := []byte("Hello world") 1946 | for i := 0; i < b.N; i++ { 1947 | w.Write(data) 1948 | } 1949 | ``` 1950 | 1951 | |
| 1953 | 1954 | ``` 1955 | BenchmarkBad-4 50000000 22.2 ns/op 1956 | ``` 1957 | 1958 | | 1959 | 1960 | ``` 1961 | BenchmarkGood-4 500000000 3.25 ns/op 1962 | ``` 1963 | 1964 | |
| Bad | Good |
|---|---|
| 1983 | 1984 | ```go 1985 | m := make(map[string]os.FileInfo) 1986 | files, _ := ioutil.ReadDir("./files") 1987 | for _, f := range files { 1988 | m[f.Name()] = f 1989 | } 1990 | ``` 1991 | 1992 | | 1993 | 1994 | ```go 1995 | files, _ := ioutil.ReadDir("./files") 1996 | m := make(map[string]os.FileInfo, len(files)) 1997 | for _, f := range files { 1998 | m[f.Name()] = f 1999 | } 2000 | ``` 2001 | 2002 | |
| 2004 | 2005 | `m` は初期化時にサイズのヒントが与えられませんでした。 2006 | そのため余計にアロケーションが発生する可能性があります。 2007 | 2008 | | 2009 | 2010 | `m` にはサイズのヒントが与えられています。 2011 | 要素の追加時にアロケーションの回数を押さえられます。 2012 | 2013 | |
| Bad | Good |
|---|---|
| 2046 | 2047 | ```go 2048 | import "a" 2049 | import "b" 2050 | ``` 2051 | 2052 | | 2053 | 2054 | ```go 2055 | import ( 2056 | "a" 2057 | "b" 2058 | ) 2059 | ``` 2060 | 2061 | |
| Bad | Good |
|---|---|
| 2070 | 2071 | ```go 2072 | 2073 | const a = 1 2074 | const b = 2 2075 | 2076 | 2077 | 2078 | var a = 1 2079 | var b = 2 2080 | 2081 | 2082 | 2083 | type Area float64 2084 | type Volume float64 2085 | ``` 2086 | 2087 | | 2088 | 2089 | ```go 2090 | const ( 2091 | a = 1 2092 | b = 2 2093 | ) 2094 | 2095 | var ( 2096 | a = 1 2097 | b = 2 2098 | ) 2099 | 2100 | type ( 2101 | Area float64 2102 | Volume float64 2103 | ) 2104 | ``` 2105 | 2106 | |
| Bad | Good |
|---|---|
| 2116 | 2117 | ```go 2118 | type Operation int 2119 | 2120 | const ( 2121 | Add Operation = iota + 1 2122 | Subtract 2123 | Multiply 2124 | ENV_VAR = "MY_ENV" 2125 | ) 2126 | ``` 2127 | 2128 | | 2129 | 2130 | ```go 2131 | type Operation int 2132 | 2133 | const ( 2134 | Add Operation = iota + 1 2135 | Subtract 2136 | Multiply 2137 | ) 2138 | 2139 | const ENV_VAR = "MY_ENV" 2140 | ``` 2141 | 2142 | |
| Bad | Good |
|---|---|
| 2151 | 2152 | ```go 2153 | func f() string { 2154 | var red = color.New(0xff0000) 2155 | var green = color.New(0x00ff00) 2156 | var blue = color.New(0x0000ff) 2157 | 2158 | ... 2159 | } 2160 | ``` 2161 | 2162 | | 2163 | 2164 | ```go 2165 | func f() string { 2166 | var ( 2167 | red = color.New(0xff0000) 2168 | green = color.New(0x00ff00) 2169 | blue = color.New(0x0000ff) 2170 | ) 2171 | 2172 | ... 2173 | } 2174 | ``` 2175 | 2176 | |
| Bad | Good |
|---|---|
| 2191 | 2192 | ```go 2193 | import ( 2194 | "fmt" 2195 | "os" 2196 | "go.uber.org/atomic" 2197 | "golang.org/x/sync/errgroup" 2198 | ) 2199 | ``` 2200 | 2201 | | 2202 | 2203 | ```go 2204 | import ( 2205 | "fmt" 2206 | "os" 2207 | 2208 | "go.uber.org/atomic" 2209 | "golang.org/x/sync/errgroup" 2210 | ) 2211 | ``` 2212 | 2213 | |
| Bad | Good |
|---|---|
| 2251 | 2252 | ```go 2253 | import ( 2254 | "fmt" 2255 | "os" 2256 | 2257 | 2258 | nettrace "golang.net/x/trace" 2259 | ) 2260 | ``` 2261 | 2262 | | 2263 | 2264 | ```go 2265 | import ( 2266 | "fmt" 2267 | "os" 2268 | "runtime/trace" 2269 | 2270 | nettrace "golang.net/x/trace" 2271 | ) 2272 | ``` 2273 | 2274 | |
| Bad | Good |
|---|---|
| 2293 | 2294 | ```go 2295 | func (s *something) Cost() { 2296 | return calcCost(s.weights) 2297 | } 2298 | 2299 | type something struct{ ... } 2300 | 2301 | func calcCost(n []int) int {...} 2302 | 2303 | func (s *something) Stop() {...} 2304 | 2305 | func newSomething() *something { 2306 | return &something{} 2307 | } 2308 | ``` 2309 | 2310 | | 2311 | 2312 | ```go 2313 | type something struct{ ... } 2314 | 2315 | func newSomething() *something { 2316 | return &something{} 2317 | } 2318 | 2319 | func (s *something) Cost() { 2320 | return calcCost(s.weights) 2321 | } 2322 | 2323 | func (s *something) Stop() {...} 2324 | 2325 | func calcCost(n []int) int {...} 2326 | ``` 2327 | 2328 | |
| Bad | Good |
|---|---|
| 2339 | 2340 | ```go 2341 | for _, v := range data { 2342 | if v.F1 == 1 { 2343 | v = process(v) 2344 | if err := v.Call(); err == nil { 2345 | v.Send() 2346 | } else { 2347 | return err 2348 | } 2349 | } else { 2350 | log.Printf("Invalid v: %v", v) 2351 | } 2352 | } 2353 | ``` 2354 | 2355 | | 2356 | 2357 | ```go 2358 | for _, v := range data { 2359 | if v.F1 != 1 { 2360 | log.Printf("Invalid v: %v", v) 2361 | continue 2362 | } 2363 | 2364 | v = process(v) 2365 | if err := v.Call(); err != nil { 2366 | return err 2367 | } 2368 | v.Send() 2369 | } 2370 | ``` 2371 | 2372 | |
| Bad | Good |
|---|---|
| 2382 | 2383 | ```go 2384 | var a int 2385 | if b { 2386 | a = 100 2387 | } else { 2388 | a = 10 2389 | } 2390 | ``` 2391 | 2392 | | 2393 | 2394 | ```go 2395 | a := 10 2396 | if b { 2397 | a = 100 2398 | } 2399 | ``` 2400 | 2401 | |
| Bad | Good |
|---|---|
| 2411 | 2412 | ```go 2413 | var _s string = F() 2414 | 2415 | func F() string { return "A" } 2416 | ``` 2417 | 2418 | | 2419 | 2420 | ```go 2421 | var _s = F() 2422 | // Since F already states that it returns a string, we don't need to specify 2423 | // the type again. 2424 | 2425 | func F() string { return "A" } 2426 | ``` 2427 | 2428 | |
| Bad | Good |
|---|---|
| 2453 | 2454 | ```go 2455 | // foo.go 2456 | 2457 | const ( 2458 | defaultPort = 8080 2459 | defaultUser = "user" 2460 | ) 2461 | 2462 | // bar.go 2463 | 2464 | func Bar() { 2465 | defaultPort := 9090 2466 | ... 2467 | fmt.Println("Default port", defaultPort) 2468 | 2469 | // We will not see a compile error if the first line of 2470 | // Bar() is deleted. 2471 | } 2472 | ``` 2473 | 2474 | | 2475 | 2476 | ```go 2477 | // foo.go 2478 | 2479 | const ( 2480 | _defaultPort = 8080 2481 | _defaultUser = "user" 2482 | ) 2483 | ``` 2484 | 2485 | |
| Bad | Good |
|---|---|
| 2497 | 2498 | ```go 2499 | type Client struct { 2500 | version int 2501 | http.Client 2502 | } 2503 | ``` 2504 | 2505 | | 2506 | 2507 | ```go 2508 | type Client struct { 2509 | http.Client 2510 | 2511 | version int 2512 | } 2513 | ``` 2514 | 2515 | |
| Bad | Good |
|---|---|
| 2545 | 2546 | ```go 2547 | type A struct { 2548 | // 悪い例: 2549 | // A.Lock() と A.Unlock() が 2550 | // 使えますが、メリットはありません。 2551 | // さらに、A の内部を操作できる 2552 | // ようになってしまいます。 2553 | sync.Mutex 2554 | } 2555 | ``` 2556 | 2557 | | 2558 | 2559 | ```go 2560 | type countingWriteCloser struct { 2561 | // 良い例: 2562 | // Write() は特定の目的のために 2563 | // 外側のレイヤーに提供されます。 2564 | // そして、内部の型の Write() メソッドに 2565 | // 役割を移譲しています。 2566 | io.WriteCloser 2567 | 2568 | count int 2569 | } 2570 | 2571 | func (w *countingWriteCloser) Write(bs []byte) (int, error) { 2572 | w.count += len(bs) 2573 | return w.WriteCloser.Write(bs) 2574 | } 2575 | ``` 2576 | 2577 | |
| 2579 | 2580 | ```go 2581 | type Book struct { 2582 | // 悪い例: 2583 | // ポインタなのでゼロ値の便利さを消してしまう 2584 | io.ReadWriter 2585 | 2586 | // other fields 2587 | } 2588 | 2589 | // later 2590 | 2591 | var b Book 2592 | b.Read(...) // panic: nil pointer 2593 | b.String() // panic: nil pointer 2594 | b.Write(...) // panic: nil pointer 2595 | ``` 2596 | 2597 | | 2598 | 2599 | ```go 2600 | type Book struct { 2601 | // 良い例: 2602 | // 便利なゼロ値を持っている 2603 | bytes.Buffer 2604 | 2605 | // other fields 2606 | } 2607 | 2608 | // later 2609 | 2610 | var b Book 2611 | b.Read(...) // ok 2612 | b.String() // ok 2613 | b.Write(...) // ok 2614 | ``` 2615 | 2616 | |
| 2618 | 2619 | ```go 2620 | type Client struct { 2621 | sync.Mutex 2622 | sync.WaitGroup 2623 | bytes.Buffer 2624 | url.URL 2625 | } 2626 | ``` 2627 | 2628 | | 2629 | 2630 | ```go 2631 | type Client struct { 2632 | mtx sync.Mutex 2633 | wg sync.WaitGroup 2634 | buf bytes.Buffer 2635 | url url.URL 2636 | } 2637 | ``` 2638 | 2639 | |
| Bad | Good |
|---|---|
| 2648 | 2649 | ```go 2650 | var s = "foo" 2651 | ``` 2652 | 2653 | | 2654 | 2655 | ```go 2656 | s := "foo" 2657 | ``` 2658 | 2659 | |
| Bad | Good |
|---|---|
| 2668 | 2669 | ```go 2670 | func f(list []int) { 2671 | filtered := []int{} 2672 | for _, v := range list { 2673 | if v > 10 { 2674 | filtered = append(filtered, v) 2675 | } 2676 | } 2677 | } 2678 | ``` 2679 | 2680 | | 2681 | 2682 | ```go 2683 | func f(list []int) { 2684 | var filtered []int 2685 | for _, v := range list { 2686 | if v > 10 { 2687 | filtered = append(filtered, v) 2688 | } 2689 | } 2690 | } 2691 | ``` 2692 | 2693 | |
| Bad | Good |
|---|---|
| 2705 | 2706 | ```go 2707 | if x == "" { 2708 | return []int{} 2709 | } 2710 | ``` 2711 | 2712 | | 2713 | 2714 | ```go 2715 | if x == "" { 2716 | return nil 2717 | } 2718 | ``` 2719 | 2720 | |
| Bad | Good |
|---|---|
| 2728 | 2729 | ```go 2730 | func isEmpty(s []string) bool { 2731 | return s == nil 2732 | } 2733 | ``` 2734 | 2735 | | 2736 | 2737 | ```go 2738 | func isEmpty(s []string) bool { 2739 | return len(s) == 0 2740 | } 2741 | ``` 2742 | 2743 | |
| Bad | Good |
|---|---|
| 2751 | 2752 | ```go 2753 | nums := []int{} 2754 | // or, nums := make([]int) 2755 | 2756 | if add1 { 2757 | nums = append(nums, 1) 2758 | } 2759 | 2760 | if add2 { 2761 | nums = append(nums, 2) 2762 | } 2763 | ``` 2764 | 2765 | | 2766 | 2767 | ```go 2768 | var nums []int 2769 | 2770 | if add1 { 2771 | nums = append(nums, 1) 2772 | } 2773 | 2774 | if add2 { 2775 | nums = append(nums, 2) 2776 | } 2777 | ``` 2778 | 2779 | |
| Bad | Good |
|---|---|
| 2789 | 2790 | ```go 2791 | err := ioutil.WriteFile(name, data, 0644) 2792 | if err != nil { 2793 | return err 2794 | } 2795 | ``` 2796 | 2797 | | 2798 | 2799 | ```go 2800 | if err := ioutil.WriteFile(name, data, 0644); err != nil { 2801 | return err 2802 | } 2803 | ``` 2804 | 2805 | |
| Bad | Good |
|---|---|
| 2814 | 2815 | ```go 2816 | if data, err := ioutil.ReadFile(name); err == nil { 2817 | err = cfg.Decode(data) 2818 | if err != nil { 2819 | return err 2820 | } 2821 | 2822 | fmt.Println(cfg) 2823 | return nil 2824 | } else { 2825 | return err 2826 | } 2827 | ``` 2828 | 2829 | | 2830 | 2831 | ```go 2832 | data, err := ioutil.ReadFile(name) 2833 | if err != nil { 2834 | return err 2835 | } 2836 | 2837 | if err := cfg.Decode(data); err != nil { 2838 | return err 2839 | } 2840 | 2841 | fmt.Println(cfg) 2842 | return nil 2843 | ``` 2844 | 2845 | |
| Bad | Good |
|---|---|
| 2856 | 2857 | ```go 2858 | // func printInfo(name string, isLocal, done bool) 2859 | 2860 | printInfo("foo", true, true) 2861 | ``` 2862 | 2863 | | 2864 | 2865 | ```go 2866 | // func printInfo(name string, isLocal, done bool) 2867 | 2868 | printInfo("foo", true /* isLocal */, true /* done */) 2869 | ``` 2870 | 2871 | |
| Bad | Good |
|---|---|
| 2904 | 2905 | ```go 2906 | wantError := "unknown name:\"test\"" 2907 | ``` 2908 | 2909 | | 2910 | 2911 | ```go 2912 | wantError := `unknown error:"test"` 2913 | ``` 2914 | 2915 | |
| Bad | Good |
|---|---|
| 2929 | 2930 | ```go 2931 | k := User{"John", "Doe", true} 2932 | ``` 2933 | 2934 | | 2935 | 2936 | ```go 2937 | k := User{ 2938 | FirstName: "John", 2939 | LastName: "Doe", 2940 | Admin: true, 2941 | } 2942 | ``` 2943 | 2944 | |
| Bad | Good |
|---|---|
| 2966 | 2967 | ```go 2968 | user := User{ 2969 | FirstName: "John", 2970 | LastName: "Doe", 2971 | MiddleName: "", 2972 | Admin: false, 2973 | } 2974 | ``` 2975 | 2976 | | 2977 | 2978 | ```go 2979 | user := User{ 2980 | FirstName: "John", 2981 | LastName: "Doe", 2982 | } 2983 | ``` 2984 | 2985 | |
| Bad | Good |
|---|---|
| 3001 | 3002 | ```go 3003 | user := User{} 3004 | ``` 3005 | 3006 | | 3007 | 3008 | ```go 3009 | var user User 3010 | ``` 3011 | 3012 | |
| Bad | Good |
|---|---|
| 3024 | 3025 | ```go 3026 | sval := T{Name: "foo"} 3027 | 3028 | // inconsistent 3029 | sptr := new(T) 3030 | sptr.Name = "bar" 3031 | ``` 3032 | 3033 | | 3034 | 3035 | ```go 3036 | sval := T{Name: "foo"} 3037 | 3038 | sptr := &T{Name: "bar"} 3039 | ``` 3040 | 3041 | |
| Bad | Good |
|---|---|
| 3052 | 3053 | ```go 3054 | var ( 3055 | // m1 is safe to read and write; 3056 | // m2 will panic on writes. 3057 | m1 = map[T1]T2{} 3058 | m2 map[T1]T2 3059 | ) 3060 | ``` 3061 | 3062 | | 3063 | 3064 | ```go 3065 | var ( 3066 | // m1 is safe to read and write; 3067 | // m2 will panic on writes. 3068 | m1 = make(map[T1]T2) 3069 | m2 map[T1]T2 3070 | ) 3071 | ``` 3072 | 3073 | |
| 3075 | 3076 | 変数宣言と初期化が視覚的に似ている 3077 | 3078 | | 3079 | 3080 | 変数宣言と初期化が視覚的に区別しやすい 3081 | 3082 | |
| Bad | Good |
|---|---|
| 3094 | 3095 | ```go 3096 | m := make(map[T1]T2, 3) 3097 | m[k1] = v1 3098 | m[k2] = v2 3099 | m[k3] = v3 3100 | ``` 3101 | 3102 | | 3103 | 3104 | ```go 3105 | m := map[T1]T2{ 3106 | k1: v1, 3107 | k2: v2, 3108 | k3: v3, 3109 | } 3110 | ``` 3111 | 3112 | |
| Bad | Good |
|---|---|
| 3125 | 3126 | ```go 3127 | msg := "unexpected values %v, %v\n" 3128 | fmt.Printf(msg, 1, 2) 3129 | ``` 3130 | 3131 | | 3132 | 3133 | ```go 3134 | const msg = "unexpected values %v, %v\n" 3135 | fmt.Printf(msg, 1, 2) 3136 | ``` 3137 | 3138 | |
| Bad | Good |
|---|---|
| 3165 | 3166 | ```go 3167 | // func TestSplitHostPort(t *testing.T) 3168 | 3169 | host, port, err := net.SplitHostPort("192.0.2.0:8000") 3170 | require.NoError(t, err) 3171 | assert.Equal(t, "192.0.2.0", host) 3172 | assert.Equal(t, "8000", port) 3173 | 3174 | host, port, err = net.SplitHostPort("192.0.2.0:http") 3175 | require.NoError(t, err) 3176 | assert.Equal(t, "192.0.2.0", host) 3177 | assert.Equal(t, "http", port) 3178 | 3179 | host, port, err = net.SplitHostPort(":8000") 3180 | require.NoError(t, err) 3181 | assert.Equal(t, "", host) 3182 | assert.Equal(t, "8000", port) 3183 | 3184 | host, port, err = net.SplitHostPort("1:8") 3185 | require.NoError(t, err) 3186 | assert.Equal(t, "1", host) 3187 | assert.Equal(t, "8", port) 3188 | ``` 3189 | 3190 | | 3191 | 3192 | ```go 3193 | // func TestSplitHostPort(t *testing.T) 3194 | 3195 | tests := []struct{ 3196 | give string 3197 | wantHost string 3198 | wantPort string 3199 | }{ 3200 | { 3201 | give: "192.0.2.0:8000", 3202 | wantHost: "192.0.2.0", 3203 | wantPort: "8000", 3204 | }, 3205 | { 3206 | give: "192.0.2.0:http", 3207 | wantHost: "192.0.2.0", 3208 | wantPort: "http", 3209 | }, 3210 | { 3211 | give: ":8000", 3212 | wantHost: "", 3213 | wantPort: "8000", 3214 | }, 3215 | { 3216 | give: "1:8", 3217 | wantHost: "1", 3218 | wantPort: "8", 3219 | }, 3220 | } 3221 | 3222 | for _, tt := range tests { 3223 | t.Run(tt.give, func(t *testing.T) { 3224 | host, port, err := net.SplitHostPort(tt.give) 3225 | require.NoError(t, err) 3226 | assert.Equal(t, tt.wantHost, host) 3227 | assert.Equal(t, tt.wantPort, port) 3228 | }) 3229 | } 3230 | ``` 3231 | 3232 | |
| Bad | Good |
|---|---|
| 3286 | 3287 | ```go 3288 | func TestComplicatedTable(t *testing.T) { 3289 | tests := []struct { 3290 | give string 3291 | want string 3292 | wantErr error 3293 | shouldCallX bool 3294 | shouldCallY bool 3295 | giveXResponse string 3296 | giveXErr error 3297 | giveYResponse string 3298 | giveYErr error 3299 | }{ 3300 | // ... 3301 | } 3302 | 3303 | for _, tt := range tests { 3304 | t.Run(tt.give, func(t *testing.T) { 3305 | // setup mocks 3306 | ctrl := gomock.NewController(t) 3307 | xMock := xmock.NewMockX(ctrl) 3308 | if tt.shouldCallX { 3309 | xMock.EXPECT().Call().Return( 3310 | tt.giveXResponse, tt.giveXErr, 3311 | ) 3312 | } 3313 | yMock := ymock.NewMockY(ctrl) 3314 | if tt.shouldCallY { 3315 | yMock.EXPECT().Call().Return( 3316 | tt.giveYResponse, tt.giveYErr, 3317 | ) 3318 | } 3319 | 3320 | got, err := DoComplexThing(tt.give, xMock, yMock) 3321 | 3322 | // verify results 3323 | if tt.wantErr != nil { 3324 | require.EqualError(t, err, tt.wantErr) 3325 | return 3326 | } 3327 | require.NoError(t, err) 3328 | assert.Equal(t, want, got) 3329 | }) 3330 | } 3331 | } 3332 | ``` 3333 | 3334 | | 3335 | 3336 | ```go 3337 | func TestShouldCallX(t *testing.T) { 3338 | // setup mocks 3339 | ctrl := gomock.NewController(t) 3340 | xMock := xmock.NewMockX(ctrl) 3341 | xMock.EXPECT().Call().Return("XResponse", nil) 3342 | 3343 | yMock := ymock.NewMockY(ctrl) 3344 | 3345 | got, err := DoComplexThing("inputX", xMock, yMock) 3346 | 3347 | require.NoError(t, err) 3348 | assert.Equal(t, "want", got) 3349 | } 3350 | 3351 | func TestShouldCallYAndFail(t *testing.T) { 3352 | // setup mocks 3353 | ctrl := gomock.NewController(t) 3354 | xMock := xmock.NewMockX(ctrl) 3355 | 3356 | yMock := ymock.NewMockY(ctrl) 3357 | yMock.EXPECT().Call().Return("YResponse", nil) 3358 | 3359 | _, err := DoComplexThing("inputY", xMock, yMock) 3360 | assert.EqualError(t, err, "Y failed") 3361 | } 3362 | ``` 3363 | 3364 | |
| Bad | Good |
|---|---|
| 3405 | 3406 | ```go 3407 | // package db 3408 | 3409 | func Open( 3410 | addr string, 3411 | cache bool, 3412 | logger *zap.Logger 3413 | ) (*Connection, error) { 3414 | // ... 3415 | } 3416 | ``` 3417 | 3418 | | 3419 | 3420 | ```go 3421 | // package db 3422 | 3423 | type Option interface { 3424 | // ... 3425 | } 3426 | 3427 | func WithCache(c bool) Option { 3428 | // ... 3429 | } 3430 | 3431 | func WithLogger(log *zap.Logger) Option { 3432 | // ... 3433 | } 3434 | 3435 | // Open creates a connection. 3436 | func Open( 3437 | addr string, 3438 | opts ...Option, 3439 | ) (*Connection, error) { 3440 | // ... 3441 | } 3442 | ``` 3443 | 3444 | |
| 3446 | 3447 | キャッシュやロガーはデフォルトを使う場合でも常に指定する必要があります 3448 | 3449 | ```go 3450 | db.Open(addr, db.DefaultCache, zap.NewNop()) 3451 | db.Open(addr, db.DefaultCache, log) 3452 | db.Open(addr, false /* cache */, zap.NewNop()) 3453 | db.Open(addr, false /* cache */, log) 3454 | ``` 3455 | 3456 | | 3457 | 3458 | オプションは必要なら提供されます 3459 | 3460 | ```go 3461 | db.Open(addr) 3462 | db.Open(addr, db.WithLogger(log)) 3463 | db.Open(addr, db.WithCache(false)) 3464 | db.Open( 3465 | addr, 3466 | db.WithCache(false), 3467 | db.WithLogger(log), 3468 | ) 3469 | ``` 3470 | 3471 | |