├── .gitattributes ├── .idea └── vcs.xml ├── .travis-build.php ├── .travis.yml ├── LICENSE └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | *.md linguist-documentation=false 2 | *.md linguist-language=PHP 3 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.travis-build.php: -------------------------------------------------------------------------------- 1 | setFlags(SplFileObject::DROP_NEW_LINE); 6 | 7 | $cliRedBackground = "\033[37;41m"; 8 | $cliReset = "\033[0m"; 9 | $exitStatus = 0; 10 | 11 | $indentationSteps = 3; 12 | $manIndex = 0; 13 | $linesWithSpaces = []; 14 | $tableOfContentsStarted = null; 15 | $currentTableOfContentsChapters = []; 16 | $chaptersFound = []; 17 | foreach ($readMeFile as $lineNumber => $line) { 18 | if (preg_match('/\s$/', $line)) { 19 | $linesWithSpaces[] = sprintf('%5s: %s', 1 + $lineNumber, $line); 20 | } 21 | if (preg_match('/^(?##+)\s(?.+)/', $line, $matches)) { 22 | if (null === $tableOfContentsStarted) { 23 | $tableOfContentsStarted = true; 24 | continue; 25 | } 26 | $tableOfContentsStarted = false; 27 | 28 | $chaptersFound[] = sprintf('%s [%s](#%s)', 29 | strlen($matches['depth']) === 2 30 | ? sprintf(' %s.', ++$manIndex) 31 | : ' *' 32 | , 33 | $matches['title'], 34 | preg_replace(['/ /', '/[^-\w]+/'], ['-', ''], strtolower($matches['title'])) 35 | ); 36 | } 37 | if ($tableOfContentsStarted === true && isset($line[0])) { 38 | $currentTableOfContentsChapters[] = $line; 39 | } 40 | } 41 | 42 | if (count($linesWithSpaces)) { 43 | fwrite(STDERR, sprintf("${cliRedBackground}The following lines end with a space character:${cliReset}\n%s\n\n", 44 | implode(PHP_EOL, $linesWithSpaces) 45 | )); 46 | $exitStatus = 1; 47 | } 48 | 49 | $currentTableOfContentsChaptersFilename = __DIR__ . '/current-chapters'; 50 | $chaptersFoundFilename = __DIR__ . '/chapters-found'; 51 | 52 | file_put_contents($currentTableOfContentsChaptersFilename, implode(PHP_EOL, $currentTableOfContentsChapters)); 53 | file_put_contents($chaptersFoundFilename, implode(PHP_EOL, $chaptersFound)); 54 | 55 | $tableOfContentsDiff = shell_exec(sprintf('diff --unified %s %s', 56 | escapeshellarg($currentTableOfContentsChaptersFilename), 57 | escapeshellarg($chaptersFoundFilename) 58 | )); 59 | 60 | @ unlink($currentTableOfContentsChaptersFilename); 61 | @ unlink($chaptersFoundFilename); 62 | 63 | if (!empty($tableOfContentsDiff)) { 64 | fwrite(STDERR, sprintf("${cliRedBackground}The table of contents is not aligned:${cliReset}\n%s\n\n", 65 | $tableOfContentsDiff 66 | )); 67 | $exitStatus = 1; 68 | } 69 | 70 | exit($exitStatus); 71 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: php 2 | 3 | sudo: false 4 | 5 | php: 6 | - nightly 7 | 8 | script: php .travis-build.php 9 | 10 | notifications: 11 | email: false 12 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Ryan McDermott 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Clean Code PHP 2 | 3 | ## Mục lục 4 | 5 | 1. [Giới thiệu](#giới-thiệu) 6 | 2. [Biến](#biến) 7 | * [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) 8 | * [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) 9 | * [Đặ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) 10 | * [Đặ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) 11 | * [Đặt tên biến có dễ hiểu](#đặt-tên-biến-dễ-hiểu) 12 | * [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) 13 | * [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) 14 | * [Tránh hack não người đọc](#tránh-hack-não-người-đọc) 15 | * [Đừ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) 16 | * [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) 17 | 3. [So sánh](#so-sánh) 18 | * [Sử dụng identical comparison](#sử-dụng-identical-comparison) 19 | 4. [Hàm](#hàm) 20 | * [Đố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) 21 | * [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) 22 | * [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) 23 | * [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) 24 | * [Đừ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) 25 | * [Tránh tác dụng phụ](#tránh-tác-dụng-phụ) 26 | * [Đừng viết hàm global](#Đừng-viết-hàm-global) 27 | * [Đừng sử dụng Singleton pattern](#Đừng-sử-dụng-singleton-pattern) 28 | * [Đóng gói điều kiện](#Đóng-gói-điều-kiện) 29 | * [Tránh điều kiện phủ định](#tránh-điều-kiện-phủ-định) 30 | * [Tránh dùng điều kiện](#tránh-dùng-điều-kiện) 31 | * [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) 32 | * [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) 33 | * [Xóa dead code](#xóa-dead-code) 34 | 5. [Đối tượng và kiến trúc dữ liệu](#Đối-tượng-và-kiến-trúc-dữ-liệu) 35 | * [Sử dụng đối tượng đóng gói](#sử-dụng-đối-tượng-đóng-gói) 36 | * [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) 37 | 6. [Lớp](#lớp) 38 | * [Ưu tiên thành phần hơn kế thừa](#Ưu-tiên-thành-phần-hơn-kế-thừa) 39 | * [Tránh viết fluent interfaces](#tránh-viết-fluent-interfaces) 40 | 7. [SOLID](#solid) 41 | * [Nguyên lý trách nhiệm duy nhất (SRP)](#nguyên-lý-trách-nhiệm-duy-nhất-srp) 42 | * [Nguyên lý Đóng/Mở (OCP)](#nguyên-lý-đóng/mở-ocp) 43 | * [Nguyên lý thay thế Liskov (LSP)](#nguyên-lý-thay-thế-liskov-lsp) 44 | * [Nguyên lý phân tách interface (ISP)](#nguyên-lý-phân-tách-interface-isp) 45 | * [Nguyên lý đảo ngược dependencies (DIP)](#nguyên-lý-đảo-ngược-dependencies-dip) 46 | 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) 47 | 9. [Các ngôn ngữ khác](#các-ngôn-ngữ-khác) 48 | 49 | ## Giới thiệu 50 | 51 | Đâ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. 52 | 53 | 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. 54 | Đâ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ả. 55 | 56 | Repository này lấy cảm hứng từ [clean-code-javascript](https://github.com/ryanmcdermott/clean-code-javascript) 57 | 58 | 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+. 59 | 60 | ## Biến 61 | 62 | ### Sử dụng tên biến có ý nghĩa và dễ hiểu 63 | 64 | **Chưa tốt:** 65 | 66 | ```php 67 | $ymdstr = $moment->format('y-m-d'); 68 | ``` 69 | 70 | **Tốt:** 71 | 72 | ```php 73 | $currentDate = $moment->format('y-m-d'); 74 | ``` 75 | 76 | **[⬆ Về mục lục](#mục-lục)** 77 | 78 | ### Sử dụng cùng từ vựng cho cùng một loại biến 79 | 80 | **Chưa tốt:** 81 | 82 | ```php 83 | getUserInfo(); 84 | getUserData(); 85 | getUserRecord(); 86 | getUserProfile(); 87 | ``` 88 | 89 | **Tốt:** 90 | 91 | ```php 92 | getUser(); 93 | ``` 94 | 95 | **[⬆ Về mục lục](#mục-lục)** 96 | 97 | ### Đặt tên sao cho dễ tìm kiếm (phần 1) 98 | 99 | 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. 100 | 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. 101 | 102 | **Chưa tốt:** 103 | 104 | ```php 105 | // Oh man, 448 là cái giề vậy? 106 | $result = $serializer->serialize($data, 448); 107 | ``` 108 | 109 | **Tốt:** 110 | 111 | ```php 112 | $json = $serializer->serialize($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE); 113 | ``` 114 | 115 | ### Đặt tên sao cho dễ tìm kiếm (phần 2) 116 | 117 | **Chưa tốt:** 118 | 119 | ```php 120 | // Lại nữa, 4 nghĩa là cái giề đây? 121 | if ($user->access & 4) { 122 | // ... 123 | } 124 | ``` 125 | 126 | **Tốt:** 127 | 128 | ```php 129 | class User 130 | { 131 | const ACCESS_READ = 1; 132 | const ACCESS_CREATE = 2; 133 | const ACCESS_UPDATE = 4; 134 | const ACCESS_DELETE = 8; 135 | } 136 | 137 | if ($user->access & User::ACCESS_UPDATE) { 138 | // do edit ... 139 | } 140 | ``` 141 | 142 | **[⬆ Về mục lục](#mục-lục)** 143 | 144 | ### Đặt tên biến dễ hiểu 145 | 146 | 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. 147 | 148 | **Chưa tốt:** 149 | 150 | ```php 151 | $address = 'One Infinite Loop, Cupertino 95014'; 152 | $cityZipCodeRegex = '/^[^,]+,\s*(.+?)\s*(\d{5})$/'; 153 | preg_match($cityZipCodeRegex, $address, $matches); 154 | 155 | saveCityZipCode($matches[1], $matches[2]); 156 | ``` 157 | 158 | **Không tệ lắm:** 159 | 160 | Tốt hơn một chút, nhưng vẫn còn phụ thuộc nhiều vào regex. 161 | 162 | ```php 163 | $address = 'One Infinite Loop, Cupertino 95014'; 164 | $cityZipCodeRegex = '/^[^,]+,\s*(.+?)\s*(\d{5})$/'; 165 | preg_match($cityZipCodeRegex, $address, $matches); 166 | 167 | [, $city, $zipCode] = $matches; 168 | saveCityZipCode($city, $zipCode); 169 | ``` 170 | 171 | **Tốt:** 172 | 173 | Đã giảm phụ thuộc vào regex bằng "naming subpatterns". 174 | 175 | ```php 176 | $address = 'One Infinite Loop, Cupertino 95014'; 177 | $cityZipCodeRegex = '/^[^,]+,\s*(?<city>.+?)\s*(?<zipCode>\d{5})$/'; 178 | preg_match($cityZipCodeRegex, $address, $matches); 179 | 180 | saveCityZipCode($matches['city'], $matches['zipCode']); 181 | ``` 182 | 183 | **[⬆ Về mục lục](#mục-lục)** 184 | 185 | ### Tránh lồng (nesting) quá nhiều và nên return sớm (phần 1) 186 | 187 | 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. 188 | 189 | **Chưa tốt:** 190 | 191 | ```php 192 | function isShopOpen($day): bool 193 | { 194 | if ($day) { 195 | if (is_string($day)) { 196 | $day = strtolower($day); 197 | if ($day === 'friday') { 198 | return true; 199 | } elseif ($day === 'saturday') { 200 | return true; 201 | } elseif ($day === 'sunday') { 202 | return true; 203 | } else { 204 | return false; 205 | } 206 | } else { 207 | return false; 208 | } 209 | } else { 210 | return false; 211 | } 212 | } 213 | ``` 214 | 215 | **Tốt:** 216 | 217 | ```php 218 | function isShopOpen(string $day): bool 219 | { 220 | if (empty($day)) { 221 | return false; 222 | } 223 | 224 | $openingDays = [ 225 | 'friday', 'saturday', 'sunday' 226 | ]; 227 | 228 | return in_array(strtolower($day), $openingDays, true); 229 | } 230 | ``` 231 | 232 | **[⬆ Về mục lục](#mục-lục)** 233 | 234 | ### Tránh lồng (nesting) quá nhiều và nên return sớm (phần 2) 235 | 236 | **Chưa tốt:** 237 | 238 | ```php 239 | function fibonacci(int $n) 240 | { 241 | if ($n < 50) { 242 | if ($n !== 0) { 243 | if ($n !== 1) { 244 | return fibonacci($n - 1) + fibonacci($n - 2); 245 | } else { 246 | return 1; 247 | } 248 | } else { 249 | return 0; 250 | } 251 | } else { 252 | return 'Not supported'; 253 | } 254 | } 255 | ``` 256 | 257 | **Tốt:** 258 | 259 | ```php 260 | function fibonacci(int $n): int 261 | { 262 | if ($n === 0 || $n === 1) { 263 | return $n; 264 | } 265 | 266 | if ($n > 50) { 267 | throw new \Exception('Not supported'); 268 | } 269 | 270 | return fibonacci($n - 1) + fibonacci($n - 2); 271 | } 272 | ``` 273 | 274 | **[⬆ Về mục lục](#mục-lục)** 275 | 276 | ### Tránh hack não người đọc 277 | 278 | Đừ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. 279 | 280 | **Chưa tốt:** 281 | 282 | ```php 283 | $l = ['Austin', 'New York', 'San Francisco']; 284 | 285 | for ($i = 0; $i < count($l); $i++) { 286 | $li = $l[$i]; 287 | doStuff(); 288 | doSomeOtherStuff(); 289 | // ... 290 | // ... 291 | // ... 292 | // Đợi đã, `$li` là cái gì? 293 | dispatch($li); 294 | } 295 | ``` 296 | 297 | **Tốt:** 298 | 299 | ```php 300 | $locations = ['Austin', 'New York', 'San Francisco']; 301 | 302 | foreach ($locations as $location) { 303 | doStuff(); 304 | doSomeOtherStuff(); 305 | // ... 306 | // ... 307 | // ... 308 | dispatch($location); 309 | } 310 | ``` 311 | 312 | **[⬆ Về mục lục](#mục-lục)** 313 | 314 | ### Đừng thêm những nội dung không cần thiết 315 | 316 | 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. 317 | 318 | **Chưa tốt:** 319 | 320 | ```php 321 | class Car 322 | { 323 | public $carMake; 324 | public $carModel; 325 | public $carColor; 326 | 327 | //... 328 | } 329 | ``` 330 | 331 | **Tốt:** 332 | 333 | ```php 334 | class Car 335 | { 336 | public $make; 337 | public $model; 338 | public $color; 339 | 340 | //... 341 | } 342 | ``` 343 | 344 | **[⬆ Về mục lục](#mục-lục)** 345 | 346 | ### 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 347 | 348 | **Chưa tốt:** 349 | 350 | Chưa tốt vì `$breweryName` có thể bị `NULL`. 351 | 352 | ```php 353 | function createMicrobrewery($breweryName = 'Hipster Brew Co.'): void 354 | { 355 |    // ... 356 | } 357 | ``` 358 | 359 | **Không tệ lắm:** 360 | 361 | 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. 362 | 363 | ```php 364 | function createMicrobrewery($name = null): void 365 | { 366 |    $breweryName = $name ?: 'Hipster Brew Co.'; 367 | // ... 368 | } 369 | ``` 370 | 371 | **Tốt:** 372 | 373 | 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`. 374 | 375 | ```php 376 | function createMicrobrewery(string $breweryName = 'Hipster Brew Co.'): void 377 | { 378 |    // ... 379 | } 380 | ``` 381 | 382 | **[⬆ Về mục lục](#mục-lục)** 383 | 384 | ## So sánh 385 | 386 | **[⬆ Về mục lục](#mục-lục)** 387 | 388 | ### Sử dụng [identical comparison](http://php.net/manual/en/language.operators.comparison.php) 389 | 390 | **Chưa tốt:** 391 | 392 | Sử dụng *simple comparison* (so sánh đơn giản) 393 | 394 | ```php 395 | $a = '42'; 396 | $b = 42; 397 | Sử dụng simple comparison thì nó sẽ tự chuyển kiểu string qua kiểu int 398 | 399 | if ($a != $b) { 400 | //Biểu thức này sẽ trả về `false` 401 | } 402 | 403 | ``` 404 | Phép so sánh $a != $b trả về `false` nhưng trong thực tế thì nó phải là `true`. 405 | **Chuỗi** '42' thì phải khác **số** 42 chứ đúng không. 406 | 407 | **Tốt:** 408 | 409 | 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ị 410 | 411 | ```php 412 | if ($a !== $b) { 413 | //Biểu thức này trả về `true` 414 | } 415 | 416 | ``` 417 | 418 | 419 | **[⬆ Về mục lục](#mục-lục)** 420 | 421 | 422 | ## Hàm 423 | 424 | ### Đối số của hàm (ít hơn hoặc bằng 2 là lý tưởng) 425 | 426 | 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. 427 | 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. 428 | 429 | 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ế. 430 | 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. 431 | 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. 432 | 433 | **Chưa tốt:** 434 | 435 | ```php 436 | function createMenu(string $title, string $body, string $buttonText, bool $cancellable): void 437 | { 438 | // ... 439 | } 440 | ``` 441 | 442 | **Tốt:** 443 | 444 | ```php 445 | class MenuConfig 446 | { 447 | public $title; 448 | public $body; 449 | public $buttonText; 450 | public $cancellable = false; 451 | } 452 | 453 | $config = new MenuConfig(); 454 | $config->title = 'Foo'; 455 | $config->body = 'Bar'; 456 | $config->buttonText = 'Baz'; 457 | $config->cancellable = true; 458 | 459 | function createMenu(MenuConfig $config): void 460 | { 461 | // ... 462 | } 463 | ``` 464 | 465 | **[⬆ Về mục lục](#mục-lục)** 466 | 467 | ### Hàm chỉ thực hiện một chức năng 468 | 469 | Đây là nguyên tắc quan trọng nhất trong phát triển phần mềm. 470 | 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. 471 | 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. 472 | 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. 473 | 474 | **Chưa tốt:** 475 | ```php 476 | function emailClients(array $clients): void 477 | { 478 | foreach ($clients as $client) { 479 | $clientRecord = $db->find($client); 480 | if ($clientRecord->isActive()) { 481 | email($client); 482 | } 483 | } 484 | } 485 | ``` 486 | 487 | **Tốt:** 488 | 489 | ```php 490 | function emailClients(array $clients): void 491 | { 492 | $activeClients = activeClients($clients); 493 | array_walk($activeClients, 'email'); 494 | } 495 | 496 | function activeClients(array $clients): array 497 | { 498 | return array_filter($clients, 'isClientActive'); 499 | } 500 | 501 | function isClientActive(int $client): bool 502 | { 503 | $clientRecord = $db->find($client); 504 | 505 | return $clientRecord->isActive(); 506 | } 507 | ``` 508 | 509 | **[⬆ Về mục lục](#mục-lục)** 510 | 511 | ### Tên hàm nên thể hiện chức năng của hàm 512 | 513 | **Chưa tốt:** 514 | 515 | ```php 516 | class Email 517 | { 518 | //... 519 | 520 | public function handle(): void 521 | { 522 | mail($this->to, $this->subject, $this->body); 523 | } 524 | } 525 | 526 | $message = new Email(...); 527 | // 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? 528 | $message->handle(); 529 | ``` 530 | 531 | **Tốt:** 532 | 533 | ```php 534 | class Email 535 | { 536 | //... 537 | 538 | public function send(): void 539 | { 540 | mail($this->to, $this->subject, $this->body); 541 | } 542 | } 543 | 544 | $message = new Email(...); 545 | // Rõ ràng và minh bạch, hàm này gửi mail 546 | $message->send(); 547 | ``` 548 | 549 | **[⬆ Về mục lục](#mục-lục)** 550 | 551 | ### Hàm chỉ nên có độ trừu tượng một cấp 552 | 553 | 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. 554 | Hãy chia tách hàm ra thành nhiều phần để dễ sử dụng lại và dễ test. 555 | 556 | **Chưa tốt:** 557 | 558 | ```php 559 | function parseBetterJSAlternative(string $code): void 560 | { 561 | $regexes = [ 562 | // ... 563 | ]; 564 | 565 | $statements = explode(' ', $code); 566 | $tokens = []; 567 | foreach ($regexes as $regex) { 568 | foreach ($statements as $statement) { 569 | // ... 570 | } 571 | } 572 | 573 | $ast = []; 574 | foreach ($tokens as $token) { 575 | // lex... 576 | } 577 | 578 | foreach ($ast as $node) { 579 | // parse... 580 | } 581 | } 582 | ``` 583 | 584 | **Cũng chưa tốt:** 585 | 586 | 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. 587 | 588 | ```php 589 | function tokenize(string $code): array 590 | { 591 | $regexes = [ 592 | // ... 593 | ]; 594 | 595 | $statements = explode(' ', $code); 596 | $tokens = []; 597 | foreach ($regexes as $regex) { 598 | foreach ($statements as $statement) { 599 | $tokens[] = /* ... */; 600 | } 601 | } 602 | 603 | return $tokens; 604 | } 605 | 606 | function lexer(array $tokens): array 607 | { 608 | $ast = []; 609 | foreach ($tokens as $token) { 610 | $ast[] = /* ... */; 611 | } 612 | 613 | return $ast; 614 | } 615 | 616 | function parseBetterJSAlternative(string $code): void 617 | { 618 | $tokens = tokenize($code); 619 | $ast = lexer($tokens); 620 | foreach ($ast as $node) { 621 | // parse... 622 | } 623 | } 624 | ``` 625 | 626 | **Tốt:** 627 | 628 | 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()` 629 | 630 | ```php 631 | class Tokenizer 632 | { 633 | public function tokenize(string $code): array 634 | { 635 | $regexes = [ 636 | // ... 637 | ]; 638 | 639 | $statements = explode(' ', $code); 640 | $tokens = []; 641 | foreach ($regexes as $regex) { 642 | foreach ($statements as $statement) { 643 | $tokens[] = /* ... */; 644 | } 645 | } 646 | 647 | return $tokens; 648 | } 649 | } 650 | 651 | class Lexer 652 | { 653 | public function lexify(array $tokens): array 654 | { 655 | $ast = []; 656 | foreach ($tokens as $token) { 657 | $ast[] = /* ... */; 658 | } 659 | 660 | return $ast; 661 | } 662 | } 663 | 664 | class BetterJSAlternative 665 | { 666 | private $tokenizer; 667 | private $lexer; 668 | 669 | public function __construct(Tokenizer $tokenizer, Lexer $lexer) 670 | { 671 | $this->tokenizer = $tokenizer; 672 | $this->lexer = $lexer; 673 | } 674 | 675 | public function parse(string $code): void 676 | { 677 | $tokens = $this->tokenizer->tokenize($code); 678 | $ast = $this->lexer->lexify($tokens); 679 | foreach ($ast as $node) { 680 | // parse... 681 | } 682 | } 683 | } 684 | ``` 685 | 686 | **[⬆ Về mục lục](#mục-lục)** 687 | 688 | ### Đừng sử dụng cờ như là một đối số của hàm 689 | 690 | 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. 691 | 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). 692 | 693 | **Chưa tốt:** 694 | 695 | ```php 696 | function createFile(string $name, bool $temp = false): void 697 | { 698 | if ($temp) { 699 | touch('./temp/'.$name); 700 | } else { 701 | touch($name); 702 | } 703 | } 704 | ``` 705 | 706 | **Tốt:** 707 | 708 | ```php 709 | function createFile(string $name): void 710 | { 711 | touch($name); 712 | } 713 | 714 | function createTempFile(string $name): void 715 | { 716 | touch('./temp/'.$name); 717 | } 718 | ``` 719 | 720 | **[⬆ Về mục lục](#mục-lục)** 721 | 722 | ### Tránh tác dụng phụ 723 | 724 | 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. 725 | 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 đó. 726 | 727 | 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 728 | 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ể. 729 | Hãy viết một service để làm điều đó. Một và chỉ một service. 730 | 731 | 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, 732 | 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. 733 | 734 | **Chưa tốt:** 735 | 736 | ```php 737 | // Biến glabal được tham chiếu bởi hàm bên dưới. 738 | // 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ỡ. 739 | $name = 'Ryan McDermott'; 740 | 741 | function splitIntoFirstAndLastName(): void 742 | { 743 | global $name; 744 | 745 | $name = explode(' ', $name); 746 | } 747 | 748 | splitIntoFirstAndLastName(); 749 | 750 | var_dump($name); // ['Ryan', 'McDermott']; 751 | ``` 752 | 753 | **Tốt:** 754 | 755 | ```php 756 | function splitIntoFirstAndLastName(string $name): array 757 | { 758 | return explode(' ', $name); 759 | } 760 | 761 | $name = 'Ryan McDermott'; 762 | $newName = splitIntoFirstAndLastName($name); 763 | 764 | var_dump($name); // 'Ryan McDermott'; 765 | var_dump($newName); // ['Ryan', 'McDermott']; 766 | ``` 767 | 768 | **[⬆ Về mục lục](#mục-lục)** 769 | 770 | ### Đừng viết hàm global 771 | 772 | 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 773 | 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. 774 | 775 | Hãy xem xét ví dụ sau: bạn sẽ làm gì nếu muốn trả về một mảng. 776 | 777 | 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. 778 | 779 | **Chưa tốt:** 780 | 781 | ```php 782 | function config(): array 783 | { 784 | return [ 785 | 'foo' => 'bar', 786 | ] 787 | } 788 | ``` 789 | 790 | **Tốt:** 791 | 792 | ```php 793 | class Configuration 794 | { 795 | private $configuration = []; 796 | 797 | public function __construct(array $configuration) 798 | { 799 | $this->configuration = $configuration; 800 | } 801 | 802 | public function get(string $key): ?string 803 | { 804 | return isset($this->configuration[$key]) ? $this->configuration[$key] : null; 805 | } 806 | } 807 | ``` 808 | 809 | Tạo instance của lớp `Configuration` 810 | 811 | ```php 812 | $configuration = new Configuration([ 813 | 'foo' => 'bar', 814 | ]); 815 | ``` 816 | 817 | Và bây giờ sử dụng instance `Configuration` trong ứng dụng của bạn. 818 | 819 | **[⬆ Về mục lục](#mục-lục)** 820 | 821 | ### Đừng sử dụng Singleton pattern 822 | 823 | Singleton là một [anti-pattern](https://en.wikipedia.org/wiki/Singleton_pattern). Trích đoạn từ Brian Button: 824 | 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, 825 | thay vì thông qua interfaces 826 | 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ó** 827 | 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**. 828 | 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. 829 | 830 | Đâ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/). 831 | 832 | **Chưa tốt:** 833 | 834 | ```php 835 | class DBConnection 836 | { 837 | private static $instance; 838 | 839 | private function __construct(string $dsn) 840 | { 841 | // ... 842 | } 843 | 844 | public static function getInstance(): DBConnection 845 | { 846 | if (self::$instance === null) { 847 | self::$instance = new self(); 848 | } 849 | 850 | return self::$instance; 851 | } 852 | 853 | // ... 854 | } 855 | 856 | $singleton = DBConnection::getInstance(); 857 | ``` 858 | 859 | **Tốt:** 860 | 861 | ```php 862 | class DBConnection 863 | { 864 | public function __construct(string $dsn) 865 | { 866 | // ... 867 | } 868 | 869 | // ... 870 | } 871 | ``` 872 | 873 | 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). 874 | 875 | ```php 876 | $connection = new DBConnection($dsn); 877 | ``` 878 | 879 | Và bây giờ sử dụng instance `DBConnection` cho ứng dụng của bạn. 880 | 881 | **[⬆ Về mục lục](#mục-lục)** 882 | 883 | ### Đóng gói điều kiện 884 | 885 | **Chưa tốt:** 886 | 887 | ```php 888 | if ($article->state === 'published') { 889 | // ... 890 | } 891 | ``` 892 | 893 | **Tốt:** 894 | 895 | ```php 896 | if ($article->isPublished()) { 897 | // ... 898 | } 899 | ``` 900 | 901 | **[⬆ Về mục lục](#mục-lục)** 902 | 903 | ### Tránh điều kiện phủ định 904 | 905 | **Chưa tốt:** 906 | 907 | ```php 908 | function isDOMNodeNotPresent(\DOMNode $node): bool 909 | { 910 | // ... 911 | } 912 | 913 | if (!isDOMNodeNotPresent($node)) 914 | { 915 | // ... 916 | } 917 | ``` 918 | 919 | **Tốt:** 920 | 921 | ```php 922 | function isDOMNodePresent(\DOMNode $node): bool 923 | { 924 | // ... 925 | } 926 | 927 | if (isDOMNodePresent($node)) { 928 | // ... 929 | } 930 | ``` 931 | 932 | **[⬆ Về mục lục](#mục-lục)** 933 | 934 | ### Tránh dùng điều kiện 935 | 936 | Điều này có vẻ không khả quan. Hầu hết mọi người sẽ thắc mắc, 937 | "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. 938 | Câu hỏi thứ hai là, "ồ ngon nhưng tại sao phải làm thế?" 939 | 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. 940 | 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. 941 | 942 | **Chưa tốt:** 943 | 944 | ```php 945 | class Airplane 946 | { 947 | // ... 948 | 949 | public function getCruisingAltitude(): int 950 | { 951 | switch ($this->type) { 952 | case '777': 953 | return $this->getMaxAltitude() - $this->getPassengerCount(); 954 | case 'Air Force One': 955 | return $this->getMaxAltitude(); 956 | case 'Cessna': 957 | return $this->getMaxAltitude() - $this->getFuelExpenditure(); 958 | } 959 | } 960 | } 961 | ``` 962 | 963 | **Tốt:** 964 | 965 | ```php 966 | interface Airplane 967 | { 968 | // ... 969 | 970 | public function getCruisingAltitude(): int; 971 | } 972 | 973 | class Boeing777 implements Airplane 974 | { 975 | // ... 976 | 977 | public function getCruisingAltitude(): int 978 | { 979 | return $this->getMaxAltitude() - $this->getPassengerCount(); 980 | } 981 | } 982 | 983 | class AirForceOne implements Airplane 984 | { 985 | // ... 986 | 987 | public function getCruisingAltitude(): int 988 | { 989 | return $this->getMaxAltitude(); 990 | } 991 | } 992 | 993 | class Cessna implements Airplane 994 | { 995 | // ... 996 | 997 | public function getCruisingAltitude(): int 998 | { 999 | return $this->getMaxAltitude() - $this->getFuelExpenditure(); 1000 | } 1001 | } 1002 | ``` 1003 | 1004 | **[⬆ Về mục lục](#mục-lục)** 1005 | 1006 | ### Tránh kiểm tra kiểu dữ liệu (phần 1) 1007 | 1008 | PHP là một ngôn ngữ không ràng buộc kiểu dữ liệu, nghĩa hàm có thể nhận bất kỳ kiểu nào. 1009 | Thỉnh thoảng thì chúng ta bị ảnh hưởng bởi sự tự do này và nó trở thành điều kiện để phải kiểm tra kiểu dữ liệu trong hàm. 1010 | Có nhiều cách để tránh phải làm việc đó. 1011 | 1012 | Điều đầu tiên cần làm là tạo ra những API nhất quán. 1013 | 1014 | **Chưa tốt:** 1015 | 1016 | ```php 1017 | function travelToTexas($vehicle): void 1018 | { 1019 | if ($vehicle instanceof Bicycle) { 1020 | $vehicle->pedalTo(new Location('texas')); 1021 | } elseif ($vehicle instanceof Car) { 1022 | $vehicle->driveTo(new Location('texas')); 1023 | } 1024 | } 1025 | ``` 1026 | 1027 | **Tốt:** 1028 | 1029 | ```php 1030 | function travelToTexas(Traveler $vehicle): void 1031 | { 1032 | $vehicle->travelTo(new Location('texas')); 1033 | } 1034 | ``` 1035 | 1036 | **[⬆ Về mục lục](#mục-lục)** 1037 | 1038 | ### Tránh kiểm tra kiểu dữ liệu (phần 2) 1039 | 1040 | Nếu bạn đang làm việc với các kiểu dữ liệu nguyên thủy như strings, integers, và arrays, 1041 | và sử dụng PHP 7+ và bạn không thể sử dụng tính đa hình nhưng bạn vẫn cảm thấy cần kiểm tra kiểu dữ liệu, hãy xem 1042 | [type declaration](http://php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration) 1043 | hoặc strict mode. Nó cung cấp cho bạn kiểu static trên PHP standard. 1044 | Vấn đề thông thường khi kiểm tra kiểu dữ liệu là sẽ khiến code khó đọc nên tóm lại mất nhiều hơn là được. 1045 | 1046 | Hãy giữ PHP nguyên thủy, viết tests cho tốt, và code reviews cẩn thận là được. 1047 | Nếu không thì chỉ còn cách định nghĩa theo kiểu nghiêm ngặt(strict type declaration) hoặc dùng strict mode. 1048 | 1049 | **Chưa tốt:** 1050 | 1051 | ```php 1052 | function combine($val1, $val2): int 1053 | { 1054 | if (!is_numeric($val1) || !is_numeric($val2)) { 1055 | throw new \Exception('Must be of type Number'); 1056 | } 1057 | 1058 | return $val1 + $val2; 1059 | } 1060 | ``` 1061 | 1062 | **Tốt:** 1063 | 1064 | ```php 1065 | function combine(int $val1, int $val2): int 1066 | { 1067 | return $val1 + $val2; 1068 | } 1069 | ``` 1070 | 1071 | **[⬆ Về mục lục](#mục-lục)** 1072 | 1073 | ### Xóa dead code 1074 | 1075 | Dead code thì cũng củ chuối giống như duplicate code. Không có lý do gì để giữ chúng. 1076 | Nếu đoạn code nào đó không được gọi, hãy xóa đi! 1077 | Sau này cần thì chỉ cần tìm lại phiên bản trước bằng git là được. 1078 | 1079 | **Chưa tốt:** 1080 | 1081 | ```php 1082 | function oldRequestModule(string $url): void 1083 | { 1084 | // ... 1085 | } 1086 | 1087 | function newRequestModule(string $url): void 1088 | { 1089 | // ... 1090 | } 1091 | 1092 | $request = newRequestModule($requestUrl); 1093 | inventoryTracker('apples', $request, 'www.inventory-awesome.io'); 1094 | ``` 1095 | 1096 | **Tốt:** 1097 | 1098 | ```php 1099 | function requestModule(string $url): void 1100 | { 1101 | // ... 1102 | } 1103 | 1104 | $request = requestModule($requestUrl); 1105 | inventoryTracker('apples', $request, 'www.inventory-awesome.io'); 1106 | ``` 1107 | 1108 | **[⬆ Về mục lục](#mục-lục)** 1109 | 1110 | 1111 | ## Đối tượng và kiến trúc dữ liệu 1112 | 1113 | ### Sử dụng đối tượng đóng gói 1114 | 1115 | Trong PHP bạn có thể khai `public`, `protected` và `private` cho phương thức và thuộc tính. 1116 | Hãy sử dụng chúng để kiểm soát được sự thay đổi thuộc tính trong object. 1117 | 1118 | * Khi bạn muốn nhiều hơn là chỉ nhận được thuộc tính của object, 1119 | thì ưu điểm là ta không cần phải tìm kiếm và thay đổi quyền mỗi khi truy cập vào object. 1120 | * Giúp tạo validation đơn giản mỗi khi thực hiện `set`. 1121 | * Đóng gói các thành phần bên trong. 1122 | * Dễ dàng ghi log và xử lý lỗi khi get và set. 1123 | * Kế thừa lớp, bạn có thể ghi đè những phương thức mặc định. 1124 | * Bạn có thể lazy load các thuộc tính của object, giả sử nó được lấy từ máy chủ chẳng hạn. 1125 | 1126 | Thêm vào đó, đây là một phần của nguyên tắc [Open/Closed](#openclosed-principle-ocp). 1127 | 1128 | **Chưa tốt:** 1129 | 1130 | ```php 1131 | class BankAccount 1132 | { 1133 | public $balance = 1000; 1134 | } 1135 | 1136 | $bankAccount = new BankAccount(); 1137 | 1138 | // Buy shoes... 1139 | $bankAccount->balance -= 100; 1140 | ``` 1141 | 1142 | **Tốt:** 1143 | 1144 | ```php 1145 | class BankAccount 1146 | { 1147 | private $balance; 1148 | 1149 | public function __construct(int $balance = 1000) 1150 | { 1151 | $this->balance = $balance; 1152 | } 1153 | 1154 | public function withdraw(int $amount): void 1155 | { 1156 | if ($amount > $this->balance) { 1157 | throw new \Exception('Amount greater than available balance.'); 1158 | } 1159 | 1160 | $this->balance -= $amount; 1161 | } 1162 | 1163 | public function deposit(int $amount): void 1164 | { 1165 | $this->balance += $amount; 1166 | } 1167 | 1168 |    public function getBalance(): int 1169 | { 1170 | return $this->balance; 1171 | } 1172 | } 1173 | 1174 | $bankAccount = new BankAccount(); 1175 | 1176 | // Buy shoes... 1177 | $bankAccount->withdraw($shoesPrice); 1178 | 1179 | // Get balance 1180 | $balance = $bankAccount->getBalance(); 1181 | ``` 1182 | 1183 | **[⬆ Về mục lục](#mục-lục)** 1184 | 1185 | ### Tạo đối tượng có chứa thuộc tính hoặc phương thức private/protected 1186 | 1187 | * Phương thức và thuộc tính `public` khá nguy hiểm, bởi vì vài dòng code phía 1188 | bên ngoài có thể dễ dàng thay đổi chúng và bạn không thể kiểm soát được nó bị 1189 | thay đổi những gì. **Thay đổi trong một lớp thì nguy hiểm cho tất cả các người dùng của lớp đó.** 1190 | * `protected` cũng nguy hiểm không kém, bởi vì chúng được cấp quyền ở tất cả các lớp con. Điều này có nghĩa là sự khác nhau giữa public và protected chỉ là cơ chế truy cập, nhưng tính đóng gói đảm bảo vẫn giữ nguyên. **Sửa đổi trong lớp thì rất nguy hiểm cho các lớp con.** 1191 | * `private` sửa đổi đảm bảo rằng code **sửa đổi chỉ nguy hiểm trong lớp đó** (bạn sẽ được an toàn khi sửa và không có hiệu ứng [Jenga](http://www.urbandictionary.com/define.php?term=Jengaphobia&defid=2494196)). 1192 | 1193 | Do đó, hãy mặc định sử dụng `private` và `public/protected` khi bạn cần cung cấp sự truy cập cho các class bên ngoài. 1194 | 1195 | Đọc thêm tại [blog post](http://fabien.potencier.org/pragmatism-over-theory-protected-vs-private.html) được viết bởi [Fabien Potencier](https://github.com/fabpot). 1196 | 1197 | **Chưa tốt:** 1198 | 1199 | ```php 1200 | class Employee 1201 | { 1202 | public $name; 1203 | 1204 | public function __construct(string $name) 1205 | { 1206 | $this->name = $name; 1207 | } 1208 | } 1209 | 1210 | $employee = new Employee('John Doe'); 1211 | echo 'Employee name: '.$employee->name; // Employee name: John Doe 1212 | ``` 1213 | 1214 | **Tốt:** 1215 | 1216 | ```php 1217 | class Employee 1218 | { 1219 | private $name; 1220 | 1221 | public function __construct(string $name) 1222 | { 1223 | $this->name = $name; 1224 | } 1225 | 1226 | public function getName(): string 1227 | { 1228 | return $this->name; 1229 | } 1230 | } 1231 | 1232 | $employee = new Employee('John Doe'); 1233 | echo 'Employee name: '.$employee->getName(); // Employee name: John Doe 1234 | ``` 1235 | 1236 | **[⬆ Về mục lục](#mục-lục)** 1237 | 1238 | ## Lớp 1239 | 1240 | ### Ưu tiên thành phần hơn kế thừa 1241 | 1242 | Như đã nói trong [*Design Patterns*](https://en.wikipedia.org/wiki/Design_Patterns) nổi tiếng của Gang of Four, 1243 | bạn nên ưu tiên sử dụng "kiểu thành phần" hơn là "kiểu kế thừa". Có nhiều lý do để sử dụng kiểu kế thừa và cũng có nhiều nguyên nhân để sử dụng kiểu thành phần. 1244 | Điểm chính của sự tối đa hóa này là nếu bạn thích theo kiểu kế thừa, 1245 | hãy thử suy nghĩ "kiểu thành phần" có thể giúp giải quyết vấn đề tốt hơn không. Vì có một vài trường hợp nó sẽ tốt hơn. 1246 | 1247 | Có thể bạn sẽ tự hỏi, "khi nào thì nên dùng kế thừa?" Nó tùy thuộc vào từng vấn đề, khi nào thì kiểu kế thừa tốt hơn kiểu thành phần: 1248 | 1249 | 1. Kiểu kế thừa đó đại diện cho một mối quan hệ "is-a" (Ví dụ: Người->Động vật) chứ không phải mối quan hệ "has-a" (Người dùng->Thông tin người dùng). 1250 | 2. Bạn cần sử dụng lại code từ lớp cha (Người có thể di chuyển như động vật). 1251 | 3. Bạn muốn khi sửa đổi lớp cha thì tất cả lớp có liên quan sẽ thay đổi dễ dàng. 1252 | (Thay đổi lượng calo của tất cả động vật khi chúng di chuyển). 1253 | 1254 | **Chưa tốt:** 1255 | 1256 | ```php 1257 | class Employee 1258 | { 1259 | private $name; 1260 | private $email; 1261 | 1262 | public function __construct(string $name, string $email) 1263 | { 1264 | $this->name = $name; 1265 | $this->email = $email; 1266 | } 1267 | 1268 | // ... 1269 | } 1270 | 1271 | // Chưa tốt vì Employees "có" thuế. 1272 | // EmployeeTaxData không phải là một loại của Employee 1273 | 1274 | class EmployeeTaxData extends Employee 1275 | { 1276 | private $ssn; 1277 | private $salary; 1278 | 1279 | public function __construct(string $name, string $email, string $ssn, string $salary) 1280 | { 1281 | parent::__construct($name, $email); 1282 | 1283 | $this->ssn = $ssn; 1284 | $this->salary = $salary; 1285 | } 1286 | 1287 | // ... 1288 | } 1289 | ``` 1290 | 1291 | **Tốt:** 1292 | 1293 | ```php 1294 | class EmployeeTaxData 1295 | { 1296 | private $ssn; 1297 | private $salary; 1298 | 1299 | public function __construct(string $ssn, string $salary) 1300 | { 1301 | $this->ssn = $ssn; 1302 | $this->salary = $salary; 1303 | } 1304 | 1305 | // ... 1306 | } 1307 | 1308 | class Employee 1309 | { 1310 | private $name; 1311 | private $email; 1312 | private $taxData; 1313 | 1314 | public function __construct(string $name, string $email) 1315 | { 1316 | $this->name = $name; 1317 | $this->email = $email; 1318 | } 1319 | 1320 | public function setTaxData(string $ssn, string $salary) 1321 | { 1322 | $this->taxData = new EmployeeTaxData($ssn, $salary); 1323 | } 1324 | 1325 | // ... 1326 | } 1327 | ``` 1328 | 1329 | **[⬆ Về mục lục](#mục-lục)** 1330 | 1331 | ### Tránh viết fluent interfaces 1332 | 1333 | [Fluent interface](https://en.wikipedia.org/wiki/Fluent_interface) là một API hướng đối tượng có mục đích cải thiện tính dễ đọc của source code bằng cách 1334 | sử dụng [Method chaining](https://en.wikipedia.org/wiki/Method_chaining). 1335 | 1336 | Trong một số ngữ cảnh, thường là khi xây dựng object nơi mà pattern này giảm tính rườm rà của code (ví dụ [PHPUnit Mock Builder](https://phpunit.de/manual/current/en/test-doubles.html) 1337 | hoặc [Doctrine Query Builder](http://docs.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/query-builder.html)), 1338 | sẽ gây ra một số thiệt hại như sau: 1339 | 1340 | 1. Phá vỡ [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29) 1341 | 2. Phá vỡ [Decorators](https://en.wikipedia.org/wiki/Decorator_pattern) 1342 | 3. Khó tạo [mock](https://en.wikipedia.org/wiki/Mock_object) hơn trong test suite 1343 | 4. Khiến cho khó đọc "sự khác nhau giữa các file" hơn khi commit code 1344 | 1345 | Để biết thêm thông tin chi tiết, vui lòng đọc [bài viết](https://ocramius.github.io/blog/fluent-interfaces-are-evil/) 1346 | được viết bởi [Marco Pivetta](https://github.com/Ocramius). 1347 | 1348 | **Chưa tốt:** 1349 | 1350 | ```php 1351 | class Car 1352 | { 1353 | private $make = 'Honda'; 1354 | private $model = 'Accord'; 1355 | private $color = 'white'; 1356 | 1357 | public function setMake(string $make): self 1358 | { 1359 | $this->make = $make; 1360 | 1361 | // NOTE: Returning this for chaining 1362 | return $this; 1363 | } 1364 | 1365 | public function setModel(string $model): self 1366 | { 1367 | $this->model = $model; 1368 | 1369 | // NOTE: Returning this for chaining 1370 | return $this; 1371 | } 1372 | 1373 | public function setColor(string $color): self 1374 | { 1375 | $this->color = $color; 1376 | 1377 | // NOTE: Returning this for chaining 1378 | return $this; 1379 | } 1380 | 1381 | public function dump(): void 1382 | { 1383 | var_dump($this->make, $this->model, $this->color); 1384 | } 1385 | } 1386 | 1387 | $car = (new Car()) 1388 | ->setColor('pink') 1389 | ->setMake('Ford') 1390 | ->setModel('F-150') 1391 | ->dump(); 1392 | ``` 1393 | 1394 | **Tốt:** 1395 | 1396 | ```php 1397 | class Car 1398 | { 1399 | private $make = 'Honda'; 1400 | private $model = 'Accord'; 1401 | private $color = 'white'; 1402 | 1403 | public function setMake(string $make): void 1404 | { 1405 | $this->make = $make; 1406 | } 1407 | 1408 | public function setModel(string $model): void 1409 | { 1410 | $this->model = $model; 1411 | } 1412 | 1413 | public function setColor(string $color): void 1414 | { 1415 | $this->color = $color; 1416 | } 1417 | 1418 | public function dump(): void 1419 | { 1420 | var_dump($this->make, $this->model, $this->color); 1421 | } 1422 | } 1423 | 1424 | $car = new Car(); 1425 | $car->setColor('pink'); 1426 | $car->setMake('Ford'); 1427 | $car->setModel('F-150'); 1428 | $car->dump(); 1429 | ``` 1430 | 1431 | **[⬆ Về mục lục](#mục-lục)** 1432 | 1433 | ## SOLID 1434 | 1435 | **SOLID** là từ viết tắt được đưa ra bởi Michael Feathers cho 5 nguyên lý đầu tiên của Robert Martin, 5 nguyên tắc cơ bản của lập trình hướng đối tượng. 1436 | 1437 | * [S: Nguyên lý trách nhiệm duy nhất (SRP)](#single-responsibility-principle-srp) 1438 | * [O: Nguyên lý Đóng/Mở (OCP)](#openclosed-principle-ocp) 1439 | * [L: Nguyên lý thay thế Liskov (LSP)](#liskov-substitution-principle-lsp) 1440 | * [I: Nguyên lý phân tách interface (ISP)](#interface-segregation-principle-isp) 1441 | * [D: Nguyên lý đảo ngược dependencies (DIP)](#dependency-inversion-principle-dip) 1442 | 1443 | ### Nguyên lý trách nhiệm duy nhất (SRP) 1444 | 1445 | Như đã đề cập trong cuốn Clean Code, "Không nên có nhiều hơn một lý do để thay đổi class". 1446 | Viết một class với thật nhiều chức năng thì quá sướng. Vấn đề là class không có khái niệm liên kết và nó có khá nhiều lý do để thay đổi. 1447 | Nếu quá nhiều chức năng trong một class thì khi thay đổi gì đó mình không biết được hết những ảnh hưởng của nó đến các chức năng khác trong các module liên quan. 1448 | 1449 | **Chưa tốt:** 1450 | 1451 | ```php 1452 | class UserSettings 1453 | { 1454 | private $user; 1455 | 1456 | public function __construct(User $user) 1457 | { 1458 | $this->user = $user; 1459 | } 1460 | 1461 | public function changeSettings(array $settings): void 1462 | { 1463 | if ($this->verifyCredentials()) { 1464 | // ... 1465 | } 1466 | } 1467 | 1468 | private function verifyCredentials(): bool 1469 | { 1470 | // ... 1471 | } 1472 | } 1473 | ``` 1474 | 1475 | **Tốt:** 1476 | 1477 | ```php 1478 | class UserAuth 1479 | { 1480 | private $user; 1481 | 1482 | public function __construct(User $user) 1483 | { 1484 | $this->user = $user; 1485 | } 1486 | 1487 | public function verifyCredentials(): bool 1488 | { 1489 | // ... 1490 | } 1491 | } 1492 | 1493 | class UserSettings 1494 | { 1495 | private $user; 1496 | private $auth; 1497 | 1498 | public function __construct(User $user) 1499 | { 1500 | $this->user = $user; 1501 | $this->auth = new UserAuth($user); 1502 | } 1503 | 1504 | public function changeSettings(array $settings): void 1505 | { 1506 | if ($this->auth->verifyCredentials()) { 1507 | // ... 1508 | } 1509 | } 1510 | } 1511 | ``` 1512 | 1513 | **[⬆ Về mục lục](#mục-lục)** 1514 | 1515 | ### Nguyên lý Đóng/Mở (OCP) 1516 | 1517 | Như đã đề cập bởi Bertrand Meyer, "thực thể phần mềm (lớp, modules, hàm, 1518 | etc...) nên cho phép mở rộng, nhưng không cho phép sửa đổi." Điều đó có nghĩa là gì? Nguyên lý này đơn giản là nên cho phép người dùng 1519 | thêm mới mà không được thay đổi code hiện tại. 1520 | 1521 | **Chưa tốt:** 1522 | 1523 | ```php 1524 | abstract class Adapter 1525 | { 1526 | protected $name; 1527 | 1528 | public function getName(): string 1529 | { 1530 | return $this->name; 1531 | } 1532 | } 1533 | 1534 | class AjaxAdapter extends Adapter 1535 | { 1536 | public function __construct() 1537 | { 1538 | parent::__construct(); 1539 | 1540 | $this->name = 'ajaxAdapter'; 1541 | } 1542 | } 1543 | 1544 | class NodeAdapter extends Adapter 1545 | { 1546 | public function __construct() 1547 | { 1548 | parent::__construct(); 1549 | 1550 | $this->name = 'nodeAdapter'; 1551 | } 1552 | } 1553 | 1554 | class HttpRequester 1555 | { 1556 | private $adapter; 1557 | 1558 | public function __construct(Adapter $adapter) 1559 | { 1560 | $this->adapter = $adapter; 1561 | } 1562 | 1563 | public function fetch(string $url): Promise 1564 | { 1565 | $adapterName = $this->adapter->getName(); 1566 | 1567 | if ($adapterName === 'ajaxAdapter') { 1568 | return $this->makeAjaxCall($url); 1569 | } elseif ($adapterName === 'httpNodeAdapter') { 1570 | return $this->makeHttpCall($url); 1571 | } 1572 | } 1573 | 1574 | private function makeAjaxCall(string $url): Promise 1575 | { 1576 | // request and return promise 1577 | } 1578 | 1579 | private function makeHttpCall(string $url): Promise 1580 | { 1581 | // request and return promise 1582 | } 1583 | } 1584 | ``` 1585 | 1586 | **Tốt:** 1587 | 1588 | ```php 1589 | interface Adapter 1590 | { 1591 | public function request(string $url): Promise; 1592 | } 1593 | 1594 | class AjaxAdapter implements Adapter 1595 | { 1596 | public function request(string $url): Promise 1597 | { 1598 | // request and return promise 1599 | } 1600 | } 1601 | 1602 | class NodeAdapter implements Adapter 1603 | { 1604 | public function request(string $url): Promise 1605 | { 1606 | // request and return promise 1607 | } 1608 | } 1609 | 1610 | class HttpRequester 1611 | { 1612 | private $adapter; 1613 | 1614 | public function __construct(Adapter $adapter) 1615 | { 1616 | $this->adapter = $adapter; 1617 | } 1618 | 1619 | public function fetch(string $url): Promise 1620 | { 1621 | return $this->adapter->request($url); 1622 | } 1623 | } 1624 | ``` 1625 | 1626 | **[⬆ Về mục lục](#mục-lục)** 1627 | 1628 | ### Nguyên lý thay thế Liskov (LSP) 1629 | 1630 | Nguyên lý này được định nghĩa như sau "Nếu S là phụ thuộc của T, thì object của T có thể **được thay thế** bởi object của S 1631 | (nghĩa là object của S có thể thay thế object của T) mà không làm thay đổi các thuộc tính của chương trình(tính đúng đắn, công việc thực hiện,...)" 1632 | 1633 | Để dễ hiểu hơn, nếu bạn có một class cha và một class con, 1634 | sau đó class cha và class con có thể được sử dụng hoán đổi cho nhau mà không sai kết quả trả về. 1635 | Có thể vẫn còn khó hiểu, hãy xem ví dụ cơ bản Square-Rectangle bên dưới. 1636 | 1637 | Trong toán học, hình vuông là hình chữ nhật, nhưng nếu bạn sử dụng quan hệ "is-a" qua kế thừa, bạn sẽ gặp rắc rối. 1638 | 1639 | **Chưa tốt:** 1640 | 1641 | ```php 1642 | class Rectangle 1643 | { 1644 | protected $width = 0; 1645 | protected $height = 0; 1646 | 1647 | public function render(int $area): void 1648 | { 1649 | // ... 1650 | } 1651 | 1652 | public function setWidth(int $width): void 1653 | { 1654 | $this->width = $width; 1655 | } 1656 | 1657 | public function setHeight(int $height): void 1658 | { 1659 | $this->height = $height; 1660 | } 1661 | 1662 | public function getArea(): int 1663 | { 1664 | return $this->width * $this->height; 1665 | } 1666 | } 1667 | 1668 | class Square extends Rectangle 1669 | { 1670 | public function setWidth(int $width): void 1671 | { 1672 | $this->width = $this->height = $width; 1673 | } 1674 | 1675 | public function setHeight(int $height): void 1676 | { 1677 | $this->width = $this->height = $height; 1678 | } 1679 | } 1680 | 1681 | /** 1682 | * @param Rectangle[] $rectangles 1683 | */ 1684 | function renderLargeRectangles(array $rectangles): void 1685 | { 1686 | foreach ($rectangles as $rectangle) { 1687 | $rectangle->setWidth(4); 1688 | $rectangle->setHeight(5); 1689 | $area = $rectangle->getArea(); // Lỗi rồi: Đoạn này sẽ trả về 25, nhưng 20 mới là kết quả đúng. 1690 | $rectangle->render($area); 1691 | } 1692 | } 1693 | 1694 | $rectangles = [new Rectangle(), new Rectangle(), new Square()]; 1695 | renderLargeRectangles($rectangles); 1696 | ``` 1697 | 1698 | **Tốt:** 1699 | 1700 | ```php 1701 | abstract class Shape 1702 | { 1703 | abstract public function getArea(): int; 1704 | 1705 | public function render(int $area): void 1706 | { 1707 | // ... 1708 | } 1709 | } 1710 | 1711 | class Rectangle extends Shape 1712 | { 1713 | private $width; 1714 | private $height; 1715 | 1716 | public function __construct(int $width, int $height) 1717 | { 1718 | $this->width = $width; 1719 | $this->height = $height; 1720 | } 1721 | 1722 | public function getArea(): int 1723 | { 1724 | return $this->width * $this->height; 1725 | } 1726 | } 1727 | 1728 | class Square extends Shape 1729 | { 1730 | private $length; 1731 | 1732 | public function __construct(int $length) 1733 | { 1734 | $this->length = $length; 1735 | } 1736 | 1737 | public function getArea(): int 1738 | { 1739 | return pow($this->length, 2); 1740 | } 1741 | } 1742 | 1743 | /** 1744 | * @param Rectangle[] $rectangles 1745 | */ 1746 | function renderLargeRectangles(array $rectangles): void 1747 | { 1748 | foreach ($rectangles as $rectangle) { 1749 | $area = $rectangle->getArea(); 1750 | $rectangle->render($area); 1751 | } 1752 | } 1753 | 1754 | $shapes = [new Rectangle(4, 5), new Rectangle(4, 5), new Square(5)]; 1755 | renderLargeRectangles($shapes); 1756 | ``` 1757 | 1758 | **[⬆ Về mục lục](#mục-lục)** 1759 | 1760 | ### Nguyên lý phân tách interface (ISP) 1761 | 1762 | ISP đề cập rằng "Không nên ép người dùng phải phụ thuộc vào interface mà họ không sử dụng." 1763 | 1764 | Để hiểu ý nghĩa của nguyên tắc này, hãy nhìn vào những class yêu cầu một số lượng lớn các object cần phải inject vào để sử dụng. 1765 | Không yêu cầu người dùng phải inject số lượng lớn các tùy chọn là một lợi thế, bởi vì hầu hết chúng không cần thiết. 1766 | Hãy coi chúng là tùy chọn(có thể không dùng) để giúp cho interface bớt phình to. 1767 | 1768 | **Chưa tốt:** 1769 | 1770 | ```php 1771 | interface Employee 1772 | { 1773 | public function work(): void; 1774 | 1775 | public function eat(): void; 1776 | } 1777 | 1778 | class Human implements Employee 1779 | { 1780 | public function work(): void 1781 | { 1782 | // ....working 1783 | } 1784 | 1785 | public function eat(): void 1786 | { 1787 | // ...... eating in lunch break 1788 | } 1789 | } 1790 | 1791 | class Robot implements Employee 1792 | { 1793 | public function work(): void 1794 | { 1795 | //.... working much more 1796 | } 1797 | 1798 | public function eat(): void 1799 | { 1800 | //.... robot can't eat, but it must implement this method 1801 | } 1802 | } 1803 | ``` 1804 | 1805 | **Tốt:** 1806 | 1807 | Không phải tất cả worker đều là employee, nhưng employee là một worker. 1808 | 1809 | ```php 1810 | interface Workable 1811 | { 1812 | public function work(): void; 1813 | } 1814 | 1815 | interface Feedable 1816 | { 1817 | public function eat(): void; 1818 | } 1819 | 1820 | interface Employee extends Feedable, Workable 1821 | { 1822 | } 1823 | 1824 | class Human implements Employee 1825 | { 1826 | public function work(): void 1827 | { 1828 | // ....working 1829 | } 1830 | 1831 | public function eat(): void 1832 | { 1833 | //.... eating in lunch break 1834 | } 1835 | } 1836 | 1837 | // robot can only work 1838 | class Robot implements Workable 1839 | { 1840 | public function work(): void 1841 | { 1842 | // ....working 1843 | } 1844 | } 1845 | ``` 1846 | 1847 | **[⬆ Về mục lục](#mục-lục)** 1848 | 1849 | ### Nguyên lý đảo ngược dependencies (DIP) 1850 | 1851 | Nguyên lý này đề cập 2 vấn đề cơ bản: 1852 | 1. Module cấp cao không nên phụ thuộc vào module cấp thấp. Cả hai nên phụ thuộc vào abstract. 1853 | 2. Abstract không nên phụ thuộc vào chi tiết, mà phải ngược lại. 1854 | 1855 | Hơi khó hiểu một chút đúng không? Nhưng nếu bạn làm việc với PHP frameworks (ví dụ Symfony), bạn sẽ thấy nguyên tắc này được áp dụng trên Dependency 1856 | Injection(DI). Một lợi ích lớn của việc này là chúng giảm sự trùng lặp giữa các modules. Trùng lặp thì tất nhiên Chưa tốt vì 1857 | chúng khiến code khó refactor. 1858 | 1859 | **Chưa tốt:** 1860 | 1861 | ```php 1862 | class Employee 1863 | { 1864 | public function work(): void 1865 | { 1866 | // ....working 1867 | } 1868 | } 1869 | 1870 | class Robot extends Employee 1871 | { 1872 | public function work(): void 1873 | { 1874 | //.... working much more 1875 | } 1876 | } 1877 | 1878 | class Manager 1879 | { 1880 | private $employee; 1881 | 1882 | public function __construct(Employee $employee) 1883 | { 1884 | $this->employee = $employee; 1885 | } 1886 | 1887 | public function manage(): void 1888 | { 1889 | $this->employee->work(); 1890 | } 1891 | } 1892 | ``` 1893 | 1894 | **Tốt:** 1895 | 1896 | ```php 1897 | interface Employee 1898 | { 1899 | public function work(): void; 1900 | } 1901 | 1902 | class Human implements Employee 1903 | { 1904 | public function work(): void 1905 | { 1906 | // ....working 1907 | } 1908 | } 1909 | 1910 | class Robot implements Employee 1911 | { 1912 | public function work(): void 1913 | { 1914 | //.... working much more 1915 | } 1916 | } 1917 | 1918 | class Manager 1919 | { 1920 | private $employee; 1921 | 1922 | public function __construct(Employee $employee) 1923 | { 1924 | $this->employee = $employee; 1925 | } 1926 | 1927 | public function manage(): void 1928 | { 1929 | $this->employee->work(); 1930 | } 1931 | } 1932 | ``` 1933 | 1934 | **[⬆ Về mục lục](#mục-lục)** 1935 | 1936 | ## Nguyên lý đừng lặp lại chính mình (DRY) 1937 | 1938 | Đọc hiểu về nguyên lý [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) 1939 | 1940 | Tốt nhất nên chống lặp code ngay khi có thể. Vì lặp code không tốt tí nào, khi bạn muốn thay đổi logic bạn cần phải sửa nhiều chỗ. 1941 | 1942 | Hãy tưởng tượng bạn đang vận hành một nhà hàng và bạn theo dõi lượng hàng tồn kho của bạn: cà chua, hành, tỏi, gia vị,... 1943 | Nếu bạn có nhiều danh sách để quản lý chúng, bạn cần cập nhật tất cả các danh sách đó mỗi khi bạn bán một đĩa thức ăn. 1944 | Nhưng nếu như bạn chỉ có 1 danh sách, thì chỉ cần cập nhật ở một nơi! 1945 | 1946 | Thỉnh thoảng vẫn có lặp code bởi vì bạn có hai hoặc nhiều hơn những thứ khác nhau, có nhiều điểm chung, nhưng sự khác nhau 1947 | giữa chúng buộc bạn phải chia ra 2 hàm làm rất nhiều việc. 1948 | Để xóa bỏ lặp code, cần tạo ra một abstract có thể xử lý sự khác biệt giữa chúng với chỉ 1 hàm/module/lớp. 1949 | 1950 | Tạo ra được abstract tốt rất quan trọng và khó, đó là lý do tại sao bạn nên dựa theo các nguyên lý [SOLID](#solid) được đưa ra tại mục [Lớp](#lớp). 1951 | Abstract củ chuối có thể sẽ tệ hại hơn là lặp code, hãy cẩn thận! 1952 | Nếu có thể tạo một abstract tốt, hãy tạo nó! Đừng lặp lại code, nếu không bạn sẽ phải rất cực khổ mỗi khi muốn sửa đổi gì đó. 1953 | 1954 | **Chưa tốt:** 1955 | 1956 | ```php 1957 | function showDeveloperList(array $developers): void 1958 | { 1959 | foreach ($developers as $developer) { 1960 | $expectedSalary = $developer->calculateExpectedSalary(); 1961 | $experience = $developer->getExperience(); 1962 | $githubLink = $developer->getGithubLink(); 1963 | $data = [ 1964 | $expectedSalary, 1965 | $experience, 1966 | $githubLink 1967 | ]; 1968 | 1969 | render($data); 1970 | } 1971 | } 1972 | 1973 | function showManagerList(array $managers): void 1974 | { 1975 | foreach ($managers as $manager) { 1976 | $expectedSalary = $manager->calculateExpectedSalary(); 1977 | $experience = $manager->getExperience(); 1978 | $githubLink = $manager->getGithubLink(); 1979 | $data = [ 1980 | $expectedSalary, 1981 | $experience, 1982 | $githubLink 1983 | ]; 1984 | 1985 | render($data); 1986 | } 1987 | } 1988 | ``` 1989 | 1990 | **Tốt:** 1991 | 1992 | ```php 1993 | function showList(array $employees): void 1994 | { 1995 | foreach ($employees as $employee) { 1996 | $expectedSalary = $employee->calculateExpectedSalary(); 1997 | $experience = $employee->getExperience(); 1998 | $githubLink = $employee->getGithubLink(); 1999 | $data = [ 2000 | $expectedSalary, 2001 | $experience, 2002 | $githubLink 2003 | ]; 2004 | 2005 | render($data); 2006 | } 2007 | } 2008 | ``` 2009 | 2010 | **Rất tốt:** 2011 | 2012 | Sử dụng một phiên bản gọn hơn 2013 | 2014 | ```php 2015 | function showList(array $employees): void 2016 | { 2017 | foreach ($employees as $employee) { 2018 | render([ 2019 | $employee->calculateExpectedSalary(), 2020 | $employee->getExperience(), 2021 | $employee->getGithubLink() 2022 | ]); 2023 | } 2024 | } 2025 | ``` 2026 | 2027 | **[⬆ Về mục lục](#mục-lục)** 2028 | 2029 | ## Các ngôn ngữ khác 2030 | 2031 | * :cn: **Trung Quốc:** 2032 | * [php-cpm/clean-code-php](https://github.com/php-cpm/clean-code-php) 2033 | * :ru: **Nga:** 2034 | * [peter-gribanov/clean-code-php](https://github.com/peter-gribanov/clean-code-php) 2035 | * :es: **Tây Ban Nha:** 2036 | * [fikoborquez/clean-code-php](https://github.com/fikoborquez/clean-code-php) 2037 | * :brazil: **Bồ Đào Nha:** 2038 | * [fabioars/clean-code-php](https://github.com/fabioars/clean-code-php) 2039 | * [jeanjar/clean-code-php](https://github.com/jeanjar/clean-code-php/tree/pt-br) 2040 | * :thailand: **Thái Lan:** 2041 | * [panuwizzle/clean-code-php](https://github.com/panuwizzle/clean-code-php) 2042 | * :fr: **Pháp:** 2043 | * [errorname/clean-code-php](https://github.com/errorname/clean-code-php) 2044 | 2045 | **[⬆ Về mục lục](#mục-lục)** 2046 | --------------------------------------------------------------------------------