fopen - PHP code example

The PHP Function fopen

PHP is a flexible programming language that offers you the freedom to work with a variety of file formats. One of the most important tools that you'll use to create and manipulate files in PHP is the fopen() function. In this article, you'll learn how to open files using fopen() and the different modes available for writing data to them. You'll also be introduced to a method for writing to files in PHP that is more streamlined than the standard readfile() function and will help you avoid common errors during the process. Finally, you'll learn how to properly handle any errors that occur during the write process using functions like fclose() and feof().

fopen() is a built-in function that is derived from the C programming language and provides a way to access and manipulate a file's content. It takes two parameters: the file name and the mode in which you want to open it. The mode allows you to choose between reading, writing and appending data to a file.

Read and Write Modes

The "r" mode opens the file for reading, ignoring any existing content. The "w" mode opens the file for writing and, if the file does not exist, will create it. The "w+" mode is similar to the "w" mode but adds an additional reading mode to the behavior. The "a" mode opens the file for appending. This mode is the most considerate of the three and will only add data to the end of an existing file, rather than overwriting it completely.

fopen example

if (!$TraceFILE) {
            $zTracePrompt = 0;
        } elseif (!$zTracePrompt) {
            $TraceFILE = 0;
        }
        self::$yyTraceFILE = $TraceFILE;
        self::$yyTracePrompt = $zTracePrompt;
    }

    static function PrintTrace()
    {
        self::$yyTraceFILE = fopen('php://output', 'w');
        self::$yyTracePrompt = '<br>';
    }

    static public $yyTraceFILE;
    static public $yyTracePrompt;
    public $yyidx;                    /* Index of top element in stack */
    public $yyerrcnt;                 /* Shifts left before out of the error */
    public $yystack = array();  /* The parser's stack */

    public $yyTokenName = array(
  '$',             'OPENB',         'SECTION',       'CLOSEB',

$this->filename = (string) $filename;

            return $this->import_from_reader( $reader );
        }

        /** * @param string $filename * @return bool */
        public function export_to_file( $filename ) {
            $fh = fopen( $filename, 'wb' );
            if ( ! $fh ) {
                return false;
            }
            $res = $this->export_to_file_handle( $fh );
            fclose( $fh );
            return $res;
        }

        /** * @return string|false */

$question->setAutocompleterValues(['F⭐Y']);

        $dialog->ask($this->createStreamableInputInterfaceMock($inputStream), $output = $this->createOutputInterface(), $question);

        $stream = $output->getStream();
        rewind($stream);
        $this->assertStringEndsWith("\033[1D\033[K\033[2D\033[K\033[1D\033[K", stream_get_contents($stream));
    }

    protected function getInputStream($input)
    {
        $stream = fopen('php://memory', 'r+', false);
        fwrite($stream, $input);
        rewind($stream);

        return $stream;
    }

    protected function createOutputInterface()
    {
        return new StreamOutput(fopen('php://memory', 'r+', false));
    }

    /** * @dataProvider providerQueries * * @param string|array<string> $index */
    public function testProfiling(string|array $index, string $expectedUrl): void
    {
        $builder = new ClientBuilder();
        $builder->setHandler(fn () => new FutureArray(resolve([
            'status' => 200,
            'body' => fopen('php://memory', 'rb'),
            'transfer_stats' => [
                'total_time' => 0,
            ],
            'effective_url' => 'http://localhost:9200/test/_search',
        ])));

        $profiler = new ClientProfiler($builder->build());

        $request = ['index' => $index, 'body' => ['query' => ['match_all' => []]]];
        $profiler->search($request);

\ZipArchive::ER_NOENT => sprintf('No such zip file: \'%s\'', $file),
            \ZipArchive::ER_NOZIP => sprintf('\'%s\' is not a zip archive.', $file),
            \ZipArchive::ER_OPEN => sprintf('Can\'t open zip file: %s', $file),
            \ZipArchive::ER_READ => sprintf('Zip read error (%s)', $file),
            \ZipArchive::ER_SEEK => sprintf('Zip seek error (%s)', $file),
            default => sprintf('\'%s\' is not a valid zip archive, got error code: %d', $file, $retVal),
        };
    }

    private static function validateFileIsZip(string $filename): bool
    {
        $fp = fopen($filename, 'rb');

        if ($fp === false) {
            return false;
        }

        $bytes = fread($fp, 4);

        if ($bytes === false) {
            return false;
        }

        if ( ! copy( "$oldpath/$oldfile", "$site_dir/$newfile" ) ) {
            return false;
        }

        chmod( "$site_dir/$newfile", 0777 );

        // Update the blog header include in each file.         $lines = explode( "\n", implode( '', file( "$site_dir/$newfile" ) ) );
        if ( $lines ) {
            $f = fopen( "$site_dir/$newfile", 'w' );

            foreach ( $lines as $line ) {
                if ( preg_match( '/require.*wp-blog-header/', $line ) ) {
                    $line = '//' . $line;
                }

                // Update stylesheet references.                 $line = str_replace(
                    "<?php echo __get_option('siteurl'); ?>/wp-layout.css",
                    "<?php bloginfo('stylesheet_url'); ?>",
                    $line
                );

ob_start();
        } else {
            // The directory containing the original file may no longer exist when using a replication plugin.             wp_mkdir_p( dirname( $filename ) );
        }

        $result = call_user_func_array( $callback, $arguments );

        if ( $result && $stream ) {
            $contents = ob_get_contents();

            $fp = fopen( $filename, 'w' );

            if ( ! $fp ) {
                ob_end_clean();
                return false;
            }

            fwrite( $fp, $contents );
            fclose( $fp );
        }

        if ( $stream ) {

    function PasswordHash($iteration_count_log2, $portable_hashes)
    {
        self::__construct($iteration_count_log2, $portable_hashes);
    }

    function get_random_bytes($count)
    {
        $output = '';
        if (@is_readable('/dev/urandom') &&
            ($fh = @fopen('/dev/urandom', 'rb'))) {
            $output = fread($fh, $count);
            fclose($fh);
        }

        if (strlen($output) < $count) {
            $output = '';
            for ($i = 0; $i < $count; $i += 16) {
                $this->random_state =
                    md5(microtime() . $this->random_state);
                $output .= md5($this->random_state, TRUE);
            }

if ($this->mediaDirCreated) {
            rmdir($projectDir . '/public/media');
            $this->mediaDirCreated = false;
        }
    }

    public function testFetchRequestData(): void
    {
        $tempFile = (string) tempnam(sys_get_temp_dir(), '');

        $content = fopen(self::TEST_IMAGE, 'rb');
        static::assertIsResource($content);

        $request = new Request([], [], [], [], [], [], $content);
        $request->query->set('extension', 'png');

        $fileSize = filesize(self::TEST_IMAGE);
        $request->headers = new HeaderBag();
        $request->headers->set('content-length', (string) $fileSize);

        try {
            $this->fileFetcher->fetchRequestData(

return "SELECT $this->dataCol, $this->lifetimeCol FROM $this->table WHERE $this->idCol = :id";
    }

    /** * Returns an insert statement supported by the database for writing session data. */
    private function getInsertStatement(#[\SensitiveParameter] string $sessionId, string $sessionData, int $maxlifetime): \PDOStatement     {
        switch ($this->driver) {
            case 'oci':
                $data = fopen('php://memory', 'r+');
                fwrite($data, $sessionData);
                rewind($data);
                $sql = "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, EMPTY_BLOB(), :expiry, :time) RETURNING $this->dataCol into :data";
                break;
            default:
                $data = $sessionData;
                $sql = "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :expiry, :time)";
                break;
        }

        $stmt = $this->pdo->prepare($sql);

'result' => true,
                'voterDetails' => [],
            ]],
            'attributes' => [12],
            12345,
            [],
            true,
        ];
        yield [
            [[
                'attributes' => [new \stdClass()],
                'object' => $x = fopen(__FILE__, 'r'),
                'result' => true,
                'voterDetails' => [],
            ]],
            [new \stdClass()],
            $x,
            [],
            true,
        ];
        yield [
            [[
                'attributes' => ['ATTRIBUTE_2'],

        if ($xml_is_sane)
        {
            $xml = xml_parser_create_ns($this->encoding, $this->separator);
            xml_parser_set_option($xml, XML_OPTION_SKIP_WHITE, 1);
            xml_parser_set_option($xml, XML_OPTION_CASE_FOLDING, 0);
            xml_set_object($xml, $this);
            xml_set_character_data_handler($xml, 'cdata');
            xml_set_element_handler($xml, 'tag_open', 'tag_close');

            // Parse!             $wrapper = @is_writable(sys_get_temp_dir()) ? 'php://temp' : 'php://memory';
            if (($stream = fopen($wrapper, 'r+')) &&
                fwrite($stream, $data) &&
                rewind($stream))
            {
                //Parse by chunks not to use too much memory                 do
                {
                    $stream_data = fread($stream, 1048576);
                    if (!xml_parse($xml, $stream_data === false ? '' : $stream_data, feof($stream)))
                    {
                        $this->error_code = xml_get_error_code($xml);
                        $this->error_string = xml_error_string($this->error_code);

    public function bodyToString(): string
    {
        return $this->getEncoder()->encodeString($this->getBody(), $this->charset);
    }

    public function bodyToIterable(): iterable
    {
        if ($this->body instanceof File) {
            $path = $this->body->getPath();
            if (false === $handle = @fopen($path, 'r', false)) {
                throw new InvalidArgumentException(sprintf('Unable to open path "%s".', $path));
            }

            yield from $this->getEncoder()->encodeByteStream($handle);
        } elseif (null !== $this->seekable) {
            if ($this->seekable) {
                rewind($this->body);
            }
            yield from $this->getEncoder()->encodeByteStream($this->body);
        } else {
            yield $this->getEncoder()->encodeString($this->body);
        }

        return self::SUCCESS;
    }

    /** * @param array{"%%timestamp%%": int, "%%name%%": string, "%%namespace%%": string} $params */
    private function createMigrationFile(OutputInterface $output, string $directory, string $templatePatch, array $params): void
    {
        $path = rtrim($directory, '/') . '/Migration' . $params['%%timestamp%%'] . $params['%%name%%'] . '.php';
        $file = fopen($path, 'wb');
        if ($file === false) {
            return;
        }

        $template = file_get_contents($templatePatch);
        if ($template === false) {
            return;
        }

        fwrite($file, str_replace(array_keys($params), array_values($params), $template));
        fclose($file);

{ +"1": 2 } EOTXT
            ,
            $var
        );
    }

    public function testClosedResource()
    {
        $var = fopen(__FILE__, 'r');
        fclose($var);

        $dumper = new CliDumper('php://output');
        $dumper->setColors(false);
        $cloner = new VarCloner();
        $data = $cloner->cloneVar($var);

        ob_start();
        $dumper->dump($data);
        $out = ob_get_clean();
        $res = (int) $var;