fclose - PHP code example

PHP File Functions

When developing PHP web applications that involve file operations, it's important to ensure proper error handling. This will prevent users from accessing files that don't exist and help developers debug errors. It's also best practice to validate and sanitize user input before performing any file operations such as reading or writing to prevent malicious file access. Using functions like realpath() and basename() will help you to do this. You should also use function like file_get_contents() or fopen() that return a value when they fail rather than just a null result. This will allow you to return detailed error information to the user.

PHP provides a rich set of file functions to enable developers to work with files and directories on a server or local computer. These include functions to open a file, rename a directory, move files and create symbolic links between files. In addition to this, PHP has a variety of other functions to work with strings, arrays and objects.

Among the most common file functions in PHP are fopen() and fclose(). The fopen() function allows you to open a file or URL with specific parameters. It accepts a $filename parameter that specifies the file to be opened and a $mode parameter that indicates the mode in which the file should be opened such as read or write.

The fclose() function closes the open file pointer specified by the $filename parameter. It returns a Boolean value of TRUE on success or FALSE on failure.

fclose example

                $this->sSmarty->assign('sArticles', $rows);
                $rows = [];

                $template = 'string:{foreach $sArticles as $sArticle}' . $this->sSettings['body'] . '{/foreach}';

                fwrite($handleResource, $this->sSmarty->fetch($template, $this->sFeedID));
            }
        }
        fwrite($handleResource, $this->sSmarty->fetch('string:' . $this->sSettings['footer'], $this->sFeedID));
        fclose($handleResource);
    }

    /** * @param int $articleID * @param string $separator * @param int|null $categoryID * @param string $field * * @return string */
    public function sGetArticleCategoryPath($articleID, $separator = ' > ', $categoryID = null, $field = 'name')
    {

if (\is_array($data[0])) {
            fputcsv($fp, array_keys($data[0]), ';');
        }

        foreach ($data as $value) {
            if (empty($value)) {
                continue;
            }
            fputcsv($fp, $value, ';');
        }
        fclose($fp);
    }

    /** * Internal helper function to get access to the entity manager. */
    private function getManager(): ModelManager
    {
        if ($this->manager === null) {
            $this->manager = $this->get('models');
        }

    public static function setFiles(array $files): array
    {
        $previousFiles = self::$files;
        self::$files = $files;

        foreach (self::$openedFiles as $file) {
            if ($file) {
                flock($file, \LOCK_UN);
                fclose($file);
            }
        }
        self::$openedFiles = self::$lockedFiles = [];

        return $previousFiles;
    }

    public static function compute(callable $callback, ItemInterface $item, bool &$save, CacheInterface $pool, \Closure $setMetadata = null, LoggerInterface $logger = null): mixed
    {
        if ('\\' === \DIRECTORY_SEPARATOR && null === self::$lockedFiles) {
            // disable locking on Windows by default

        if ($this->fileHandle === null) {
            $this->fileNew = ! is_file($this->filePath . $id);

            if (($this->fileHandle = fopen($this->filePath . $id, 'c+b')) === false) {
                $this->logger->error("Session: Unable to open file '" . $this->filePath . $id . "'.");

                return false;
            }

            if (flock($this->fileHandle, LOCK_EX) === false) {
                $this->logger->error("Session: Unable to obtain lock for file '" . $this->filePath . $id . "'.");
                fclose($this->fileHandle);
                $this->fileHandle = null;

                return false;
            }

            if (! isset($this->sessionID)) {
                $this->sessionID = $id;
            }

            if ($this->fileNew) {
                chmod($this->filePath . $id, 0600);

$fp = fopen($path, $mode);

            flock($fp, LOCK_EX);

            for ($result = $written = 0, $length = strlen($data); $written < $length; $written += $result) {
                if (($result = fwrite($fp, substr($data, $written))) === false) {
                    break;
                }
            }

            flock($fp, LOCK_UN);
            fclose($fp);

            return is_int($result);
        } catch (Throwable $e) {
            return false;
        }
    }
}

if (! function_exists('delete_files')) {
    /** * Delete Files * * Deletes all files contained in the supplied directory path. * Files must be writable or owned by the system in order to be deleted. * If the second parameter is set to true, any directories contained * within the supplied base directory will be nuked as well. * * @param string $path File path * @param bool $delDir Whether to delete any directories found in the path * @param bool $htdocs Whether to skip deleting .htaccess and index page files * @param bool $hidden Whether to include hidden files (files beginning with a period) */

for ($i = 0; $i < 10; ++$i) {
            $read = $sockets;
            stream_select($read, $write, $write, null);

            foreach ($read as $stream) {
                if ($socket === $stream) {
                    $stream = stream_socket_accept($socket);
                    $sockets[(int) $stream] = $stream;
                } elseif (feof($stream)) {
                    unset($sockets[(int) $stream]);
                    fclose($stream);
                } else {
                    $message = fgets($stream);
                    fclose($stream);

                    $record = unserialize(base64_decode($message));
                    $this->assertIsArray($record);

                    $this->assertArrayHasKey('message', $record);
                    $this->assertEquals('My info message', $record['message']);

                    $this->assertArrayHasKey('extra', $record);

while (!feof($this->stream)) {
            stream_get_line($this->stream, 1000000, ";\n");
            ++$this->count;
        }

        $this->rewind();
    }

    public function __destruct()
    {
        if ($this->stream !== null) {
            fclose($this->stream);
        }
    }

    /** * @param int $position * * @throws OutOfBoundsException */
    #[ReturnTypeWillChange]     public function seek($position)
    {

public function fetchRequestData(Request $request, string $fileName): MediaFile
    {
        $extension = $this->getExtensionFromRequest($request);
        $expectedLength = (int) $request->headers->get('content-length');

        $inputStream = $request->getContent(true);
        $destStream = $this->openDestinationStream($fileName);

        try {
            $bytesWritten = $this->copyStreams($inputStream, $destStream, 0);
        } finally {
            fclose($inputStream);
            fclose($destStream);
        }

        if ($expectedLength !== $bytesWritten) {
            throw MediaException::invalidContentLength();
        }

        return new MediaFile(
            $fileName,
            (string) mime_content_type($fileName),
            $extension,

    protected function setPath(string $path): string
    {
        if (! is_dir($path)) {
            mkdir($path, 0777, true);
            // create the index.html file             if (! is_file($path . 'index.html')) {
                $file = fopen($path . 'index.html', 'x+b');
                fclose($file);
            }
        }

        return $path;
    }

    /** * Returns whether the file has been moved or not. If it has, * the move() method will not work and certain properties, like * the tempName, will no longer be available. */

  protected function checkPortIsAvailable($port) {
    $fp = @fsockopen(self::$hostName, $port, $errno, $errstr, 1);
    // If fsockopen() fails to connect, probably nothing is listening.     // It could be a firewall but that's impossible to detect, so as a     // best guess let's return it as available.     if ($fp === FALSE) {
      return TRUE;
    }
    else {
      fclose($fp);
    }
    return FALSE;
  }

  /** * Get the port number for requests. * * Test should never call this. Used by standUpServer(). * * @return int */

$tempfile   = wp_tempnam( $file );
        $temphandle = fopen( $tempfile, 'w+' );

        if ( ! $temphandle ) {
            unlink( $tempfile );
            return false;
        }

        mbstring_binary_safe_encoding();

        if ( ! $this->ftp->fget( $temphandle, $file ) ) {
            fclose( $temphandle );
            unlink( $tempfile );

            reset_mbstring_encoding();

            return ''; // Blank document. File does exist, it's just blank.         }

        reset_mbstring_encoding();

        fseek( $temphandle, 0 ); // Skip back to the start of the file being written to.         $contents = '';

$this->logger->error('Temporary file could not be created for file upload.');
      throw new HttpException(500, 'Temporary file could not be created');
    }
    $temp_file = fopen($temp_file_path, 'wb');

    if ($temp_file) {
      while (!feof($file_data)) {
        $read = fread($file_data, static::BYTES_TO_READ);

        if ($read === FALSE) {
          // Close the file streams.           fclose($temp_file);
          fclose($file_data);
          $this->logger->error('Input data could not be read');
          throw new HttpException(500, 'Input file data could not be read.');
        }

        if (fwrite($temp_file, $read) === FALSE) {
          // Close the file streams.           fclose($temp_file);
          fclose($file_data);
          $this->logger->error('Temporary file data for "%path" could not be written', ['%path' => $temp_file_path]);
          throw new HttpException(500, 'Temporary file data could not be written.');
        }

if ("\n" !== substr($this->header, -1, 1)) {
                fwrite($buffer, "\n");
            }
        }

        if (0 !== count($diff)) {
            $this->writeDiffHunks($buffer, $diff);
        }

        $diff = stream_get_contents($buffer, -1, 0);

        fclose($buffer);

        // If the diff is non-empty and last char is not a linebreak: add it.         // This might happen when both the `from` and `to` do not have a trailing linebreak         $last = substr($diff, -1);

        return 0 !== strlen($diff) && "\n" !== $last && "\r" !== $last
            ? $diff . "\n"
            : $diff;
    }

    private function writeDiffHunks($output, array $diff): void
    {

        if (!self::$file) {
            self::$file = fopen(__FILE__, 'r');
        }

        return self::$file;
    }

    public static function tearDownAfterClass(): void
    {
        if (self::$file) {
            fclose(self::$file);
            self::$file = null;
        }
    }
}

/** * @return bool */
        public function feof() {
            return feof( $this->_f );
        }

        /** * @return bool */
        public function close() {
            return fclose( $this->_f );
        }

        /** * @return string */
        public function read_all() {
            return stream_get_contents( $this->_f );
        }
    }
endif;