forked from piotrplenik/clean-code-php
-
Notifications
You must be signed in to change notification settings - Fork 35
/
README.md
2045 lines (1566 loc) · 51.9 KB
/
README.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Clean Code PHP
## Mục lục
1. [Giới thiệu](#giới-thiệu)
2. [Biến](#biến)
* [Sử dụng tên biến có ý nghĩa và dễ hiểu](#sử-dụng-tên-biến-có-ý-nghĩa-và-dễ-hiểu)
* [Sử dụng cùng từ vựng cho cùng một loại biến](#sử-dụng-cùng-từ-vựng-cho-cùng-một-loại-biến)
* [Đặt tên sao cho dễ tìm kiếm (phần 1)](#Đặt-tên-sao-cho-dễ-tìm-kiếm-phần-1)
* [Đặt tên sao cho dễ tìm kiếm (phần 2)](#Đặt-tên-sao-cho-dễ-tìm-kiếm-phần-2)
* [Đặt tên biến có dễ hiểu](#đặt-tên-biến-dễ-hiểu)
* [Tránh lồng (nesting) quá nhiều và nên return sớm (phần 1)](#tránh-lồng-nesting-quá-nhiều-và-nên-return-sớm-phần-1)
* [Tránh lồng (nesting) quá nhiều và nên return sớm (phần 2)](#tránh-lồng-nesting-quá-nhiều-và-nên-return-sớm-phần-2)
* [Tránh hack não người đọc](#tránh-hack-não-người-đọc)
* [Đừng thêm những nội dung không cần thiết](#Đừng-thêm-những-nội-dung-không-cần-thiết)
* [Sử dụng đối số mặc định thay vì phải kiểm tra bằng biểu thức điều kiện](#sử-dụng-đối-số-mặc-định-thay-vì-phải-kiểm-tra-bằng-biểu-thức-điều-kiện)
3. [So sánh](#so-sánh)
* [Sử dụng identical comparison](#sử-dụng-identical-comparison)
4. [Hàm](#hàm)
* [Đối số của hàm (ít hơn hoặc bằng 2 là lý tưởng)](#Đối-số-của-hàm-ít-hơn-hoặc-bằng-2-là-lý-tưởng)
* [Hàm chỉ thực hiện một chức năng](#hàm-chỉ-thực-hiện-một-chức-năng)
* [Tên hàm nên thể hiện chức năng của hàm](#tên-hàm-nên-thể-hiện-chức-năng-của-hàm)
* [Hàm chỉ nên chứa một cấp trừu tượng](#hàm-chỉ-nên-chứa-một-cấp-trừu-tượng)
* [Đừng sử dụng cờ như là một đối số của hàm](#Đừng-sử-dụng-cờ-như-là-một-đối-số-của-hàm)
* [Tránh tác dụng phụ](#tránh-tác-dụng-phụ)
* [Đừng viết hàm global](#Đừng-viết-hàm-global)
* [Đừng sử dụng Singleton pattern](#Đừng-sử-dụng-singleton-pattern)
* [Đóng gói điều kiện](#Đóng-gói-điều-kiện)
* [Tránh điều kiện phủ định](#tránh-điều-kiện-phủ-định)
* [Tránh dùng điều kiện](#tránh-dùng-điều-kiện)
* [Tránh kiểm tra kiểu dữ liệu (phần 1)](#tránh-kiểm-tra-kiểu-dữ-liệu-phần-1)
* [Tránh kiểm tra kiểu dữ liệu (phần 2)](#tránh-kiểm-tra-kiểu-dữ-liệu-phần-2)
* [Xóa dead code](#xóa-dead-code)
5. [Đối tượng và kiến trúc dữ liệu](#Đối-tượng-và-kiến-trúc-dữ-liệu)
* [Sử dụng đối tượng đóng gói](#sử-dụng-đối-tượng-đóng-gói)
* [Tạo đối tượng có chứa thuộc tính hoặc phương thức private/protected](#tạo-đối-tượng-có-chứa-thuộc-tính-hoặc-phương-thức-private/protected)
6. [Lớp](#lớp)
* [Ưu tiên thành phần hơn kế thừa](#Ưu-tiên-thành-phần-hơn-kế-thừa)
* [Tránh viết fluent interfaces](#tránh-viết-fluent-interfaces)
7. [SOLID](#solid)
* [Nguyên lý trách nhiệm duy nhất (SRP)](#nguyên-lý-trách-nhiệm-duy-nhất-srp)
* [Nguyên lý Đóng/Mở (OCP)](#nguyên-lý-đóng/mở-ocp)
* [Nguyên lý thay thế Liskov (LSP)](#nguyên-lý-thay-thế-liskov-lsp)
* [Nguyên lý phân tách interface (ISP)](#nguyên-lý-phân-tách-interface-isp)
* [Nguyên lý đảo ngược dependencies (DIP)](#nguyên-lý-đảo-ngược-dependencies-dip)
8. [Nguyên lý đừng lặp lại chính mình (DRY)](#nguyên-lý-đừng-lặp-lại-chính-mình-dry)
9. [Các ngôn ngữ khác](#các-ngôn-ngữ-khác)
## Giới thiệu
Đây là những nguyên lý kỹ thuật phần mềm, được trích từ cuốn sách [*Clean Code*](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) của tác giả Robert C. Martin(thường gọi là Uncle Bob) rất thích hợp cho ngôn ngữ PHP. Tài liệu này không phải là sách hướng dẫn về phong cách viết code, mà là hướng dẫn cách làm thế nào để viết phần mềm dễ đọc, dễ sử dụng lại, và dễ cải tiến trong PHP.
Bạn không cần phải tuân theo tất cả các nguyên tắc trong tài liệu này.
Đây chỉ đơn giản là những hướng dẫn, nhưng dù sao nó cũng là đúc kết từ nhiều năm kinh nghiệm của tác giả.
Repository này lấy cảm hứng từ [clean-code-javascript](https://github.com/ryanmcdermott/clean-code-javascript)
Lưu ý: Dù nhiều lập trình viên còn sử dụng PHP 5, nhưng nhiều ví dụ trong đây chỉ chạy được trên PHP 7.1+.
## Biến
### Sử dụng tên biến có ý nghĩa và dễ hiểu
**Chưa tốt:**
```php
$ymdstr = $moment->format('y-m-d');
```
**Tốt:**
```php
$currentDate = $moment->format('y-m-d');
```
**[⬆ Về mục lục](#mục-lục)**
### Sử dụng cùng từ vựng cho cùng một loại biến
**Chưa tốt:**
```php
getUserInfo();
getUserData();
getUserRecord();
getUserProfile();
```
**Tốt:**
```php
getUser();
```
**[⬆ Về mục lục](#mục-lục)**
### Đặt tên sao cho dễ tìm kiếm (phần 1)
Thường thì chúng ta sẽ đọc code nhiều hơn viết code. Nên điều quan trọng là code chúng ta viết ra phải dễ đọc và dễ tìm kiếm.
Nếu *không* đặt tên biến có ý nghĩa và làm chương trình dễ hiểu, chúng ta sẽ gây khó cho những lập trình viên khác. Do đó mỗi khi đặt tên biến, hàm thì hãy đặt có ý nghĩa.
**Chưa tốt:**
```php
// Oh man, 448 là cái giề vậy?
$result = $serializer->serialize($data, 448);
```
**Tốt:**
```php
$json = $serializer->serialize($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
```
### Đặt tên sao cho dễ tìm kiếm (phần 2)
**Chưa tốt:**
```php
// Lại nữa, 4 nghĩa là cái giề đây?
if ($user->access & 4) {
// ...
}
```
**Tốt:**
```php
class User
{
const ACCESS_READ = 1;
const ACCESS_CREATE = 2;
const ACCESS_UPDATE = 4;
const ACCESS_DELETE = 8;
}
if ($user->access & User::ACCESS_UPDATE) {
// do edit ...
}
```
**[⬆ Về mục lục](#mục-lục)**
### Đặt tên biến dễ hiểu
Tức là đặt tên biến sao cho đọc vô là hiểu nó là gì và nó dùng để làm gì. Không cần phải suy nghĩ, suy diễn.
**Chưa tốt:**
```php
$address = 'One Infinite Loop, Cupertino 95014';
$cityZipCodeRegex = '/^[^,]+,\s*(.+?)\s*(\d{5})$/';
preg_match($cityZipCodeRegex, $address, $matches);
saveCityZipCode($matches[1], $matches[2]);
```
**Không tệ lắm:**
Tốt hơn một chút, nhưng vẫn còn phụ thuộc nhiều vào regex.
```php
$address = 'One Infinite Loop, Cupertino 95014';
$cityZipCodeRegex = '/^[^,]+,\s*(.+?)\s*(\d{5})$/';
preg_match($cityZipCodeRegex, $address, $matches);
[, $city, $zipCode] = $matches;
saveCityZipCode($city, $zipCode);
```
**Tốt:**
Đã giảm phụ thuộc vào regex bằng "naming subpatterns".
```php
$address = 'One Infinite Loop, Cupertino 95014';
$cityZipCodeRegex = '/^[^,]+,\s*(?<city>.+?)\s*(?<zipCode>\d{5})$/';
preg_match($cityZipCodeRegex, $address, $matches);
saveCityZipCode($matches['city'], $matches['zipCode']);
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh lồng (nesting) quá nhiều và nên return sớm (phần 1)
Quá nhiều if else lồng nhau sẽ khiến code tăng độ phức tạp, khó debug. Giảm sự phức tạp bằng cách giảm số if else lồng nhau xuống ít nhất có thể. Return sớm chính là một cách giảm số lần lồng nhau.
**Chưa tốt:**
```php
function isShopOpen($day): bool
{
if ($day) {
if (is_string($day)) {
$day = strtolower($day);
if ($day === 'friday') {
return true;
} elseif ($day === 'saturday') {
return true;
} elseif ($day === 'sunday') {
return true;
} else {
return false;
}
} else {
return false;
}
} else {
return false;
}
}
```
**Tốt:**
```php
function isShopOpen(string $day): bool
{
if (empty($day)) {
return false;
}
$openingDays = [
'friday', 'saturday', 'sunday'
];
return in_array(strtolower($day), $openingDays, true);
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh lồng (nesting) quá nhiều và nên return sớm (phần 2)
**Chưa tốt:**
```php
function fibonacci(int $n)
{
if ($n < 50) {
if ($n !== 0) {
if ($n !== 1) {
return fibonacci($n - 1) + fibonacci($n - 2);
} else {
return 1;
}
} else {
return 0;
}
} else {
return 'Not supported';
}
}
```
**Tốt:**
```php
function fibonacci(int $n): int
{
if ($n === 0 || $n === 1) {
return $n;
}
if ($n > 50) {
throw new \Exception('Not supported');
}
return fibonacci($n - 1) + fibonacci($n - 2);
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh hack não người đọc
Đừng khiến người đọc code phải khó khăn để hiểu ý nghĩa của biến. Tên biến càng rõ ràng càng tốt.
**Chưa tốt:**
```php
$l = ['Austin', 'New York', 'San Francisco'];
for ($i = 0; $i < count($l); $i++) {
$li = $l[$i];
doStuff();
doSomeOtherStuff();
// ...
// ...
// ...
// Đợi đã, `$li` là cái gì?
dispatch($li);
}
```
**Tốt:**
```php
$locations = ['Austin', 'New York', 'San Francisco'];
foreach ($locations as $location) {
doStuff();
doSomeOtherStuff();
// ...
// ...
// ...
dispatch($location);
}
```
**[⬆ Về mục lục](#mục-lục)**
### Đừng thêm những nội dung không cần thiết
Nếu tên của class/object đã rõ ràng, không nên lặp lại chúng trong tên biến.
**Chưa tốt:**
```php
class Car
{
public $carMake;
public $carModel;
public $carColor;
//...
}
```
**Tốt:**
```php
class Car
{
public $make;
public $model;
public $color;
//...
}
```
**[⬆ Về mục lục](#mục-lục)**
### Sử dụng đối số mặc định thay vì phải kiểm tra bằng biểu thức điều kiện
**Chưa tốt:**
Chưa tốt vì `$breweryName` có thể bị `NULL`.
```php
function createMicrobrewery($breweryName = 'Hipster Brew Co.'): void
{
// ...
}
```
**Không tệ lắm:**
Cái này tốt hơn cái trước, nhưng nó nên quản lý được giá trị của biến thì tốt hơn.
```php
function createMicrobrewery($name = null): void
{
$breweryName = $name ?: 'Hipster Brew Co.';
// ...
}
```
**Tốt:**
Bạn có thể sử dụng [type hinting](http://php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration) và chắc chắn `$breweryName` sẽ không bị `NULL`.
```php
function createMicrobrewery(string $breweryName = 'Hipster Brew Co.'): void
{
// ...
}
```
**[⬆ Về mục lục](#mục-lục)**
## So sánh
**[⬆ Về mục lục](#mục-lục)**
### Sử dụng [identical comparison](http://php.net/manual/en/language.operators.comparison.php)
**Chưa tốt:**
Sử dụng *simple comparison* (so sánh đơn giản)
```php
$a = '42';
$b = 42;
Sử dụng simple comparison thì nó sẽ tự chuyển kiểu string qua kiểu int
if ($a != $b) {
//Biểu thức này sẽ trả về `false`
}
```
Phép so sánh $a != $b trả về `false` nhưng trong thực tế thì nó phải là `true`.
**Chuỗi** '42' thì phải khác **số** 42 chứ đúng không.
**Tốt:**
Sử dụng *identical comparison* (so sánh giống hệt nhau) để so sánh cả kiểu dữ liệu và giá trị
```php
if ($a !== $b) {
//Biểu thức này trả về `true`
}
```
**[⬆ Về mục lục](#mục-lục)**
## Hàm
### Đối số của hàm (ít hơn hoặc bằng 2 là lý tưởng)
Giới hạn số lượng đối số (parameters) của hàm vô cùng quan trọng bởi vì nó giúp dễ test hơn.
Có nhiều hơn 3 đối số dẫn đến một tổ hợp rất nhiều trường hợp khác nhau cần phải test.
Lý tưởng nhất là khi hàm không có đối số nào. Một hoặc hai đối số là ok, còn ba thì nên hạn chế.
Bất cứ khi nào hàm có nhiều hơn 3 đối số thì cần phải xem xét tìm cách giảm bớt lại.
Bởi vì nếu hàm có nhiều hơn hai đối số thì nó phải xử lý rất nhiều.
**Chưa tốt:**
```php
function createMenu(string $title, string $body, string $buttonText, bool $cancellable): void
{
// ...
}
```
**Tốt:**
```php
class MenuConfig
{
public $title;
public $body;
public $buttonText;
public $cancellable = false;
}
$config = new MenuConfig();
$config->title = 'Foo';
$config->body = 'Bar';
$config->buttonText = 'Baz';
$config->cancellable = true;
function createMenu(MenuConfig $config): void
{
// ...
}
```
**[⬆ Về mục lục](#mục-lục)**
### Hàm chỉ thực hiện một chức năng
Đây là nguyên tắc quan trọng nhất trong phát triển phần mềm.
Khi hàm thực hiện nhiều hơn một chức năng, chúng khó biên dịch, kiểm tra và biết được nguyên nhân lỗi.
Khi bạn tạo hàm chỉ với một chức năng, sẽ dễ dàng refactor hơn và code sẽ dễ đọc hơn.
Nếu làm được điều này thì bạn sẽ tốt hơn nhiều lập trình viên khác.
**Chưa tốt:**
```php
function emailClients(array $clients): void
{
foreach ($clients as $client) {
$clientRecord = $db->find($client);
if ($clientRecord->isActive()) {
email($client);
}
}
}
```
**Tốt:**
```php
function emailClients(array $clients): void
{
$activeClients = activeClients($clients);
array_walk($activeClients, 'email');
}
function activeClients(array $clients): array
{
return array_filter($clients, 'isClientActive');
}
function isClientActive(int $client): bool
{
$clientRecord = $db->find($client);
return $clientRecord->isActive();
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tên hàm nên thể hiện chức năng của hàm
**Chưa tốt:**
```php
class Email
{
//...
public function handle(): void
{
mail($this->to, $this->subject, $this->body);
}
}
$message = new Email(...);
// Hàm này dùng làm gì? Có phải nó xử lý mail? Nó có đang ghi gì vào file không?
$message->handle();
```
**Tốt:**
```php
class Email
{
//...
public function send(): void
{
mail($this->to, $this->subject, $this->body);
}
}
$message = new Email(...);
// Rõ ràng và minh bạch, hàm này gửi mail
$message->send();
```
**[⬆ Về mục lục](#mục-lục)**
### Hàm chỉ nên có độ trừu tượng một cấp
Khi bạn có độ trừu tượng nhiều hơn một cấp thì hàm thường phải làm quá nhiều việc.
Hãy chia tách hàm ra thành nhiều phần để dễ sử dụng lại và dễ test.
**Chưa tốt:**
```php
function parseBetterJSAlternative(string $code): void
{
$regexes = [
// ...
];
$statements = explode(' ', $code);
$tokens = [];
foreach ($regexes as $regex) {
foreach ($statements as $statement) {
// ...
}
}
$ast = [];
foreach ($tokens as $token) {
// lex...
}
foreach ($ast as $node) {
// parse...
}
}
```
**Cũng chưa tốt:**
Chúng ta đã thực hiện tách ra vài hàm, nhưng hàm `parseBetterJSAlternative()` vẫn còn khá phức tạp và khó test.
```php
function tokenize(string $code): array
{
$regexes = [
// ...
];
$statements = explode(' ', $code);
$tokens = [];
foreach ($regexes as $regex) {
foreach ($statements as $statement) {
$tokens[] = /* ... */;
}
}
return $tokens;
}
function lexer(array $tokens): array
{
$ast = [];
foreach ($tokens as $token) {
$ast[] = /* ... */;
}
return $ast;
}
function parseBetterJSAlternative(string $code): void
{
$tokens = tokenize($code);
$ast = lexer($tokens);
foreach ($ast as $node) {
// parse...
}
}
```
**Tốt:**
Giải pháp tốt nhất là chuyển các phần thành các dependencies của hàm `parseBetterJSAlternative()`
```php
class Tokenizer
{
public function tokenize(string $code): array
{
$regexes = [
// ...
];
$statements = explode(' ', $code);
$tokens = [];
foreach ($regexes as $regex) {
foreach ($statements as $statement) {
$tokens[] = /* ... */;
}
}
return $tokens;
}
}
class Lexer
{
public function lexify(array $tokens): array
{
$ast = [];
foreach ($tokens as $token) {
$ast[] = /* ... */;
}
return $ast;
}
}
class BetterJSAlternative
{
private $tokenizer;
private $lexer;
public function __construct(Tokenizer $tokenizer, Lexer $lexer)
{
$this->tokenizer = $tokenizer;
$this->lexer = $lexer;
}
public function parse(string $code): void
{
$tokens = $this->tokenizer->tokenize($code);
$ast = $this->lexer->lexify($tokens);
foreach ($ast as $node) {
// parse...
}
}
}
```
**[⬆ Về mục lục](#mục-lục)**
### Đừng sử dụng cờ như là một đối số của hàm
Cờ dùng để nói rằng hàm này thực hiện nhiều hơn một công việc. Nhưng hàm thì chỉ nên xử lý một công việc mà thôi.
Do đó hãy chia tách hàm của bạn nếu như chúng có nhiều luồng code phân biệt bằng boolean(true/false).
**Chưa tốt:**
```php
function createFile(string $name, bool $temp = false): void
{
if ($temp) {
touch('./temp/'.$name);
} else {
touch($name);
}
}
```
**Tốt:**
```php
function createFile(string $name): void
{
touch($name);
}
function createTempFile(string $name): void
{
touch('./temp/'.$name);
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh tác dụng phụ
Một hàm sinh ra tác dụng phụ nếu nó thực hiện thêm việc khác ngoài việc lấy giá trị vào và trả về một hoặc nhiều giá trị khác.
Tác dụng phụ có thể là viết vào một file nào đó, sửa đổi biến global, hoặc vô tình chuyển hết tiền của bạn cho người lạ nào đó.
Vậy nếu bây giờ bạn cần hàm thực hiện các tác dụng phụ đó thì sao. Giống như ví dụ trước, bạn cần ghi vào file. Điều bạn cần làm
là tập trung những việc này lại một chỗ. Đừng viết vài hàm và vài lớp chỉ để ghi vào vài file cụ thể.
Hãy viết một service để làm điều đó. Một và chỉ một service.
Hãy tránh những sai lầm phổ biến như: chia sẻ trạng thái giữa các object mà không tuân theo cấu trúc nào,
sử dụng kiểu dữ liệu có thể thay đổi/bị thay đổi dễ dàng, không tổng hợp các tác dụng phụ có thể xảy ra khi viết hàm.
**Chưa tốt:**
```php
// Biến glabal được tham chiếu bởi hàm bên dưới.
// Nếu ta tạo một function khác sử dụng chính biến name, ví dụ bên dưới cho thấy nó biến thành array và đã bị phá vỡ.
$name = 'Ryan McDermott';
function splitIntoFirstAndLastName(): void
{
global $name;
$name = explode(' ', $name);
}
splitIntoFirstAndLastName();
var_dump($name); // ['Ryan', 'McDermott'];
```
**Tốt:**
```php
function splitIntoFirstAndLastName(string $name): array
{
return explode(' ', $name);
}
$name = 'Ryan McDermott';
$newName = splitIntoFirstAndLastName($name);
var_dump($name); // 'Ryan McDermott';
var_dump($newName); // ['Ryan', 'McDermott'];
```
**[⬆ Về mục lục](#mục-lục)**
### Đừng viết hàm global
Dùng nhiều hàm global là bad practice với nhiều ngôn ngữ bởi vì có thể gây xung đột với thư viện khác
và người sử dụng API của bạn không hề hay biết gì cho đến khi nhận được thông báo lỗi.
Hãy xem xét ví dụ sau: bạn sẽ làm gì nếu muốn trả về một mảng.
Bạn có thể viết hàm global như `config()`, nhưng nó có thể xung đột với thư viện khác thực hiện cùng chức năng.
**Chưa tốt:**
```php
function config(): array
{
return [
'foo' => 'bar',
]
}
```
**Tốt:**
```php
class Configuration
{
private $configuration = [];
public function __construct(array $configuration)
{
$this->configuration = $configuration;
}
public function get(string $key): ?string
{
return isset($this->configuration[$key]) ? $this->configuration[$key] : null;
}
}
```
Tạo instance của lớp `Configuration`
```php
$configuration = new Configuration([
'foo' => 'bar',
]);
```
Và bây giờ sử dụng instance `Configuration` trong ứng dụng của bạn.
**[⬆ Về mục lục](#mục-lục)**
### Đừng sử dụng Singleton pattern
Singleton là một [anti-pattern](https://en.wikipedia.org/wiki/Singleton_pattern). Trích đoạn từ Brian Button:
1. Chúng thường được sử dụng như **global instance**, vì sao lại Chưa tốt? Bởi vì **bạn ẩn dependencies** của ứng dụng bên trong code của bạn,
thay vì thông qua interfaces
2. Chúng vi phạm [single responsibility principle](#single-responsibility-principle-srp): bởi vì thực tế là **chúng điều khiển những gì chúng tạo ra và vòng đời của nó**
3. Chúng đã tạo ra kiểu code [coupling](https://en.wikipedia.org/wiki/Coupling_%28computer_programming%29). Đây là một sự giả mạo và được giấu bằng cách tạo ra nhiều trường hợp **test khó khăn hơn**.
4. Chúng giữ trạng thái suốt vòng đời của ứng dụng. Bạn nên kết thúc sớm testing khi lỗi. Nhưng Singleton thì lại duy trì trạng thái nên nó Chưa tốt.
Đây là một ý kiến khác của [Misko Hevery](http://misko.hevery.com/about/) về [gốc rễ của vấn đề](http://misko.hevery.com/2008/08/25/root-cause-of-singletons/).
**Chưa tốt:**
```php
class DBConnection
{
private static $instance;
private function __construct(string $dsn)
{
// ...
}
public static function getInstance(): DBConnection
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
// ...
}
$singleton = DBConnection::getInstance();
```
**Tốt:**
```php
class DBConnection
{
public function __construct(string $dsn)
{
// ...
}
// ...
}
```
Tạo instance của lớp `DBConnection` và cấu hình chúng với [DSN](http://php.net/manual/en/pdo.construct.php#refsect1-pdo.construct-parameters).
```php
$connection = new DBConnection($dsn);
```
Và bây giờ sử dụng instance `DBConnection` cho ứng dụng của bạn.
**[⬆ Về mục lục](#mục-lục)**
### Đóng gói điều kiện
**Chưa tốt:**
```php
if ($article->state === 'published') {
// ...
}
```
**Tốt:**
```php
if ($article->isPublished()) {
// ...
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh điều kiện phủ định
**Chưa tốt:**
```php
function isDOMNodeNotPresent(\DOMNode $node): bool
{
// ...
}
if (!isDOMNodeNotPresent($node))
{
// ...
}
```
**Tốt:**
```php
function isDOMNodePresent(\DOMNode $node): bool
{
// ...
}
if (isDOMNodePresent($node)) {
// ...
}
```
**[⬆ Về mục lục](#mục-lục)**
### Tránh dùng điều kiện
Điều này có vẻ không khả quan. Hầu hết mọi người sẽ thắc mắc,
"làm sao có thể làm gì đó mà không có `if`?" Bạn có thể dùng tính đa hình để hoàn thành việc đó trong khá nhiều trường hợp.
Câu hỏi thứ hai là, "ồ ngon nhưng tại sao phải làm thế?"
Bởi vì khái niệm clean code mà ta đã học trước đây: một hàm chỉ nên thực hiện một chức năng.
Khi bạn có một lớp hoặc hàm chứa `if`, tức là bạn đang muốn nó thực hiện nhiều việc. Luôn nhớ, chỉ một mà thôi.
**Chưa tốt:**
```php
class Airplane
{
// ...
public function getCruisingAltitude(): int
{
switch ($this->type) {
case '777':
return $this->getMaxAltitude() - $this->getPassengerCount();
case 'Air Force One':
return $this->getMaxAltitude();
case 'Cessna':
return $this->getMaxAltitude() - $this->getFuelExpenditure();
}
}
}
```
**Tốt:**
```php
interface Airplane
{
// ...
public function getCruisingAltitude(): int;
}
class Boeing777 implements Airplane
{
// ...
public function getCruisingAltitude(): int
{
return $this->getMaxAltitude() - $this->getPassengerCount();
}
}
class AirForceOne implements Airplane
{
// ...
public function getCruisingAltitude(): int
{
return $this->getMaxAltitude();
}
}
class Cessna implements Airplane
{
// ...
public function getCruisingAltitude(): int
{
return $this->getMaxAltitude() - $this->getFuelExpenditure();
}