week5

docs/coding-practices/exception.md

@@ -0,0 +1,67 @@
+# Xử lý lỗi
+- Sử dụng cơ chế xử lý lỗi trong PHP để bắt và xử lý các lỗi một cách chính xác. Đảm bảo rằng mã của bạn có khả năng xử lý các tình huống lỗi và cung cấp thông báo lỗi dễ hiểu.
+    ```php
+        <?php
+        // Mã "bad"
+        $number1 = 10;
+        $number2 = 0;
+        $result = $number1 / $number2;
+        echo "Kết quả: " . $result;
+        ?>
+    ```
+    - Trong ví dụ trên, chúng ta chia một số cho 0, gây ra lỗi chia cho 0 (division by zero). Mã này không xử lý lỗi và sẽ gây ra một lỗi ngoại lệ (exception) không được xử lý một cách chính xác gây khó khăn cho người dùng hoặc dev fix
+
+        ```php
+            <?php
+            // Mã "good"
+            $number1 = 10;
+            $number2 = 0;
+            try {
+            if ($number2 === 0) {
+            throw new Exception("Số bị chia không thể là 0.");
+            }
+            $result = $number1 / $number2;
+            echo "Kết quả: " . $result;
+            } catch (Exception $e) {
+            echo "Đã xảy ra lỗi: " . $e->getMessage();
+            }
+            ?>
+        ```
+    - Trong ví dụ này, chúng ta đã sử dụng cơ chế xử lý lỗi trong PHP bằng cách sử dụng câu lệnh try-catch. Chúng ta chỉ đơn giản in ra thông báo lỗi, nhưng bạn cũng có thể thực hiện các xử lý khác như ghi log, gửi email thông báo lỗi, hoặc chuyển hướng người dùng đến trang lỗi
+# Quản lý exception
+- Sử dụng các cấu trúc try-catch để xử lý ngoại lệ một cách rõ ràng và kiểm soát các lỗi không mong muốn. Điều này giúp ứng dụng của bạn trở nên bền vững và dễ bảo trì.
+    ```php
+        <?php
+        function divideNumbers($number1, $number2) {
+        if ($number2 === 0) {
+        echo "Lỗi: Số bị chia không thể là 0.";
+        return;
+        }
+        $result = $number1 / $number2;
+        echo "Kết quả: " . $result;
+        }
+
+        divideNumbers(10, 0);
+        ?>
+    ```
+    - Trong ví dụ trên, chúng ta kiểm tra điều kiện trước khi thực hiện phép chia và in ra thông báo lỗi nếu số bị chia là 0. Tuy nhiên, việc in ra thông báo lỗi trực tiếp trong hàm divideNumbers() là một cách xử lý lỗi không tốt. Nếu chúng ta muốn xử lý lỗi khác hoặc thay đổi cách thông báo lỗi, chúng ta phải sửa đổi mã nguồn của hàm này.
+
+        ```php
+        <?php
+        function divideNumbers($number1, $number2) {
+        if ($number2 === 0) {
+        throw new Exception("Số bị chia không thể là 0.");
+        }
+        $result = $number1 / $number2;
+        return $result;
+        }
+
+        try {
+        $result = divideNumbers(10, 0);
+        echo "Kết quả: " . $result;
+        } catch (Exception $e) {
+        echo "Đã xảy ra lỗi: " . $e->getMessage();
+        }
+        ?>
+        ```
+- Trong ví dụ này, chúng ta sử dụng cấu trúc try-catch để quản lý ngoại lệ. Hàm divideNumbers() ném ra một ngoại lệ nếu số bị chia là 0. Trong khối try, chúng ta gọi hàm divideNumbers() và gán kết quả vào biến $result. Nếu có ngoại lệ xảy ra, khối catch sẽ được thực thi và chúng ta có thể xử lý ngoại lệ đó bằng cách in ra thông báo lỗi.

docs/coding-practices/standard_function.md

@@ -0,0 +1,42 @@
+# Sử dụng các hàm chuẩn
+- Hãy tận dụng các hàm chuẩn của PHP để giảm sự lặp lại và tăng tính module hóa của code. Các hàm chuẩn bao gồm các chức năng xử lý chuỗi, mảng, thời gian và cơ sở dữ liệu
+    ```php
+        <?php
+            // Mã "bad"
+            $date = date('Y-m-d');
+            $uppercaseName = strtoupper("John Doe");
+            $arrayLength = count($myArray);
+        ?>
+    ```
+    - Trong ví dụ trên, chúng ta thực hiện các xử lý chuỗi, thời gian và mảng bằng cách sử dụng các hàm được tích hợp sẵn trong PHP. Tuy nhiên, chúng ta không tận dụng các hàm chuẩn một cách tối đa và lại lặp lại các đoạn mã xử lý
+
+- Mã "good"
+    ```php
+        <?php
+        // Mã "good"
+        $date = date('Y-m-d');
+        $uppercaseName = strtoupper("John Doe");
+        $arrayLength = count($myArray);
+
+        // Sử dụng các hàm chuẩn để tăng tính module hóa của code
+        function getCurrentDate() {
+            return date('Y-m-d');
+        }
+
+        function convertToUppercase($string) {
+            return strtoupper($string);
+        }
+
+        function getArrayLength($array) {
+            return count($array);
+        }
+
+        // Sử dụng các hàm chuẩn để thực hiện xử lý
+        $date = getCurrentDate();
+        $uppercaseName = convertToUppercase("John Doe");
+        $arrayLength = getArrayLength($myArray);
+        ?>
+    ```
+    - Trong ví dụ này, chúng ta đã tận dụng các hàm chuẩn để giảm sự lặp lại và tăng tính module hóa của code. Chúng ta đã tạo ra các hàm getCurrentDate(), convertToUppercase(), và getArrayLength() để thực hiện các xử lý tương ứng. Bằng cách này, chúng ta chỉ cần gọi các hàm này để thực hiện các xử lý, thay vì lặp lại các đoạn mã xử lý trong nhiều nơi.
+
+    - Sử dụng các hàm chuẩn giúp giảm sự lặp lại mã nguồn, tăng tính module hóa và dễ bảo trì. Ngoài ra, nếu cần thay đổi logic xử lý, chúng ta chỉ cần sửa đổi một lần trong hàm tương ứng, không cần phải sửa đổi từng đoạn mã được lặp lại trong code.