error_get_last - PHP code example

PHP Function Error_Get_Last

For PHP, the php function error_get_last gets information about the last error that occured. It can be helpful when working with debugging. It can help in tracing where the errors have occurred and when they occurred in your application.

Error handling is a necessary part of developing any web application. PHP allows you to handle errors in several ways with the exceptions, custom error handler, or by logging. Errors can be expected or unexpected and if not handled properly may cause a website to break or produce an error for the site visitor.

Many people add error reporting operators to their code to report errors to the screen but that is a bad practice as it interferes with the ability to correctly handle errors. A better practice is to let PHP generate and report the errors, ideally in an ini setting or.htaccess file, and then configure it to direct those errors appropriately. For example, on a dev server they should be shown on-screen and for production sites it may be more appropriate to log them.

In addition to the error_get_last() function, php provides a function called error_log() that allows you to log all errors into a file defined in the configuration settings of the web server. A popular use case is to log all exceptions that have occurred as the result of trying to set a handler for them. The logger function also allows you to see the errors in an associative array, which can be very useful for troubleshooting.

error_get_last example

        $e = error_reporting(0);

        try {
            $configureOptions($this->resolver);
            $this->resolver->resolve($options);
        } finally {
            error_reporting($e);
            restore_error_handler();
        }

        $lastError = error_get_last();
        unset($lastError['file'], $lastError['line']);

        $this->assertSame($expectedError, $lastError);
        $this->assertSame($expectedCount, $count);
    }

    public static function provideDeprecationData()
    {
        yield 'It deprecates an option with default message' => [
            function DOptionsResolver $resolver) {
                $resolver

            $object = $callback;
        } elseif (isset($callback[0])) { // array($object, 'method')             $object = $callback[0];
        }
        if (isset($object)) {
            try {
                $tmp = @serialize($callback);
            } catch (Exception $e) {
                Zend_Cache::throwException($e->getMessage());
            }
            if (!$tmp) {
                $lastErr = error_get_last();
                Zend_Cache::throwException("Can't serialize callback object to generate id: {$lastErr['message']}");
            }
            $name.= '__' . $tmp;
        }

        // generate a unique id for arguments         $argsStr = '';
        if ($args) {
            try {
                $argsStr = @serialize(array_values($args));
            } catch (Exception $e) {

$timezone = $this->now->getTimezone();

        $this->now = DatePoint::createFromInterface(new \DateTimeImmutable($now, $timezone))->setTimezone($timezone);
    }

    /** * @throws \DateMalformedStringException When $modifier is invalid */
    public function modify(string $modifier): void
    {
        if (\PHP_VERSION_ID < 80300) {
            $this->now = @$this->now->modify($modifier) ?: throw new \DateMalformedStringException(error_get_last()['message'] ?? sprintf('Invalid modifier: "%s". Could not modify MockClock.', $modifier));

            return;
        }

        $this->now = $this->now->modify($modifier);
    }

    /** * @throws \DateInvalidTimeZoneException When the timezone name is invalid */
    public function withTimeZone(\DateTimeZone|string $timezone): static
    {

private static ?bool $linkOnWindows = null;
    private static ?bool $symlinkOnWindows = null;

    public static function setUpBeforeClass(): void
    {
        if ('\\' === \DIRECTORY_SEPARATOR) {
            self::$linkOnWindows = true;
            $originFile = tempnam(sys_get_temp_dir(), 'li');
            $targetFile = tempnam(sys_get_temp_dir(), 'li');
            if (true !== @link($originFile, $targetFile)) {
                $report = error_get_last();
                if (\is_array($report) && str_contains($report['message'], 'error code(1314)')) {
                    self::$linkOnWindows = false;
                }
            } else {
                @unlink($targetFile);
            }

            self::$symlinkOnWindows = true;
            $originDir = tempnam(sys_get_temp_dir(), 'sl');
            $targetDir = tempnam(sys_get_temp_dir(), 'sl');
            if (true !== @symlink($originDir, $targetDir)) {

return (bool) $result;
    }

    /** * Recursively create the directories needed to write the static file */
    protected function _createDirectoriesFor($path)
    {
        if (!is_dir($path)) {
            $oldUmask = umask(0);
            if ( !@mkdir($path, $this->_octdec($this->_options['cache_directory_umask']), true)) {
                $lastErr = error_get_last();
                umask($oldUmask);
                Zend_Cache::throwException("Can't create directory: {$lastErr['message']}");
            }
            umask($oldUmask);
        }
    }

    /** * Detect serialization of data (cannot predict since this is the only way * to obey the interface yet pass in another parameter). * * In future, ZF 2.0, check if we can just avoid the interface restraints. * * This format is the only valid one possible for the class, so it's simple * to just run a regular expression for the starting serialized format. */

private function export(string $filename, string $data): void
    {
        $b64 = 'decrypt.private' === $filename ? '// SYMFONY_DECRYPTION_SECRET='.base64_encode($data)."\n" : '';
        $name = basename($this->pathPrefix.$filename);
        $data = str_replace('%', '\x', rawurlencode($data));
        $data = sprintf("<?php // %s on %s\n\n%sreturn \"%s\";\n", $name, date('r'), $b64, $data);

        $this->createSecretsDir();

        if (false === file_put_contents($this->pathPrefix.$filename.'.php', $data, \LOCK_EX)) {
            $e = error_get_last();
            throw new \ErrorException($e['message'] ?? 'Failed to write secrets data.', 0, $e['type'] ?? \E_USER_WARNING);
        }
    }

    private function createSecretsDir(): void
    {
        if ($this->secretsDir && !is_dir($this->secretsDir) && !@mkdir($this->secretsDir, 0777, true) && !is_dir($this->secretsDir)) {
            throw new \RuntimeException(sprintf('Unable to create the secrets directory (%s).', $this->secretsDir));
        }

        $this->secretsDir = null;
    }

    public function move(string $targetPath, ?string $name = null, bool $overwrite = false)
    {
        $targetPath = rtrim($targetPath, '/') . '/';
        $name ??= $this->getBaseName();
        $destination = $overwrite ? $targetPath . $name : $this->getDestination($targetPath . $name);

        $oldName = $this->getRealPath() ?: $this->__toString();

        if (! @rename($oldName, $destination)) {
            $error = error_get_last();

            throw FileException::forUnableToMove($this->getBasename(), $targetPath, strip_tags($error['message']));
        }

        @chmod($destination, 0777 & ~umask());

        return new self($destination);
    }

    /** * Returns the destination path for the move operation where overwriting is not expected. * * First, it checks whether the delimiter is present in the filename, if it is, then it checks whether the * last element is an integer as there may be cases that the delimiter may be present in the filename. * For the all other cases, it appends an integer starting from zero before the file's extension. */

        if (!$handler) {
            return;
        }
        if ($handler !== $h) {
            $handler[0]->setExceptionHandler($h);
        }
        $handler = $handler[0];
        $handlers = [];

        if ($exit = null === $error) {
            $error = error_get_last();
        }

        if ($error && $error['type'] &= \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR) {
            // Let's not throw anymore but keep logging             $handler->throwAt(0, true);
            $trace = $error['backtrace'] ?? null;

            if (str_starts_with($error['message'], 'Allowed memory') || str_starts_with($error['message'], 'Out of memory')) {
                $fatalError = new OutOfMemoryError($handler->levels[$error['type']].': '.$error['message'], 0, $error, 2, false, $trace);
            } else {
                $fatalError = new FatalError($handler->levels[$error['type']].': '.$error['message'], 0, $error, 2, true, $trace);
            }

if ( is_network_admin() ) {
    $admin_body_class .= ' network-admin';
}

$admin_body_class .= ' no-customize-support no-svg';

if ( $current_screen->is_block_editor() ) {
    $admin_body_class .= ' block-editor-page wp-embed-responsive';
}

$error_get_last = error_get_last();

// Print a CSS class to make PHP errors visible. if ( $error_get_last && WP_DEBUG && WP_DEBUG_DISPLAY && ini_get( 'display_errors' )
    // Don't print the class for PHP notices in wp-config.php, as they happen before WP_DEBUG takes effect,     // and should not be displayed with the `error_reporting` level previously set in wp-load.php.     && ( E_NOTICE !== $error_get_last['type'] || 'wp-config.php' !== wp_basename( $error_get_last['file'] ) )
) {
    $admin_body_class .= ' php-error';
}

unset( $error_get_last );

$handler->setDefaultLogger($logger);
        $handler->screamAt(\E_ALL);

        try {
            @trigger_error('Hello', \E_USER_WARNING);
            $expected = [
                'type' => \E_USER_WARNING,
                'message' => 'Hello',
                'file' => __FILE__,
                'line' => __LINE__ - 5,
            ];
            $this->assertSame($expected, error_get_last());
        } finally {
            restore_error_handler();
            restore_exception_handler();
        }
    }

    public function testNotice()
    {
        ErrorHandler::register();

        try {

$cmd->run();
    }

    /** * @group transient-on-windows */
    public function testThatProcessDoesNotThrowWarningDuringRun()
    {
        @trigger_error('Test Error', \E_USER_NOTICE);
        $process = $this->getProcessForCode('sleep(3)');
        $process->run();
        $actualError = error_get_last();
        $this->assertEquals('Test Error', $actualError['message']);
        $this->assertEquals(\E_USER_NOTICE, $actualError['type']);
    }

    public function testNegativeTimeoutFromConstructor()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->getProcess('', null, null, null, -1);
    }

    public function testNegativeTimeoutFromSetter()
    {

$validLocales = $this->getValidLocales();

        /** @var SplFileInfo $entry */
        foreach ($iterator as $entry) {
            if (!$entry->isFile() || substr($entry->getFilename(), -4) !== '.ini') {
                continue;
            }

            $data = @parse_ini_file($entry->getRealPath(), true);

            if ($data === false) {
                $error = error_get_last();
                if (\is_array($error)) {
                    $invalidSnippets[] = $error['message'] . ' (' . $entry->getRealPath() . ')';
                } else {
                    $invalidSnippets[] = 'Unknown error (' . $entry->getRealPath() . ')';
                }
                continue;
            }

            $dataRaw = @parse_ini_file($entry->getRealPath(), true, INI_SCANNER_RAW);

            if ($dataRaw === false) {

class TaskQueue implements TaskQueueInterface
{
    private $enableShutdown = true;
    private $queue = [];

    public function __construct(bool $withShutdown = true)
    {
        if ($withShutdown) {
            register_shutdown_function(function D): void {
                if ($this->enableShutdown) {
                    // Only run the tasks if an E_ERROR didn't occur.                     $err = error_get_last();
                    if (!$err || ($err['type'] ^ E_ERROR)) {
                        $this->run();
                    }
                }
            });
        }
    }

    public function isEmpty(): bool
    {
        return !$this->queue;
    }

return $response->toStream(false);
            }
        }

        if (null === $client && !method_exists($response, 'stream')) {
            throw new \InvalidArgumentException(sprintf('Providing a client to "%s()" is required when the response doesn\'t have any "stream()" method.', __CLASS__));
        }

        static $registered = false;

        if (!$registered = $registered || stream_wrapper_register(strtr(__CLASS__, '\\', '-'), __CLASS__)) {
            throw new \RuntimeException(error_get_last()['message'] ?? 'Registering the "symfony" stream wrapper failed.');
        }

        $context = [
            'client' => $client ?? $response,
            'response' => $response,
        ];

        return fopen(strtr(__CLASS__, '\\', '-').'://'.$response->getInfo('url'), 'r', false, stream_context_create(['symfony' => $context]));
    }

    public function getResponse(): ResponseInterface
    {

$this->hooks = $options['hooks'];

        $this->setup_handle($url, $headers, $data, $options);

        $options['hooks']->dispatch('curl.before_send', [&$this->handle]);

        if ($options['filename'] !== false) {
            // phpcs:ignore WordPress.PHP.NoSilencedErrors -- Silenced the PHP native warning in favour of throwing an exception.             $this->stream_handle = @fopen($options['filename'], 'wb');
            if ($this->stream_handle === false) {
                $error = error_get_last();
                throw new Exception($error['message'], 'fopen');
            }
        }

        $this->response_data       = '';
        $this->response_bytes      = 0;
        $this->response_byte_limit = false;
        if ($options['max_bytes'] !== false) {
            $this->response_byte_limit = $options['max_bytes'];
        }