fwrite - PHP code example

PHP Function fwrite

The php function fwrite is used to write content into an open file. It takes two parameters: a string to write and the number of bytes to write. The function can also be passed a special flag to indicate whether PHP should get an exclusive lock on the file. This can be helpful if you want to ensure that the data you’re writing to a file doesn’t overwrite something that another script might have written earlier.

To start using fwrite, you need to open the file that you want to work with by calling functions like fopen(). Next, specify the mode in which you’d like to work with the file. Lastly, write your data to the file.

There are three modes for writing to files: read mode ('r'), write mode ('w'), and append mode ('a'). In read mode, fopen ignores the file if it exists already and opens the file for reading only. In write mode, fopen opens the file for writing and creates the file if it doesn’t exist. And in append mode, fopen opens the file for appending and places its file pointer at the end of the existing file.

While the fwrite function is very powerful, it can be a bit intimidating for newcomers to file handling. There are other functions that can simplify the process, such as file_put_contents. And don’t forget to properly close the file by calling functions like fclose. This helps to ensure that any buffers and resources are flushed and freed up.

fwrite example

        $path = $this->getPath($key);

        if (!$overwrite && file_exists($path)) {
            return true;
        }

        if (isset($this->locks[$key])) {
            $fp = $this->locks[$key];
            @ftruncate($fp, 0);
            @fseek($fp, 0);
            $len = @fwrite($fp, $data);
            if (\strlen($data) !== $len) {
                @ftruncate($fp, 0);

                return false;
            }
        } else {
            if (!is_dir(\dirname($path)) && false === @mkdir(\dirname($path), 0777, true) && !is_dir(\dirname($path))) {
                return false;
            }

            $tmpFile = tempnam(\dirname($path), basename($path));

        if (! $this->fileNew) {
            ftruncate($this->fileHandle, 0);
            rewind($this->fileHandle);
        }

        if (($length = strlen($data)) > 0) {
            $result = null;

            for ($written = 0; $written < $length; $written += $result) {
                if (($result = fwrite($this->fileHandle, substr($data, $written))) === false) {
                    break;
                }
            }

            if (! is_int($result)) {
                $this->fingerprint = md5(substr($data, 0, $written));
                $this->logger->error('Session: Unable to write data.');

                return false;
            }
        }

if ( ! wp_mkdir_p( $exports_dir ) ) {
        wp_send_json_error( __( 'Unable to create personal data export folder.' ) );
    }

    // Protect export folder from browsing.     $index_pathname = $exports_dir . 'index.php';
    if ( ! file_exists( $index_pathname ) ) {
        $file = fopen( $index_pathname, 'w' );
        if ( false === $file ) {
            wp_send_json_error( __( 'Unable to protect personal data export folder from browsing.' ) );
        }
        fwrite( $file, "<?php\n// Silence is golden.\n" );
        fclose( $file );
    }

    $obscura              = wp_generate_password( 32, false, false );
    $file_basename        = 'wp-personal-data-file-' . $obscura;
    $html_report_filename = wp_unique_filename( $exports_dir, $file_basename . '.html' );
    $html_report_pathname = wp_normalize_path( $exports_dir . $html_report_filename );
    $json_report_filename = $file_basename . '.json';
    $json_report_pathname = wp_normalize_path( $exports_dir . $json_report_filename );

    /* * Gather general data needed. */

return array( 'error' => $message );
    }

    $ifp = @fopen( $new_file, 'wb' );
    if ( ! $ifp ) {
        return array(
            /* translators: %s: File name. */
            'error' => sprintf( __( 'Could not write file %s' ), $new_file ),
        );
    }

    fwrite( $ifp, $bits );
    fclose( $ifp );
    clearstatcache();

    // Set correct file permissions.     $stat  = @ stat( dirname( $new_file ) );
    $perms = $stat['mode'] & 0007777;
    $perms = $perms & 0000666;
    chmod( $new_file, $perms );
    clearstatcache();

    // Compute the URL.

$this->assertOutputContains(<<<EOT qqq: [0] foo >ccc> EOT
            , $output, true);
    }

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

        return $stream;
    }

    protected function createOutputInterface()
    {
        $output = new StreamOutput(fopen('php://memory', 'r+', false));
        $output->setDecorated(false);

        return $output;
    }

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 ) {
            ob_end_clean();
        }

        return $result;
    }

    /** * Returns first matched mime-type from extension, * as mapped from wp_get_mime_types() * * @since 3.5.0 * * @param string $extension * @return string|false */

class TestVarDumper {

  /** * A CLI handler for \Symfony\Component\VarDumper\VarDumper. */
  public static function cliHandler($var) {
    $cloner = new VarCloner();
    $dumper = new CliDumper();
    fwrite(STDOUT, "\n");
    $dumper->setColors(TRUE);
    $dumper->dump(
      $cloner->cloneVar($var),
      function D$line, $depth, $indent_pad) {
        // A negative depth means "end of dump".         if ($depth >= 0) {
          // Adds a two spaces indentation to the line.           fwrite(STDOUT, str_repeat($indent_pad, $depth) . $line . "\n");
        }
      }
    );
  }

                return $data_length;
            }

            if (($this->response_bytes + $data_length) > $this->response_byte_limit) {
                // Limit the length                 $limited_length = ($this->response_byte_limit - $this->response_bytes);
                $data           = substr($data, 0, $limited_length);
            }
        }

        if ($this->stream_handle) {
            fwrite($this->stream_handle, $data);
        } else {
            $this->response_data .= $data;
        }

        $this->response_bytes += strlen($data);
        return $data_length;
    }

    /** * Format a URL given GET data * * @param string $url Original URL. * @param array|object $data Data to build query using, see {@link https://www.php.net/http_build_query} * @return string URL with data */

$request .= "$v\r\n";
        }

        if(is_resource($body)) {
            $request .= "\r\n";
        } else {
            // Add the request body             $request .= "\r\n" . $body;
        }

        // Send the request         if (!@fwrite($this->socket, $request)) {
            throw new Zend_Http_Client_Adapter_Exception(
                'Error writing request to proxy server'
            );
        }

        if(is_resource($body)) {
            if(stream_copy_to_stream($body, $this->socket) == 0) {
                throw new Zend_Http_Client_Adapter_Exception(
                    'Error writing request to server'
                );
            }
        }

    /** * @dataProvider pipesCodeProvider */
    public function testSetStreamAsInput($code, $size)
    {
        $expected = str_repeat(str_repeat('*', 1024), $size).'!';
        $expectedLength = (1024 * $size) + 1;

        $stream = fopen('php://temporary', 'w+');
        fwrite($stream, $expected);
        rewind($stream);

        $p = $this->getProcessForCode($code);
        $p->setInput($stream);
        $p->run();

        fclose($stream);

        $this->assertEquals($expectedLength, \strlen($p->getOutput()));
        $this->assertEquals($expectedLength, \strlen($p->getErrorOutput()));
    }

public function getCurrentPosition(): array
    {
        static $isTtySupported;

        if (!$isTtySupported ??= '/' === \DIRECTORY_SEPARATOR && stream_isatty(\STDOUT)) {
            return [1, 1];
        }

        $sttyMode = shell_exec('stty -g');
        shell_exec('stty -icanon -echo');

        @fwrite($this->input, "\033[6n");

        $code = trim(fread($this->input, 1024));

        shell_exec(sprintf('stty %s', $sttyMode));

        sscanf($code, "\033[%d;%dR", $row, $col);

        return [$col, $row];
    }
}

$this->assertContains('Content-Type: application/x-www-form-urlencoded; charset=utf-8', $options['headers']);
    }

    public function testNormalizeBodyMultipart()
    {
        $file = fopen('php://memory', 'r+');
        stream_context_set_option($file, ['http' => [
            'filename' => 'test.txt',
            'content_type' => 'text/plain',
        ]]);
        fwrite($file, 'foobarbaz');
        rewind($file);

        $headers = [
            'content-type' => ['Content-Type: multipart/form-data; boundary=ABCDEF'],
        ];
        $body = [
            'foo[]' => 'bar',
            'bar' => [
                $file,
            ],
        ];

//If SMTP transcripts are left enabled, or debug output is posted online         //it can leak credentials, so hide credentials in all but lowest level         if (
            self::DEBUG_LOWLEVEL > $this->do_debug &&
            in_array($command, ['User & Password', 'Username', 'Password'], true)
        ) {
            $this->edebug('CLIENT -> SERVER: [credentials hidden]', self::DEBUG_CLIENT);
        } else {
            $this->edebug('CLIENT -> SERVER: ' . $data, self::DEBUG_CLIENT);
        }
        set_error_handler([$this, 'errorHandler']);
        $result = fwrite($this->smtp_conn, $data);
        restore_error_handler();

        return $result;
    }

    /** * Get the latest error. * * @return array */
    public function getError()
    {

        if (!file_exists($path)) {
            throw new RuntimeException(sprintf('File does not exist: "%s".', $path));
        }

        return 'file://'.str_replace('\\', '/', realpath($path));
    }

    protected function iteratorToFile(iterable $iterator, $stream): void
    {
        foreach ($iterator as $chunk) {
            fwrite($stream, $chunk);
        }
    }

    protected function convertMessageToSMimePart($stream, string $type, string $subtype): SMimePart
    {
        rewind($stream);

        $headers = '';

        while (!feof($stream)) {
            $buffer = fread($stream, 78);

namespace Shopware\Core\Content\ImportExport\Processing\Writer;

use Shopware\Core\Content\ImportExport\Struct\Config;
use Shopware\Core\Framework\Log\Package;

#[Package('system-settings')] class XmlFileWriter extends AbstractFileWriter
{
    public function append(Config $config, array $data, int $index): void
    {
        if ($index === 0) {
            fwrite($this->buffer, "<?xml version=\"1.0\"?><root>\n");
        }

        $item = new \SimpleXMLElement('<item/>');
        $this->addDataToNode($item, $data);
        /** @var string $xml */
        $xml = mb_strstr($item->asXML(), '<item>');
        fwrite($this->buffer, $xml);
    }

    public function finish(Config $config, string $targetPath): void
    {