Hướng dẫn how to catch fatal error in php - cách bắt lỗi nghiêm trọng trong php

Giải pháp tốt đẹp được tìm thấy trong Zend Framework 2:

/**
 * ErrorHandler that can be used to catch internal PHP errors
 * and convert to an ErrorException instance.
 */
abstract class ErrorHandler
{
    /**
     * Active stack
     *
     * @var array
     */
    protected static $stack = array();

    /**
     * Check if this error handler is active
     *
     * @return bool
     */
    public static function started()
    {
        return (bool) static::getNestedLevel();
    }

    /**
     * Get the current nested level
     *
     * @return int
     */
    public static function getNestedLevel()
    {
        return count(static::$stack);
    }

    /**
     * Starting the error handler
     *
     * @param int $errorLevel
     */
    public static function start($errorLevel = \E_WARNING)
    {
        if (!static::$stack) {
            set_error_handler(array(get_called_class(), 'addError'), $errorLevel);
        }

        static::$stack[] = null;
    }

    /**
     * Stopping the error handler
     *
     * @param  bool $throw Throw the ErrorException if any
     * @return null|ErrorException
     * @throws ErrorException If an error has been catched and $throw is true
     */
    public static function stop($throw = false)
    {
        $errorException = null;

        if (static::$stack) {
            $errorException = array_pop(static::$stack);

            if (!static::$stack) {
                restore_error_handler();
            }

            if ($errorException && $throw) {
                throw $errorException;
            }
        }

        return $errorException;
    }

    /**
     * Stop all active handler
     *
     * @return void
     */
    public static function clean()
    {
        if (static::$stack) {
            restore_error_handler();
        }

        static::$stack = array();
    }

    /**
     * Add an error to the stack
     *
     * @param int    $errno
     * @param string $errstr
     * @param string $errfile
     * @param int    $errline
     * @return void
     */
    public static function addError($errno, $errstr = '', $errfile = '', $errline = 0)
    {
        $stack = & static::$stack[count(static::$stack) - 1];
        $stack = new ErrorException($errstr, 0, $errno, $errfile, $errline, $stack);
    }
}

Lớp này cho phép bạn bắt đầu

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Sử dụng lớp này, ví dụ: như thế này:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Liên kết đến mã lớp đầy đủ: https://github.com/zendframework/zf2/blob/master/l Library/zend/stdlib/errorhandler.php
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Một giải pháp tốt hơn có lẽ là một giải pháp từ Monolog:

Liên kết đến mã lớp đầy đủ: https://github.com/seldaek/monolog/blob/master/src/monolog
https://github.com/Seldaek/monolog/blob/master/src/Monolog/ErrorHandler.php

Nó cũng có thể xử lý Fatal_errors bằng hàm

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

class ErrorHandler
{
    // [...]

    public function registerExceptionHandler($level = null, $callPrevious = true)
    {
        $prev = set_exception_handler(array($this, 'handleException'));
        $this->uncaughtExceptionLevel = $level;
        if ($callPrevious && $prev) {
            $this->previousExceptionHandler = $prev;
        }
    }

    public function registerErrorHandler(array $levelMap = array(), $callPrevious = true, $errorTypes = -1)
    {
        $prev = set_error_handler(array($this, 'handleError'), $errorTypes);
        $this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap);
        if ($callPrevious) {
            $this->previousErrorHandler = $prev ?: true;
        }
    }

    public function registerFatalHandler($level = null, $reservedMemorySize = 20)
    {
        register_shutdown_function(array($this, 'handleFatalError'));

        $this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
        $this->fatalLevel = $level;
    }

    // [...]
}

Giao diện mới

Mặc dù PHP 7 cung cấp cả hai lớp lỗi và ngoại lệ, hãy để kiểm tra giao diện có thể ném trước. Cả hai lớp lỗi và ngoại lệ đều thực hiện giao diện có thể ném - đó là cơ sở cho bất kỳ đối tượng nào có thể được ném qua câu lệnh ném. Nó chỉ có một ngoại lệ để thông báo, nó không thể được triển khai trực tiếp trong các lớp Userland, nhưng chỉ thông qua việc mở rộng lớp ngoại lệ. Ngoài ra, nó cung cấp một điểm duy nhất để bắt cả hai loại lỗi trong một câu lệnh:Error and Exception classes implement Throwable interface – it's a basis for any object that can be thrown via throw statement. It only has one exception to notice, it cannot be implemented in userland classes directly, but only through extending the Exception class. Also, it provides a single point for catching both types of error in a single statement:

try {
// your code
} catch (Throwable $e) {
   echo 'Very nice way to catch Exception and Error exceptions';
}

Danh sách các lớp ngoại lệ tích hợp có sẵn kể từ Php 7.4:

• Ngoại lệ
• ErrorException
• Lỗi
• ArbutionChoolror
• Arithmeticerror
• AssitSerror
• Sư đoàn
• Lỗi biên dịch
• Parseerror
• Kiểu hàng

Nhiều lớp ngoại lệ có thể được tìm thấy bên trong thư viện tiêu chuẩn PHP. Và một thứ đáng chú ý nhất xuất phát từ phần mở rộng JSON là lớp Jsoneoxception.

Lỗi, cái gì?

Trong các phiên bản trước của PHP, các lỗi được đối xử khá khác với ngoại lệ. Một lỗi là một cái gì đó được tạo ra trong động cơ và miễn là nó không gây tử vong, nó có thể được xử lý bởi một chức năng do người dùng xác định.

Vấn đề là có một số lỗi gây tử vong và không thể xử lý bằng trình xử lý lỗi do người dùng xác định. Điều này có nghĩa là bạn không thể xử lý các lỗi nghiêm trọng trong PHP một cách duyên dáng. Có một số tác dụng phụ có vấn đề, chẳng hạn như mất bối cảnh thời gian chạy, các kẻ hủy diệt sẽ không được gọi và đối phó với chúng là cồng kềnh. Trong Php 7, các lỗi nghiêm trọng hiện là ngoại lệ và chúng ta có thể xử lý chúng rất dễ dàng. Lỗi gây tử vong dẫn đến một ngoại lệ lỗi đang bị ném. Bạn cần xử lý các lỗi không gây tử vong với chức năng xử lý lỗi.

Dưới đây là một ví dụ về việc bắt một lỗi nghiêm trọng trong Php 7.1. Lưu ý cách không bị lỗi không gây tử vong.

 

try {
   // this will generate notice that would not be caught
   echo $someNotSetVariable;
   // fatal error that now actually is caught
   someNoneExistentFunction();
} catch (Error $e) {
      echo "Error caught: " . $e->getMessage();
}

Tập lệnh này sẽ xuất ra một lỗi thông báo cho nỗ lực truy cập một biến không hợp lệ. Cố gắng gọi một hàm không tồn tại sẽ dẫn đến một lỗi nghiêm trọng trong các phiên bản trước của PHP, nhưng trong PHP 7.1, bạn có thể bắt được nó. Đây là đầu ra cho tập lệnh:

Notice: Undefined variable: someNotSetVariable on line 3
Error caught: Call to undefined function someNoneExistentFunction()

Hằng số lỗi

PHP có rất nhiều hằng số được sử dụng liên quan đến lỗi. Các hằng số này được sử dụng khi định cấu hình PHP để ẩn hoặc hiển thị lỗi của một số lớp.

Dưới đây là một số mã lỗi thường thấy nhất:

• E_Deprecated - Trình thông dịch sẽ tạo loại cảnh báo này nếu bạn sử dụng tính năng ngôn ngữ không dùng nữa. Kịch bản chắc chắn sẽ tiếp tục chạy mà không có lỗi.
• E_Strict - Tương tự như e_deprecated, điều này cho thấy bạn đang sử dụng một tính năng ngôn ngữ hiện không tiêu chuẩn và có thể không hoạt động trong tương lai. Kịch bản sẽ tiếp tục chạy mà không có bất kỳ lỗi nào.
• E_Parse - Cú pháp của bạn không thể được phân tích cú pháp để tập lệnh của bạn giành được bắt đầu. Thực thi tập lệnh thậm chí sẽ không bắt đầu.
• E_NOTICE - Động cơ sẽ chỉ in ra một tin nhắn thông tin. Thực thi kịch bản đã giành được sự phá vỡ và không có lỗi nào sẽ bị ném.
• E_Error - tập lệnh không thể tiếp tục chạy và nó đang bị chấm dứt. Sẽ ném lỗi và cách xử lý chúng sẽ được xử lý tùy thuộc vào trình xử lý lỗi.
• E_RECOVERABLE_ERROR - Nó chỉ ra rằng một lỗi có lẽ nguy hiểm đã xảy ra, nhưng không để động cơ ở trạng thái không ổn định. Việc thực hiện thêm phụ thuộc vào trình xử lý lỗi và lỗi chắc chắn sẽ được ném.

Để biết danh sách đầy đủ các hằng số, vui lòng tham khảo hướng dẫn sử dụng PHP.

Hàm xử lý lỗi

Hàm set_error_handler () được sử dụng để cho PHP cách xử lý các lỗi động cơ tiêu chuẩn không phải là trường hợp của lớp ngoại lệ lỗi. Bạn không thể sử dụng chức năng xử lý lỗi cho các lỗi nghiêm trọng. Ngoại lệ lỗi phải được xử lý với các câu lệnh thử/bắt. set_error_handler () chấp nhận một tham số có thể gọi được. Các thiết bị gọi trong PHP có thể được chỉ định theo hai cách: bằng một chuỗi biểu thị tên của một hàm hoặc bằng cách truyền một mảng có chứa một đối tượng và tên của một phương thức (theo thứ tự đó). Bạn có thể chỉ định các phương thức được bảo vệ và riêng tư là có thể gọi trong một đối tượng. Bạn cũng có thể vượt qua NULL để bảo PHP trở lại việc sử dụng cơ chế xử lý lỗi tiêu chuẩn. Nếu trình xử lý lỗi của bạn không chấm dứt chương trình và trả về, tập lệnh của bạn sẽ tiếp tục thực thi theo dòng sau khi xảy ra lỗi xảy ra lỗi.set_error_handler() function is used to tell PHP how to handle standard engine errors that are not instances of the Error exception class. You cannot use an error-handler function for fatal errors. Error exceptions must be handled with try/catch statements. set_error_handler() accepts a callable as its parameter. Callables in PHP can be specified in two ways: either by a string denoting the name of a function or by passing an array that contains an object and the name of a method (in that order). You can specify protected and private methods as the callable in an object. You can also pass null to tell PHP to revert to the usage of the standard error-handling mechanism. If your error handler does not terminate the program and returns, your script will continue executing at the line after the one where the error occurred.

PHP chuyển các tham số cho chức năng xử lý lỗi của bạn. Bạn có thể tùy chọn khai báo chúng trong chữ ký chức năng nếu bạn muốn sử dụng chúng trong chức năng của mình.

Đây là một ví dụ về tùy chỉnh:

function myCustomErrorHandler(int $errNo, string $errMsg, string $file, int $line) {
echo "Wow my custom error handler got #[$errNo] occurred in [$file] at line [$line]: [$errMsg]";
}

set_error_handler('myCustomErrorHandler');

try {
   what;
} catch (Throwable $e) {
   echo 'And my error is: ' . $e->getMessage();
}

Nếu bạn chạy mã này trong bảng điều khiển PHP -A, bạn sẽ nhận được đầu ra tương tự:php -a you should receive similar output:

Error #[2] occurred in [php shell code] at line [3]: [Use of undefined constant what - assumed 'what' (this will throw an Error in a future version of PHP)]

Các thư viện PHP nổi bật nhất thực hiện việc sử dụng rộng rãi PHPTHER SET_ERROR_HANDLER () và có thể thực hiện các biểu hiện tốt đẹp của các trường hợp ngoại lệ và lỗi là whirops hoặc symony tựa gỡ lỗi & nbsp; và các thành phần ErrorHandler. Đề nghị của tôi là sử dụng một trong những điều đó. Nếu không, bạn luôn có thể lấy cảm hứng từ mã của họ. Trong khi thành phần gỡ lỗi có cách sử dụng rộng rãi trong hệ sinh thái Symfony, rất tiếc vẫn là thư viện được lựa chọn cho Laravel Framework. & NBSP;set_error_handler() and can do nice representations of exceptions and error are Whoops or Symony’s Debug and ErrorHandler components. My suggestion is to use one of those. If not, you can always draw inspiration from their code. While Debug component has extensive usage within the Symfony ecosystem, Whoops remains library of choice for Laravel framework. 

Để sử dụng chi tiết và nâng cao, vui lòng tham khảo hướng dẫn sử dụng PHP về xử lý lỗi.

Hiển thị hoặc đàn áp thông báo lỗi không gây tử vong

Khi ứng dụng của bạn đạt được sản xuất, bạn muốn ẩn tất cả các thông báo lỗi hệ thống trong khi sản xuất và mã của bạn phải chạy mà không tạo ra cảnh báo hoặc tin nhắn. Nếu bạn sẽ hiển thị một thông báo lỗi, hãy đảm bảo rằng đó là thông báo mà bạn đã tạo và nó không bao gồm thông tin có thể giúp kẻ tấn công đột nhập vào hệ thống của bạn.

Trong môi trường phát triển của bạn, bạn muốn tất cả các lỗi được hiển thị để bạn có thể khắc phục tất cả các vấn đề chúng liên quan, nhưng trong khi sản xuất, bạn muốn triệt tiêu bất kỳ tin nhắn hệ thống nào được gửi cho người dùng.

Để thực hiện điều này, bạn cần định cấu hình PHP bằng cách sử dụng các cài đặt sau trong tệp php.ini của mình:

• display_errors - có thể được đặt thành sai để đàn áp tin nhắn – can be set to false to suppress messages
• log_errors - có thể được sử dụng để lưu trữ thông báo lỗi trong các tệp nhật ký – can be used to store error messages in log files
• Error_Reporting - có thể được đặt để định cấu hình lỗi nào kích hoạt báo cáo – can be set to configure which errors trigger a report

Thực tiễn tốt nhất là xử lý các lỗi trong ứng dụng của bạn một cách duyên dáng. Trong sản xuất, bạn nên đăng nhập các lỗi chưa được xử lý thay vì cho phép chúng được hiển thị cho người dùng. Hàm error_log () có thể được sử dụng để gửi tin nhắn đến một trong các thói quen xử lý lỗi đã xác định. Bạn cũng có thể sử dụng hàm ERROR_LOG () để gửi email, nhưng cá nhân, thay vì sử dụng một giải pháp tốt để ghi nhật ký lỗi và nhận thông báo khi xảy ra lỗi như Sentry hoặc Rollbar.error_log() function can be used to send a message to one of the defined error handling routines. You can also use the error_log() function to send emails, but personally, would rather use a good solution for logging errors and receiving notifications when an error occurs like Sentry or Rollbar.

Có một điều gọi là toán tử điều khiển lỗi-dấu hiệu (@)-rằng trong bản chất có thể bỏ qua và loại bỏ các lỗi. Việc sử dụng rất dễ dàng-chỉ cần dự phòng bất kỳ biểu thức PHP nào với lỗi AT-SIGN và được tạo sẽ bị bỏ qua. Mặc dù sử dụng nhà điều hành này có thể trông thú vị, tôi khuyên bạn không nên làm điều đó. Tôi thích gọi nó là người sống từ quá khứ.Error Control Operator – the at-sign (@) – that in the essence can ignore and suppress errors. The usage is very easy – just prepend any PHP expression with at-sign and generated error will be ignored. Although using this operator may look interesting, I urge you not to do that. I like to call it the living relict from the past.

Thông tin thêm cho tất cả các chức năng liên quan đến lỗi PHP có thể được tìm thấy trong thủ công.

Ngoại lệ

Các trường hợp ngoại lệ là một phần cốt lõi của lập trình hướng đối tượng và lần đầu tiên được giới thiệu trong PHP 5.0. Một ngoại lệ là một trạng thái chương trình yêu cầu xử lý đặc biệt bởi vì nó không chạy theo cách mong đợi. Bạn có thể sử dụng một ngoại lệ để thay đổi luồng chương trình của mình, ví dụ, để ngừng làm điều gì đó nếu không được đáp ứng điều kiện tiên quyết nhất định.

Một ngoại lệ sẽ bong bóng qua ngăn xếp cuộc gọi nếu bạn không bắt được nó. Hãy để kiểm tra một ví dụ đơn giản:

try {
   print "this is our try block n";
   throw new Exception();
} catch (Exception $e) {
   print "something went wrong, caught yah!";
} finally {
   print "this part is always executed n";
}

PHP bao gồm một số loại ngoại lệ tiêu chuẩn và thư viện PHP tiêu chuẩn (SPL) bao gồm một vài loại nữa. Mặc dù bạn không phải sử dụng các trường hợp ngoại lệ này, nhưng làm như vậy có nghĩa là bạn có thể sử dụng báo cáo và phát hiện lỗi hạt mịn hơn. Các lớp ngoại lệ và lỗi đều thực hiện giao diện có thể ném và, giống như bất kỳ lớp nào khác, có thể được mở rộng. Điều này cho phép bạn tạo hệ thống phân cấp lỗi linh hoạt và điều chỉnh xử lý ngoại lệ của bạn. Chỉ một lớp thực hiện lớp ném có thể được sử dụng với từ khóa ném. Nói cách khác, bạn có thể khai báo lớp cơ sở của riêng bạn và sau đó ném nó như một ngoại lệ.

Mã mạnh mẽ có thể gặp phải lỗi và đối phó với nó. Xử lý các ngoại lệ một cách hợp lý giúp cải thiện tính bảo mật của ứng dụng của bạn và giúp ghi nhật ký và gỡ lỗi dễ dàng hơn. Quản lý lỗi trong ứng dụng của bạn cũng sẽ cho phép bạn cung cấp cho người dùng trải nghiệm tốt hơn. Trong phần này, chúng tôi đề cập đến cách bẫy và xử lý các lỗi xảy ra trong mã của bạn.

Nắm bắt ngoại lệ

Hãy cùng xem xét ví dụ đơn giản này:

class MyCustomException extends Exception { }

function throwMyCustomException() {
      throw new MyCustomException('There is something wrong.');
}

try {
   throwMyCustomException();
} catch (MyCustomException $e) {
   echo "Your custom exception caught ";
   echo $e->getMessage();
} catch (Exception $e) {
   echo "PHP base exception caught";
}

Như bạn có thể thấy, có hai mệnh đề bắt. Các trường hợp ngoại lệ sẽ được khớp với các mệnh đề từ trên xuống dưới cho đến khi loại ngoại lệ khớp với mệnh đề bắt. Chức năng némmyCustomException () rất đơn giản này ném myCustomException và chúng tôi hy vọng nó sẽ bị bắt trong khối đầu tiên. Bất kỳ trường hợp ngoại lệ nào khác sẽ xảy ra sẽ bị bắt bởi khối thứ hai. Ở đây chúng tôi đang gọi phương thức getMessage () từ lớp ngoại lệ cơ sở. Bạn có thể tìm thêm thông tin về phương pháp bổ sung trong tài liệu PHP ngoại lệ.

Bạn cũng có thể chỉ định nhiều ngoại lệ bằng cách tách chúng bằng ký tự (|).pipe (|) character.

Hãy cùng xem xét một ví dụ khác:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Khối đánh bắt rất đơn giản này sẽ bắt được các ngoại lệ của loại mycustomexception và myanothercustomexception.

Kịch bản bắt nâng cao hơn một chút:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Đây có phải là câu trả lời cuối cùng của bạn?

Trong Php 5.5 trở lên, một khối cuối cùng cũng có thể được chỉ định sau hoặc thay vì các khối bắt. Mã trong khối cuối cùng sẽ luôn được thực thi sau khi thử và bắt các khối, bất kể ngoại lệ có bị ném hay không, và trước khi thực hiện bình thường tiếp tục. Một cách sử dụng phổ biến cho khối cuối cùng là đóng kết nối cơ sở dữ liệu, nhưng cuối cùng có thể được sử dụng bất cứ nơi nào bạn muốn mã luôn được thực thi.finally block may also be specified after or instead of catch blocks. Code within the finally block will always be executed after the try and catch blocks, regardless of whether an exception has been thrown, and before normal execution resumes. One common use for the finally block is to close a database connection, but finally can be used wherever you want code to always be executed.

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Dưới đây là một ví dụ tốt để phù hợp với cách các câu lệnh bắt/cuối cùng của PHP/cuối cùng hoạt động:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Chức năng xử lý ngoại lệ

Bất kỳ ngoại lệ nào không bị bắt gặp đều có lỗi nghiêm trọng. Nếu bạn muốn trả lời một cách duyên dáng với các ngoại lệ không bị bắt trong các khối bắt, bạn sẽ cần phải đặt một chức năng làm trình xử lý ngoại lệ mặc định.

Để làm như vậy, bạn sử dụng hàm set_exception_handler (), chấp nhận một tham số có thể gọi là tham số của nó. Tập lệnh của bạn sẽ chấm dứt sau khi cuộc gọi có thể thực hiện được.set_exception_handler() function, which accepts a callable as its parameter. Your script will terminate after the callable has executed.

Hàm khôi phục_exception_handler () sẽ hoàn nguyên trình xử lý ngoại lệ về giá trị trước đó.restore_exception_handler() will revert the exception handler to its previous value.

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Ở đây, hàm Exception_Handler đơn giản sẽ được thực thi sau khi cuối cùng chặn khi không có loại ngoại lệ nào được khớp. Câu lệnh in cuối cùng sẽ không bao giờ được thực thi.

Để biết thêm thông tin tham khảo tài liệu PHP.

Cái tốt cũ t_paamayim_nekudotayim

Đây có lẽ là thông báo lỗi PHP nổi tiếng nhất từ ​​trước đến nay. Đã có nhiều tranh cãi về nó trong những năm gần đây. Bạn có thể đọc thêm trong một bài đăng trên blog tuyệt vời từ Phil Sturgeon. & NBSP; & NBSP;

Hôm nay tôi có thể tự hào nói nếu bạn chạy mã này với Php 7 No T_PAAMAYIM_NEKUDOTAYIM sẽ xảy ra:T_PAAMAYIM_NEKUDOTAYIM will occur:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Sự kết luận

Kể từ lần giới thiệu đầu tiên về xử lý ngoại lệ cho PHP, nhiều năm đã trôi qua cho đến khi chúng tôi kết thúc với khả năng xử lý đặc biệt vững chắc và trưởng thành hơn nhiều mà Java có, khá thẳng thắn từ lâu. Xử lý lỗi trong Php 7 nhận được nhiều sự chú ý khiến nó trở nên tốt đẹp, mở không gian cho các cải tiến trong tương lai nếu chúng ta thực sự từ quan điểm ngày nay cần một.

Chúng ta có thể bắt được lỗi nghiêm trọng trong PHP không?

Giải pháp cho lỗi nghiêm trọng trong PHP là gì?

Làm thế nào để bạn đối phó với các lỗi nghiêm trọng?

Làm thế nào tôi có thể nhận được 500 lỗi trong PHP?