glob - PHP code example

PHP Function Glob

A php function glob is used to search for filenames and directories based on pattern. The function returns an array of filenames if it finds any. It also ignores hidden files like.gitignore and dotfiles.

The php function glob accepts two parameters in its implementation: the $pattern and the $flags. The first parameter is the pattern of file or folder that you want to search. The second parameter can include additional settings that influence the behavior of the glob function. For example, you can set the flags to GLOB_MARK to add a slash with each returned item or GLOB_NOSORT to prevent sorting.

Another setting you can use is the GLOB_BRACE to expand characters from a group to match e.g. 'a,b,c' matches 'jpg,gif,png'. This is useful if you want to find image files. You can learn more about these settings by reading the glob manual page.

Using the php function glob can be a little slow because it needs to build an array of files and then return it. It is possible to speed up the process by using alternatives such as readdir(), foreach() and array_flip().

However, the advantage of glob() is that it handles symbolic filesystem links nicely. This makes it better than other functions that do not handle symlinks such as scandir() and rglob().

glob example

use Symfony\Component\Cache\LockRegistry;

class LockRegistryTest extends TestCase
{
    public function testFiles()
    {
        if ('\\' === \DIRECTORY_SEPARATOR) {
            $this->markTestSkipped('LockRegistry is disabled on Windows');
        }
        $lockFiles = LockRegistry::setFiles([]);
        LockRegistry::setFiles($lockFiles);
        $expected = array_map('realpath', glob(__DIR__.'/../Adapter/*.php'));
        $this->assertSame($expected, $lockFiles);
    }
}

    /** * Returns all locales found in the given directory. * * @return array An array of locales. The result also contains locales that * are in fact just aliases for other locales. Use * {@link scanAliases()} to determine which of the locales * are aliases */
    public function scanLocales(string $sourceDir): array
    {
        $locales = glob($sourceDir.'/*.txt', \GLOB_NOSORT);

        // Remove file extension and sort         array_walk($locales, function D&$locale) { $locale = basename($locale, '.txt'); });

        // Remove non-locales         $locales = array_filter($locales, fn ($locale) => preg_match('/^[a-z]{2}(_.+)?$/', $locale));

        sort($locales);

        return $locales;
    }

/** * This method is here to simulate the extra level from the piece of code * triggering an error to the error handler. */
    public function debugBacktrace()
    {
        return debug_backtrace();
    }

    private static function removeDir($dir)
    {
        $files = glob($dir.'/*');
        foreach ($files as $file) {
            if (is_file($file)) {
                unlink($file);
            } else {
                self::removeDir($file);
            }
        }
        rmdir($dir);
    }

    public static function setupBeforeClass(): void
    {

        $this->iniSet('session.save_handler', 'files');
        $this->iniSet('session.save_path', $this->savePath = sys_get_temp_dir().'/sftest');
        if (!is_dir($this->savePath)) {
            mkdir($this->savePath);
        }
    }

    protected function tearDown(): void
    {
        session_write_close();
        array_map('unlink', glob($this->savePath.'/*'));
        if (is_dir($this->savePath)) {
            @rmdir($this->savePath);
        }
    }

    protected function getStorage(): PhpBridgeSessionStorage
    {
        $storage = new PhpBridgeSessionStorage();
        $storage->registerBag(new AttributeBag());

        return $storage;
    }

if ( is_wp_error( $source ) ) {
            return $source;
        }

        $working_directory = str_replace( $wp_filesystem->wp_content_dir(), trailingslashit( WP_CONTENT_DIR ), $source );
        if ( ! is_dir( $working_directory ) ) { // Sanity check, if the above fails, let's not prevent installation.             return $source;
        }

        // Check that the folder contains at least 1 valid plugin.         $files = glob( $working_directory . '*.php' );
        if ( $files ) {
            foreach ( $files as $file ) {
                $info = get_plugin_data( $file, false, false );
                if ( ! empty( $info['Name'] ) ) {
                    $this->new_plugin_data = $info;
                    break;
                }
            }
        }

        if ( empty( $this->new_plugin_data ) ) {

namespace Symfony\Component\DependencyInjection\Loader;

/** * GlobFileLoader loads files from a glob pattern. * * @author Nicolas Grekas <p@tchwork.com> */
class GlobFileLoader extends FileLoader
{
    public function load(mixed $resource, string $type = null): mixed
    {
        foreach ($this->glob($resource, false, $globResource) as $path => $info) {
            $this->import($path);
        }

        $this->container->addResource($globResource);

        return null;
    }

    public function supports(mixed $resource, string $type = null): bool
    {
        return 'glob' === $type;
    }

    public function import(mixed $resource, string $type = null, bool $ignoreErrors = false, string $sourceResource = null, string|array $exclude = null)
    {
        if (\is_string($resource) && \strlen($resource) !== ($i = strcspn($resource, '*?{[')) && !str_contains($resource, "\n")) {
            $excluded = [];
            foreach ((array) $exclude as $pattern) {
                foreach ($this->glob($pattern, true, $_, false, true) as $path => $info) {
                    // normalize Windows slashes and remove trailing slashes                     $excluded[rtrim(str_replace('\\', '/', $path), '/')] = true;
                }
            }

            $ret = [];
            $isSubpath = 0 !== $i && str_contains(substr($resource, 0, $i), '/');
            foreach ($this->glob($resource, false, $_, $ignoreErrors || !$isSubpath, false, $excluded) as $path => $info) {
                if (null !== $res = $this->doImport($path, 'glob' === $type ? null : $type, $ignoreErrors, $sourceResource)) {
                    $ret[] = $res;
                }

        $context = ['http' => ['header' => "Cookie: sid=123abc\r\n"]];
        $context = stream_context_create($context);
        $result = file_get_contents(sprintf('http://localhost:8053/%s.php', $fixture), false, $context);
        $result = preg_replace_callback('/expires=[^;]++/', fn ($m) => str_replace('-', ' ', $m[0]), $result);

        $this->assertStringEqualsFile(__DIR__.sprintf('/Fixtures/%s.expected', $fixture), $result);
    }

    public static function provideSession()
    {
        foreach (glob(__DIR__.'/Fixtures/*.php') as $file) {
            yield [pathinfo($file, \PATHINFO_FILENAME)];
        }
    }
}

if ( $stylesheet !== $template ) {
        $themes[] = wp_get_theme( $stylesheet );
    }
    $themes[] = wp_get_theme( $template );

    foreach ( $themes as $theme ) {
        $dirpath = $theme->get_stylesheet_directory() . '/patterns/';
        if ( ! is_dir( $dirpath ) || ! is_readable( $dirpath ) ) {
            continue;
        }
        if ( file_exists( $dirpath ) ) {
            $files = glob( $dirpath . '*.php' );
            if ( $files ) {
                foreach ( $files as $file ) {
                    $pattern_data = get_file_data( $file, $default_headers );

                    if ( empty( $pattern_data['slug'] ) ) {
                        _doing_it_wrong(
                            '_register_theme_block_patterns',
                            sprintf(
                                /* translators: %s: file name. */
                                __( 'Could not register file "%s" as a block pattern ("Slug" field missing)' ),
                                $file
                            ),

$this->container = require $cachePath;
        $this->container->set('kernel', $this);

        if ($oldContainer && $this->container::class !== $oldContainer->name) {
            // Because concurrent requests might still be using them,             // old container files are not removed immediately,             // but on a next dump of the container.             static $legacyContainers = [];
            $oldContainerDir = \dirname($oldContainer->getFileName());
            $legacyContainers[$oldContainerDir.'.legacy'] = true;
            foreach (glob(\dirname($oldContainerDir).\DIRECTORY_SEPARATOR.'*.legacy', \GLOB_NOSORT) as $legacyContainer) {
                if (!isset($legacyContainers[$legacyContainer]) && @unlink($legacyContainer)) {
                    (new Filesystem())->remove(substr($legacyContainer, 0, -7));
                }
            }

            touch($oldContainerDir.'.legacy');
        }

        $preload = $this instanceof WarmableInterface ? (array) $this->warmUp($this->container->getParameter('kernel.cache_dir')) : [];

        if ($this->container->has('cache_warmer')) {

foreach ($this->getServicesFilePathArray($this->getPath() . '/Resources/config/services_test.*') as $testPath) {
                $delegatingLoader->load($testPath);
            }
        }
    }

    /** * @return list<string> */
    private function getServicesFilePathArray(string $path): array
    {
        $pathArray = glob($path);

        if ($pathArray === false) {
            return [];
        }

        return $pathArray;
    }
}

else {
            $regex = null;
        }

        $prefixLen = \strlen($prefix);
        $paths = null;

        if ('' === $this->pattern && is_file($this->prefix)) {
            $paths = [$this->prefix => null];
        } elseif (!str_starts_with($this->prefix, 'phar://') && (null !== $regex || !str_contains($this->pattern, '/**/'))) {
            if (!str_contains($this->pattern, '/**/') && ($this->globBrace || !str_contains($this->pattern, '{'))) {
                $paths = array_fill_keys(glob($this->prefix.$this->pattern, \GLOB_NOSORT | $this->globBrace), null);
            } elseif (!str_contains($this->pattern, '\\') || !preg_match('/\\\\[,{}]/', $this->pattern)) {
                $paths = [];
                foreach ($this->expandGlob($this->pattern) as $p) {
                    if (false !== $i = strpos($p, '/**/')) {
                        $p = substr_replace($p, '/*', $i);
                    }
                    $paths += array_fill_keys(glob($this->prefix.$p, \GLOB_NOSORT), false !== $i ? $regex : null);
                }
            }
        }

static $cached_mofiles = null;

    if ( null === $cached_mofiles ) {
        $cached_mofiles = array();

        $locations = array(
            WP_LANG_DIR . '/plugins',
            WP_LANG_DIR . '/themes',
        );

        foreach ( $locations as $location ) {
            $mofiles = glob( $location . '/*.mo' );
            if ( $mofiles ) {
                $cached_mofiles = array_merge( $cached_mofiles, $mofiles );
            }
        }
    }

    $locale = determine_locale();
    $mofile = "{$domain}-{$locale}.mo";

    $path = WP_LANG_DIR . '/plugins/' . $mofile;
    if ( in_array( $path, $cached_mofiles, true ) ) {

$document->loadXML(file_get_contents($filePath));

        $errors = XliffUtils::validateSchema($document);

        $this->assertCount(0, $errors, sprintf('"%s" is invalid:%s', $filePath, \PHP_EOL.implode(\PHP_EOL, array_column($errors, 'message'))));
    }

    public static function provideTranslationFiles()
    {
        return array_map(
            fn ($filePath) => (array) $filePath,
            glob(\dirname(__DIR__, 2).'/Resources/translations/*.xlf')
        );
    }

    public function testNorwegianAlias()
    {
        $this->assertFileEquals(
            \dirname(__DIR__, 2).'/Resources/translations/validators.nb.xlf',
            \dirname(__DIR__, 2).'/Resources/translations/validators.no.xlf',
            'The NO locale should be an alias for the NB variant of the Norwegian language.'
        );
    }
}

    protected function _clean($dir, $mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
    {
        if (!is_dir($dir)) {
            return false;
        }
        $result = true;
        $prefix = $this->_options['file_name_prefix'];
        $glob = @glob($dir . $prefix . '--*');
        if ($glob === false) {
            // On some systems it is impossible to distinguish between empty match and an error.             return true;
        }
        foreach ($glob as $file)  {
            if (is_file($file)) {
                $fileName = basename($file);
                if ($this->_isMetadatasFile($fileName)) {
                    // in CLEANING_MODE_ALL, we drop anything, even remainings old metadatas files                     if ($mode != Zend_Cache::CLEANING_MODE_ALL) {
                        continue;
                    }