PHP Function fgets - A Handy Tool For Working With Files

The php function fgets is a handy tool for working with files. It lets you grab a line from a file and return it as a string. It also has a nice feature that will automatically strip any "0" end-of-string terminator if it is present in your data.

As you work with files, it is important to have all the tools at your disposal. The php functions file, file_get_contents, and readfile all give you different ways to work with your data. Take the time to explore each of these and learn which one best suits your needs.

For example, if you want to parse your file into separate strings, the file() function will provide a single string for each line of text. While this is useful, you may find that it is easier to use the split() function and parse the data in chunks.

Another great feature of fgets is that it will stop reading at a specified length or EOF (end-of-file) whichever comes first. This can be helpful if you have large files and don't want to wait for the entire file to load.

You can also use the fgets function in conjunction with other streams, such as streams that have an associated buffer. This can be useful for handling large amounts of data and storing it in memory, such as with a cache. It is important to note that fgets works differently on Macintosh computers and it may not properly recognize line endings. This can be fixed by setting the auto_detect_line_endings run-time configuration option.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

fgets example

private function removeExpiredProfiles(): void
    {
        $minimalProfileTimestamp = time() - 2 * 86400;
        $file = $this->getIndexFilename();
        $handle = fopen($file, 'r');

        if ($offset = is_file($file.'.offset') ? (int) file_get_contents($file.'.offset') : 0) {
            fseek($handle, $offset);
        }

        while ($line = fgets($handle)) {
            $values = str_getcsv($line);

            if (7 !== \count($values)) {
                // skip invalid lines                 $offset += \strlen($line);
                continue;
            }

            [$csvToken, , , , $csvTime] = $values;

            if ($csvTime >= $minimalProfileTimestamp) {
                


        $process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);

        if (!\is_resource($process)) {
            throw new RuntimeException('Unable to launch a new process.');
        }
        $this->process = $process;
        $this->status = self::STATUS_STARTED;

        if (isset($descriptors[3])) {
            $this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
        }

        if ($this->tty) {
            return;
        }

        $this->updateStatus(false);
        $this->checkTimeout();
    }

    /** * Restarts the process. * * Be warned that the process is cloned before being started. * * @param callable|null $callback A PHP callback to run whenever there is some * output available on STDOUT or STDERR * * @throws RuntimeException When process can't be launched * @throws RuntimeException When process is already running * * @see start() * * @final */
return $value;
        }

        if (self::$stty && Terminal::hasSttyAvailable()) {
            $sttyMode = shell_exec('stty -g');
            shell_exec('stty -echo');
        } elseif ($this->isInteractiveInput($inputStream)) {
            throw new RuntimeException('Unable to hide the response.');
        }

        $value = fgets($inputStream, 4096);

        if (4095 === \strlen($value)) {
            $errOutput = $output instanceof ConsoleOutputInterface ? $output->getErrorOutput() : $output;
            $errOutput->warning('The value was possibly truncated by your shell or terminal emulator');
        }

        if (self::$stty && Terminal::hasSttyAvailable()) {
            shell_exec('stty '.$sttyMode);
        }

        if (false === $value) {
            
EOPHP;

while (false !== $file = fgets(\STDIN)) {
    $code = file_get_contents(substr($file, 0, -1));

    if (!str_contains($code, '@tentative-return-type')) {
        continue;
    }

    $code = preg_split('{^\s*(?:(?:abstract )?class|interface|trait) ([^\s]++)}m', $code, -1, \PREG_SPLIT_DELIM_CAPTURE);

    if (1 === count($code)) {
        continue;
    }

    
if (!$object instanceof \SplFileInfo) {
            throw new InvalidArgumentException('The object must be an instance of "\SplFileInfo".');
        }

        $mimeType = $this->getMimeType($object);
        $splFileObject = $this->extractSplFileObject($object);

        $data = '';

        $splFileObject->rewind();
        while (!$splFileObject->eof()) {
            $data .= $splFileObject->fgets();
        }

        if ('text' === explode('/', $mimeType, 2)[0]) {
            return sprintf('data:%s,%s', $mimeType, rawurlencode($data));
        }

        return sprintf('data:%s;base64,%s', $mimeType, base64_encode($data));
    }

    /** * @param array $context */
private function getLinesFromMarkedFile(string $path): array
    {
        $fp = fopen($path, 'rb+');
        if (!$fp) {
            // @codeCoverageIgnoreStart             return [[], [], []];
            // @codeCoverageIgnoreEnd         }

        $lines = [];
        while (!feof($fp)) {
            if ($line = fgets($fp)) {
                $lines[] = rtrim($line, "\r\n");
            }
        }

        $foundStart = false;
        $foundStop = false;
        $preLines = [];
        $postLines = [];
        $existingLines = [];

        foreach ($lines as $line) {
            
$this->assertEquals(0, $typed_data->validate()->count());
    $typed_data->setValue('invalidATexample.com');
    $this->assertEquals(1, $typed_data->validate()->count(), 'Validation detected invalid value.');

    // Binary type.     $typed_data = $this->createTypedData(['type' => 'binary'], $files[0]->getFileUri());
    $this->assertInstanceOf(BinaryInterface::class, $typed_data);
    $this->assertIsResource($typed_data->getValue());
    $this->assertEquals(0, $typed_data->validate()->count());
    // Try setting by URI.     $typed_data->setValue($files[1]->getFileUri());
    $this->assertEquals(fgets(fopen($files[1]->getFileUri(), 'r')), fgets($typed_data->getValue()), 'Binary value was changed.');
    $this->assertIsString($typed_data->getString());
    $this->assertEquals(0, $typed_data->validate()->count());
    // Try setting by resource.     $typed_data->setValue(fopen($files[2]->getFileUri(), 'r'));
    $this->assertEquals(fgets($typed_data->getValue()), fgets(fopen($files[2]->getFileUri(), 'r')), 'Binary value was changed.');
    $this->assertIsString($typed_data->getString());
    $this->assertEquals(0, $typed_data->validate()->count());
    $typed_data->setValue(NULL);
    $this->assertNull($typed_data->getValue(), 'Binary wrapper is null-able.');
    $this->assertEquals(0, $typed_data->validate()->count());
    $typed_data->setValue('invalid');
    
// TODO: implement             /** * @see Zend_Mail_Storage_Exception */
            throw new Zend_Mail_Storage_Exception('not implemented');
        }

        $fh = fopen($this->_getFileData($id, 'filename'), 'r');

        $content = '';
        while (!feof($fh)) {
            $line = fgets($fh);
            if (!trim($line)) {
                break;
            }
            $content .= $line;
        }

        fclose($fh);
        return $content;
    }

    /* * Get raw content of message or part * * @param int $id number of message * @param null|array|string $part path to part or null for messsage content * @return string raw content * @throws Zend_Mail_Storage_Exception */
/** * gets a stream variable * * @param string $variable the stream of the variable * @return mixed the value of the stream variable */
    public function getStreamVariable($variable)
    {
        $_result = '';
        $fp = fopen($variable, 'r+');
        if ($fp) {
            while (!feof($fp) && ($current_line = fgets($fp)) !== false ) {
                $_result .= $current_line;
            }
            fclose($fp);
            return $_result;
        }

        if ($this->smarty->error_unassigned) {
            throw new SmartyException('Undefined stream variable "' . $variable . '"');
        } else {
            return null;
        }
    }

  private function readLine() {
    // Read a line and set the stream finished indicator if it was not     // possible anymore.     $line = fgets($this->fd);
    $this->finished = ($line === FALSE);

    if (!$this->finished) {

      if ($this->lineNumber == 0) {
        // The first line might come with a UTF-8 BOM, which should be removed.         $line = str_replace("\xEF\xBB\xBF", '', $line);
        // Current plurality for 'msgstr[]'.         $this->currentPluralIndex = 0;
      }

      
$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 {
                    yield (int) $stream => fgets($stream);
                }
            }
        }
    }

    private function displayLog(OutputInterface $output, int $clientId, array $record): void
    {
        if (isset($record['log_id'])) {
            $clientId = unpack('H*', $record['log_id'])[1];
        }
        $logBlock = sprintf('<bg=%s> </>', self::BG_COLOR[$clientId % 8]);
        

    }

    /** * get the next line from socket with error checking, but nothing else * * @return string next line * @throws Zend_Mail_Protocol_Exception */
    protected function _nextLine()
    {
        $line = @fgets($this->_socket);
        if ($line === false) {
            /** * @see Zend_Mail_Protocol_Exception */
            throw new Zend_Mail_Protocol_Exception('cannot read - connection closed?');
        }

        return $line;
    }

    /** * get next line and assume it starts with $start. some requests give a simple * feedback so we can quickly check if we can go on. * * @param string $start the first bytes we assume to be in the next line * @return bool line starts with $start * @throws Zend_Mail_Protocol_Exception */
throw new RuntimeException(sprintf('The provided cwd "%s" does not exist.', $this->cwd));
        }

        $this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $this->options);

        if (!\is_resource($this->process)) {
            throw new RuntimeException('Unable to launch a new process.');
        }
        $this->status = self::STATUS_STARTED;

        if (isset($descriptors[3])) {
            $this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
        }

        if ($this->tty) {
            return;
        }

        $this->updateStatus(false);
        $this->checkTimeout();
    }

    /** * Restarts the process. * * Be warned that the process is cloned before being started. * * @param callable|null $callback A PHP callback to run whenever there is some * output available on STDOUT or STDERR * * @throws RuntimeException When process can't be launched * @throws RuntimeException When process is already running * * @see start() * * @final */
function _readmsg($fnction="_readmsg"){
        if(!$this->_connected) {
            $this->PushError($fnction, 'Connect first');
            return FALSE;
        }
        $result=true;
        $this->_message="";
        $this->_code=0;
        $go=true;
        do {
            $tmp=@fgets($this->_ftp_control_sock, 512);
            if($tmp===false) {
                $go=$result=false;
                $this->PushError($fnction,'Read failed');
            } else {
                $this->_message.=$tmp;
                if(preg_match("/^([0-9]{3})(-(.*[".CRLF."]{1,2})+\\1)? [^".CRLF."]+[".CRLF."]{1,2}$/", $this->_message, $regs)) $go=false;
            }
        } while($go);
        if($this->LocalEcho) echo "GET < ".rtrim($this->_message, CRLF).CRLF;
        $this->_code=(int)$regs[1];
        return $result;
    }
public function terminate(): void
    {
        $this->stream = $this->out = $this->in = null;
    }

    public function readLine(): string
    {
        if (feof($this->out)) {
            return '';
        }

        $line = fgets($this->out);
        if ('' === $line || false === $line) {
            $metas = stream_get_meta_data($this->out);
            if ($metas['timed_out']) {
                throw new TransportException(sprintf('Connection to "%s" timed out.', $this->getReadConnectionDescription()));
            }
            if ($metas['eof']) {
                throw new TransportException(sprintf('Connection to "%s" has been closed unexpectedly.', $this->getReadConnectionDescription()));
            }
        }

        $this->debug .= sprintf('< %s', $line);

        
Home | Imprint | This part of the site doesn't use cookies.