file - PHP code example

What is a PHP Function File?

The php function file is the place in your site where you can define and call any user-defined functions. This allows you to add features to your website that can’t be achieved through plugins or the built-in WordPress functions.

Functions are essentially re-usable blocks of code. If you find yourself writing similar code on your site over and over with only slight variations it makes sense to break this into a function that can then be called from any page. This helps to keep your code readable and easier to troubleshoot.

A php function can return a value of any type, so it’s a great way to make your code more modular. This is because by splitting your code into different functions you can include only the necessary files into your main script. This reduces the overall size of your program and can be a good way to debug your code.

Variable scope is another advantage of using functions. By declaring a variable inside a function it’s not accessible outside that function, this helps to keep your variables isolated from each other.

Functions also allow you to pass values into your function at run time. This is done through what are called arguments. Arguments can be anything from a string to an integer. These are replaced at runtime by the values passed into the function. This makes your code much more dynamic and re-usable. It can also help you to avoid bugs as you’ll only have one place in your script for any errors to occur.

file example

return $logs;
    }

    private function getContainerCompilerLogs(string $compilerLogsFilepath = null): array
    {
        if (!is_file($compilerLogsFilepath)) {
            return [];
        }

        $logs = [];
        foreach (file($compilerLogsFilepath, \FILE_IGNORE_NEW_LINES) as $log) {
            $log = explode(': ', $log, 2);
            if (!isset($log[1]) || !preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+)++$/', $log[0])) {
                $log = ['Unknown Compiler Pass', implode(': ', $log)];
            }

            $logs[$log[0]][] = ['message' => $log[1]];
        }

        return $logs;
    }

$this->assertTrue(defined('APPPATH'));
    }

    public function testBaseUrlHasBeenSet()
    {
        $validation = Services::validation();

        $env = false;

        // Check the baseURL in .env         if (is_file(HOMEPATH . '.env')) {
            $env = preg_grep('/^app\.baseURL = ./', file(HOMEPATH . '.env')) !== false;
        }

        if ($env) {
            // BaseURL in .env is a valid URL?             // phpunit.xml.dist sets app.baseURL in $_SERVER             // So if you set app.baseURL in .env, it takes precedence             $config = new App();
            $this->assertTrue(
                $validation->check($config->baseURL, 'valid_url'),
                'baseURL "' . $config->baseURL . '" in .env is not valid URL'
            );
        }

    $this->assertNoErrorsLogged();

    $this->expectedExceptionMessage = 'Deforestation';
    \Drupal::state()->set('error_service_test.break_logger', TRUE);

    $this->drupalGet('');
    $this->assertSession()->statusCodeEquals(500);
    $this->assertSession()->pageTextContains('The website encountered an unexpected error. Please try again later.');
    $this->assertSession()->pageTextContains($this->expectedExceptionMessage);

    // Find fatal error logged to the error.log     $errors = file(\Drupal::root() . '/' . $this->siteDirectory . '/error.log');
    $this->assertCount(8, $errors, 'The error + the error that the logging service is broken has been written to the error log.');
    $this->assertStringContainsString('Failed to log error', $errors[0], 'The error handling logs when an error could not be logged to the logger.');

    $expected_path = \Drupal::root() . '/core/modules/system/tests/modules/error_service_test/src/MonkeysInTheControlRoom.php';
    $expected_line = 67;
    $expected_entry = "Failed to log error: Exception: Deforestation in Drupal\\error_service_test\\MonkeysInTheControlRoom->handle() (line {$expected_line} of {$expected_path})";
    $this->assertStringContainsString($expected_entry, $errors[0], 'Original error logged to the PHP error log when an exception is thrown by a logger');

    // The exception is expected. Do not interpret it as a test failure. Not     // using File API; a potential error must trigger a PHP warning.     unlink(\Drupal::root() . '/' . $this->siteDirectory . '/error.log');
  }

self::assertSame(1, preg_match('/[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}[\+-][0-9]{2}:[0-9]{2} '.preg_quote($expected[$k]).'/', $line), "\"$line\" do not match expected pattern \"$expected[$k]\"");
        }
    }

    /** * Return the log messages in order. * * @return string[] */
    public function getLogs(): array
    {
        return file($this->tmpFile, \FILE_IGNORE_NEW_LINES);
    }

    public function testImplements()
    {
        $this->assertInstanceOf(LoggerInterface::class, $this->logger);
    }

    /** * @dataProvider provideLevelsAndMessages */
    public function testLogsAtAllLevels($level, $message)
    {

/** * @return string[] */
    public function getCleanupFiles()
    {
        $cleanupFile = UPDATE_ASSET_PATH . '/cleanup.txt';
        if (!is_file($cleanupFile)) {
            return [];
        }

        $lines = file($cleanupFile, \FILE_IGNORE_NEW_LINES);

        $cleanupList = [];
        foreach ($lines as $path) {
            $realpath = $this->shopwarePath . '/' . $path;
            if (file_exists($realpath)) {
                $cleanupList[] = $realpath;
            }
        }

        return $cleanupList;
    }
}

    $result = $archive->addFile($path, basename($path));
    if (!$result) {
      throw new DriverException('File could not be added to zip archive.');
    }
    $result = $archive->close();
    if (!$result) {
      throw new DriverException('Zip archive could not be closed.');
    }

    try {
      $remotePath = $this->getWebDriverSession()->file(['file' => base64_encode(file_get_contents($tempFilename))]);

      // If no path is returned the file upload failed silently.       if (empty($remotePath)) {
        throw new UnknownError();
      }
    }
    catch (\Exception $e) {
      throw $e;
    }
    finally {
      unlink($tempFilename);
    }

foreach ($langcodes as $code) {
                $lang_file = $lang_path . 'phpmailer.lang-' . $code . '.php';
                if (static::fileIsAccessible($lang_file)) {
                    $foundFile = true;
                    break;
                }
            }

            if ($foundFile === false) {
                $foundlang = false;
            } else {
                $lines = file($lang_file);
                foreach ($lines as $line) {
                    //Translation file lines look like this:                     //$PHPMAILER_LANG['authenticate'] = 'SMTP-Fehler: Authentifizierung fehlgeschlagen.';                     //These files are parsed as text and not PHP so as to avoid the possibility of code injection                     //See https://blog.stevenlevithan.com/archives/match-quoted-string                     $matches = [];
                    if (
                        preg_match(
                            '/^\$PHPMAILER_LANG\[\'([a-z\d_]+)\'\]\s*=\s*(["\'])(.+)*?\2;/',
                            $line,
                            $matches
                        )

if (!is_file($path) || !is_readable($path)) {
            throw new InvalidArgumentException(sprintf('The "%s" file does not exist or is not readable.', $path));
        }

        if (!$this->isGuesserSupported()) {
            throw new LogicException(sprintf('The "%s" guesser is not supported.', __CLASS__));
        }

        if (false === $finfo = new \finfo(\FILEINFO_MIME_TYPE, $this->magicFile)) {
            return null;
        }
        $mimeType = $finfo->file($path);

        if ($mimeType && 0 === (\strlen($mimeType) % 2)) {
            $mimeStart = substr($mimeType, 0, \strlen($mimeType) >> 1);
            $mimeType = $mimeStart.$mimeStart === $mimeType ? $mimeStart : $mimeType;
        }

        return $mimeType;
    }
}

->configurator(['%baz_class%', 'configureStatic1']);

    $s->set('bar', FooClass::class)
        ->args(['foo', service('foo.baz'), new Parameter('foo_bar')])
        ->configurator([service('foo.baz'), 'configure']);

    $s->set('foo_bar', '%foo_class%')
        ->args([service('deprecated_service')])
        ->share(false);

    $s->set('method_call1', 'Bar\FooClass')
        ->file(realpath(__DIR__.'/../includes/foo.php'))
        ->call('setBar', [service('foo')])
        ->call('setBar', [service('foo2')->nullOnInvalid()])
        ->call('setBar', [service('foo3')->ignoreOnInvalid()])
        ->call('setBar', [service('foobaz')->ignoreOnInvalid()])
        ->call('setBar', [expr('service("foo").foo() ~ (container.hasParameter("foo") ? parameter("foo") : "default")')]);

    $s->set('foo_with_inline', 'Foo')
        ->call('setBar', [service('inlined')]);

    $s->set('inlined', 'Bar')
        ->property('pub', 'pub')

    /** * Reads entire file into an array. * * @since 2.7.0 * * @param string $file Path to the file. * @return array|false File contents in an array on success, false on failure. */
    public function get_contents_array( $file ) {
        return file( $this->sftp_path( $file ) );
    }

    /** * Writes a string to a file. * * @since 2.7.0 * * @param string $file Remote path to the file where to write the data. * @param string $contents The data to write. * @param int|false $mode Optional. The file permissions as octal number, usually 0644. * Default false. * @return bool True on success, false on failure. */

  public function processPhpErrorLogFile(string $error_log_path, string $test_class): bool {
    $found = FALSE;
    if (file_exists($error_log_path)) {
      foreach (file($error_log_path) as $line) {
        if (preg_match('/\[.*?\] (.*?): (.*?) in (.*) on line (\d+)/', $line, $match)) {
          // Parse PHP fatal errors for example: PHP Fatal error: Call to           // undefined function break_me() in /path/to/file.php on line 17           $this->insertLogEntry([
            'test_class' => $test_class,
            'status' => 'fail',
            'message' => $match[2],
            'message_group' => $match[1],
            'line' => $match[4],
            'file' => $match[3],
          ]);
        }

$io->success(sprintf('Cache for the "%s" environment (debug=%s) was successfully cleared.', $kernel->getEnvironment(), var_export($kernel->isDebug(), true)));

        return 0;
    }

    private function isNfs(string $dir): bool
    {
        static $mounts = null;

        if (null === $mounts) {
            $mounts = [];
            if ('/' === \DIRECTORY_SEPARATOR && $files = @file('/proc/mounts')) {
                foreach ($files as $mount) {
                    $mount = \array_slice(explode(' ', $mount), 1, -3);
                    if (!\in_array(array_pop($mount), ['vboxsf', 'nfs'])) {
                        continue;
                    }
                    $mounts[] = implode(' ', $mount).'/';
                }
            }
        }
        foreach ($mounts as $mount) {
            if (str_starts_with($dir, $mount)) {

Builder::saveRules(Builder::buildRules($emojisCodePoints));
Builder::saveRules(Builder::buildStripRules($emojisCodePoints));
Builder::saveRules(Builder::buildGitHubRules($emojisCodePoints));
Builder::saveRules(Builder::buildSlackRules($emojisCodePoints));

final class Builder
{
    private const TARGET_DIR = __DIR__.'/../data/transliterator/emoji/';

    public static function getEmojisCodePoints(): array
    {
        $lines = file(__DIR__.'/vendor/emoji-test.txt');

        $emojisCodePoints = [];
        foreach ($lines as $line) {
            $line = trim($line);
            if (!$line || str_starts_with($line, '#')) {
                continue;
            }

            // 263A FE0F ; fully-qualified # ☺️ E0.6 smiling face             preg_match('{^(?<codePoints>[\w ]+) +; [\w-]+ +# (?<emoji>.+) E\d+\.\d+ ?(?<name>.+)$}Uu', $line, $matches);
            if (!$matches) {

$dispatcher = new EventDispatcher();
        $kernel = $this->getHttpKernel($dispatcher, static fn () => null);

        try {
            $kernel->handle(new Request());

            $this->fail('The kernel should throw an exception.');
        } catch (ControllerDoesNotReturnResponseException $e) {
            $first = $e->getTrace()[0];

            // `file` index the array starting at 0, and __FILE__ starts at 1             $line = file($first['file'])[$first['line'] - 2];
            $this->assertStringContainsString('// call controller', $line);
        }
    }

    public function testHandleWhenTheControllerDoesNotReturnAResponseButAViewIsRegistered()
    {
        $dispatcher = new EventDispatcher();
        $dispatcher->addListener(KernelEvents::VIEW, function D$event) {
            $event->setResponse(new Response($event->getControllerResult()));
        });

static::assertSame($expectedData['issue'], $logEntry->getIssue());
        static::assertSame($expectedData['flag'], $logEntry->getFlag());
        static::assertSame($expectedData['author'], $logEntry->getAuthor());
        static::assertSame($expectedData['authorEmail'], $logEntry->getAuthorEmail());
        static::assertSame($expectedData['authorGithub'], $logEntry->getAuthorGitHub());
        static::assertSame($expectedData['core'], $logEntry->getCore());
        static::assertSame($expectedData['storefront'], $logEntry->getStorefront());
        static::assertSame($expectedData['admin'], $logEntry->getAdministration());
        static::assertSame($expectedData['api'], $logEntry->getApi());
        static::assertSame($expectedData['upgrade'], $logEntry->getUpgradeInformation());
        static::assertSame($expectedData['major'], $logEntry->getNextMajorVersionChanges());
        $lines = file($outFile);
        static::assertIsArray($lines);

        /** @var array<string> $templateLines */
        $templateLines = explode(\PHP_EOL, $logEntry->toTemplate());

        foreach ($lines as $index => $line) {
            static::assertSame(trim($line), trim($templateLines[$index]));
        }

        $result = self::getContainer()->get(ValidatorInterface::class)->validate($logEntry);