is_dir - PHP code example

The php Function is_dir

The php function is_dir lets you verify if a given path name is a directory. This is especially useful when it comes to parsing file paths or iterating through directories, but it can also be used for checking whether a particular path is a regular file, a symlink, or an unknown type of file (as a note, this method does not check whether a file actually exists; you would need to use is_file() or file_exists() to do that).

The is_dir() function accepts one parameter - the file path to be checked. The returned bool value is true if the path is a directory, and false otherwise. The function also follows symlinks, so you should always supply the full path to the directory in which the symlink is located.

If you are using open_basedir, the is_dir() function may be slower than it would be if you didn't have this feature enabled. Also, the is_dir() function results are cached; use clearstatcache() to clear them.

In a performance test, is_dir was found to be at least four times faster than file_exists in determining whether the path is a directory; however, it may take longer depending on the depth of the folder being examined. You should use is_dir() if you are trying to optimize your scripts for speed, but remember that this method does not check whether the path is valid, so you would need to combine it with the is_file() or file_exists() functions to do that.

is_dir example

    use OrderFixture;
    use SalesChannelApiTestBehaviour;

    private bool $mediaDirCreated = false;

    protected function setUp(): void
    {
        parent::setUp();

        $projectDir = $this->getContainer()->getParameter('kernel.project_dir');
        if (!\is_dir($projectDir . '/public/media')) {
            mkdir($projectDir . '/public/media');
            $this->mediaDirCreated = true;
        }

        \copy(self::TEST_IMAGE, $this->getContainer()->getParameter('kernel.project_dir') . '/public/media/ßhopware-logö.png');
    }

    protected function tearDown(): void
    {
        parent::tearDown();

/** * This static method is called by Composer after every update event, * i.e., `composer install`, `composer update`, `composer remove`. */
    public static function postUpdate()
    {
        self::recursiveDelete(self::$path);

        foreach (self::$dependencies as $key => $dependency) {
            // Kint may be removed.             if (! is_dir($dependency['from']) && strpos($key, 'kint') === 0) {
                continue;
            }

            self::recursiveMirror($dependency['from'], $dependency['to']);

            if (isset($dependency['license'])) {
                $license = basename($dependency['license']);
                copy($dependency['license'], $dependency['to'] . '/' . $license);
            }
        }

return function D) use ($path, $rootClass) {
            require_once $path;
            $className = $rootClass->getFqcn();

            return new $className();
        };
    }

    private function getFullPath(ClassBuilder $class): string
    {
        $directory = $this->outputDir.\DIRECTORY_SEPARATOR.$class->getDirectory();
        if (!is_dir($directory)) {
            @mkdir($directory, 0777, true);
        }

        return $directory.\DIRECTORY_SEPARATOR.$class->getFilename();
    }

    private function writeClasses(): void
    {
        foreach ($this->classes as $class) {
            $this->buildConstructor($class);
            $this->buildToArray($class);

error_reporting(E_ALL);
ini_set('display_errors', '1');
ini_set('display_startup_errors', '1');

// Make sure it recognizes that we're testing. $_SERVER['CI_ENVIRONMENT'] = 'testing';
define('ENVIRONMENT', 'testing');
defined('CI_DEBUG') || define('CI_DEBUG', true);

// Often these constants are pre-defined, but query the current directory structure as a fallback defined('HOMEPATH') || define('HOMEPATH', realpath(rtrim(getcwd(), '\\/ ')) . DIRECTORY_SEPARATOR);
$source = is_dir(HOMEPATH . 'app')
? HOMEPATH
: (is_dir('vendor/codeigniter4/framework/') ? 'vendor/codeigniter4/framework/' : 'vendor/codeigniter4/codeigniter4/');
defined('CONFIGPATH') || define('CONFIGPATH', realpath($source . 'app/Config') . DIRECTORY_SEPARATOR);
defined('PUBLICPATH') || define('PUBLICPATH', realpath($source . 'public') . DIRECTORY_SEPARATOR);
unset($source);

// Load framework paths from their config file require CONFIGPATH . 'Paths.php';
$paths = new Paths();

// Define necessary framework path constants

require_once __DIR__ . '/../common/autoload.php';

\define('UPDATE_PATH', __DIR__);
$isManual = is_dir(SW_PATH . '/update-assets');
if ($isManual) {
    \define('UPDATE_IS_MANUAL', true);
    \define('UPDATE_FILES_PATH', '');
    \define('UPDATE_ASSET_PATH', SW_PATH . '/update-assets');
    \define('UPDATE_META_FILE', '');
} else {
    \define('UPDATE_IS_MANUAL', false);
    \define('UPDATE_FILES_PATH', SW_PATH . '/files/update/files');
    \define('UPDATE_ASSET_PATH', SW_PATH . '/files/update/update-assets');
    \define('UPDATE_META_FILE', SW_PATH . '/files/update/update.json');
}

$baseDir = $savePath ??= \ini_get('session.save_path');

        if ($count = substr_count($savePath, ';')) {
            if ($count > 2) {
                throw new \InvalidArgumentException(sprintf('Invalid argument $savePath \'%s\'.', $savePath));
            }

            // characters after last ';' are the path             $baseDir = ltrim(strrchr($savePath, ';'), ';');
        }

        if ($baseDir && !is_dir($baseDir) && !@mkdir($baseDir, 0777, true) && !is_dir($baseDir)) {
            throw new \RuntimeException(sprintf('Session Storage was not able to create directory "%s".', $baseDir));
        }

        if ($savePath !== \ini_get('session.save_path')) {
            ini_set('session.save_path', $savePath);
        }
        if ('files' !== \ini_get('session.save_handler')) {
            ini_set('session.save_handler', 'files');
        }
    }
}

use Symfony\Component\HttpKernel\Profiler\FileProfilerStorage;
use Symfony\Component\HttpKernel\Profiler\Profile;

class FileProfilerStorageTest extends TestCase
{
    private string $tmpDir;
    private FileProfilerStorage $storage;

    protected function setUp(): void
    {
        $this->tmpDir = sys_get_temp_dir().'/sf_profiler_file_storage';
        if (is_dir($this->tmpDir)) {
            self::cleanDir();
        }
        $this->storage = new FileProfilerStorage('file:'.$this->tmpDir);
        $this->storage->purge();
    }

    protected function tearDown(): void
    {
        self::cleanDir();
    }

            // @see : https://bugs.php.net/69442             $ptsWorkaround = fopen(__FILE__, 'r');
        }

        $envPairs = [];
        foreach ($env as $k => $v) {
            if (false !== $v && false === \in_array($k, ['argc', 'argv', 'ARGC', 'ARGV'], true)) {
                $envPairs[] = $k.'='.$v;
            }
        }

        if (!is_dir($this->cwd)) {
            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])) {

class ThemeFileImporter implements ThemeFileImporterInterface
{
    /** * @internal */
    public function __construct(private readonly string $projectDir)
    {
    }

    public function fileExists(string $filePath): bool
    {
        return file_exists($filePath) && !is_dir($filePath);
    }

    public function getRealPath(string $filePath): string
    {
        if ($filePath[0] === '/' || !file_exists($this->projectDir . '/' . $filePath)) {
            return $filePath;
        }

        return $this->projectDir . '/' . $filePath;
    }

    public function chmod( $file, $mode = false, $recursive = false ) {
        if ( ! $mode ) {
            if ( $this->is_file( $file ) ) {
                $mode = FS_CHMOD_FILE;
            } elseif ( $this->is_dir( $file ) ) {
                $mode = FS_CHMOD_DIR;
            } else {
                return false;
            }
        }

        // chmod any sub-objects if recursive.         if ( $recursive && $this->is_dir( $file ) ) {
            $filelist = $this->dirlist( $file );

            foreach ( (array) $filelist as $filename => $filemeta ) {

try {
            foreach ($this->warmers as $warmer) {
                if (!$this->optionalsEnabled && $warmer->isOptional()) {
                    continue;
                }
                if ($this->onlyOptionalsEnabled && !$warmer->isOptional()) {
                    continue;
                }

                $start = microtime(true);
                foreach ((array) $warmer->warmUp($cacheDir) as $item) {
                    if (is_dir($item) || (str_starts_with($item, \dirname($cacheDir)) && !is_file($item))) {
                        throw new \LogicException(sprintf('"%s::warmUp()" should return a list of files or classes but "%s" is none of them.', $warmer::class, $item));
                    }
                    $preload[] = $item;
                }

                if ($io?->isDebug()) {
                    $io->info(sprintf('"%s" completed in %0.2fms.', $warmer::class, 1000 * (microtime(true) - $start)));
                }
            }
        } finally {
            if ($collectDeprecations) {

$test_discovery = new TestDiscovery(
      $this->getContainer()->getParameter('app.root'),
      $this->getContainer()->get('class_loader')
    );
    $test_discovery->registerTestNamespaces();

    // Register stream wrappers.     $this->getContainer()->get('stream_wrapper_manager')->register();

    // Create the build/artifacts directory if necessary.     if (!is_dir('public://simpletest') && !@mkdir('public://simpletest', 0777, TRUE) && !is_dir('public://simpletest')) {
      throw new \RuntimeException('Unable to create directory: public://simpletest');
    }

    return $this;
  }

  /** * {@inheritdoc} */
  public function discoverServiceProviders() {
    parent::discoverServiceProviders();

function wp_set_lang_dir() {
    if ( ! defined( 'WP_LANG_DIR' ) ) {
        if ( file_exists( WP_CONTENT_DIR . '/languages' ) && @is_dir( WP_CONTENT_DIR . '/languages' )
            || ! @is_dir( ABSPATH . WPINC . '/languages' )
        ) {
            /** * Server path of the language directory. * * No leading slash, no trailing slash, full path, not relative to ABSPATH * * @since 2.1.0 */
            define( 'WP_LANG_DIR', WP_CONTENT_DIR . '/languages' );

$fileData  = [];
            $newDepth  = $directoryDepth - 1;
            $sourceDir = rtrim($sourceDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;

            while (false !== ($file = readdir($fp))) {
                // Remove '.', '..', and hidden files [optional]                 if ($file === '.' || $file === '..' || ($hidden === false && $file[0] === '.')) {
                    continue;
                }

                if (is_dir($sourceDir . $file)) {
                    $file .= DIRECTORY_SEPARATOR;
                }

                if (($directoryDepth < 1 || $newDepth > 0) && is_dir($sourceDir . $file)) {
                    $fileData[$file] = directory_map($sourceDir . $file, $newDepth, $hidden);
                } else {
                    $fileData[] = $file;
                }
            }

            closedir($fp);

class AnnotationDirectoryLoader extends AnnotationFileLoader
{
    /** * @throws \InvalidArgumentException When the directory does not exist or its routes cannot be parsed */
    public function load(mixed $path, string $type = null): ?RouteCollection
    {
        if (!is_dir($dir = $this->locator->locate($path))) {
            return parent::supports($path, $type) ? parent::load($path, $type) : new RouteCollection();
        }

        $collection = new RouteCollection();
        $collection->addResource(new DirectoryResource($dir, '/\.php$/'));
        $files = iterator_to_array(new \RecursiveIteratorIterator(
            new \RecursiveCallbackFilterIterator(
                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
                fn (\SplFileInfo $current) => !str_starts_with($current->getBasename(), '.')
            ),
            \RecursiveIteratorIterator::LEAVES_ONLY
        ));