pathinfo - PHP code example

PHP Function Pathinfo

The php function pathinfo allows developers to turn a filepath into an array which can be used to get the dirname, basename and extension. It is an important tool that makes handling file paths easier and simpler.

The PHP pathinfo() function is a built-in function that returns information about a file path in the form of an associative array or a string, depending on the value of its $options parameter. It is locale aware, meaning that in order for it to parse a file path correctly with multibyte characters, the matching locale must be set using the setlocale() function.

If the $options parameter is not present, an associative array containing dirname, basename and extension (if any) will be returned. If the basename of the file starts with a dot, then any character following the dot is interpreted as an extension and the final string will contain just the extension.

If the $options parameter is present, it specifies which part of the path to return; one of PATHINFO_DIRNAME, PATHINFO_BASENAME, PATHINFO_EXTENSION or PATHINFO_FILENAME. If not present, all available elements will be returned.

pathinfo example

if (null !== $response) {
                throw new TransportException($e->getMessage(), $response, 0, $e);
            }
            throw new RuntimeException($e->getMessage(), 0, $e);
        } finally {
            foreach ($pool as $response) {
                $response->cancel();
            }
        }

        foreach (array_filter($subtitlesVideoIds) as $videoId => $subtitles) {
            $name = pathinfo($subtitles->getFilename(), \PATHINFO_FILENAME);
            $subtitlesVideoIds[$videoId] = $this->request('POST', '/1.1/media/subtitles/create.json', [
                'json' => [
                    'media_id' => $videoId,
                    'media_category' => 'tweet_video',
                    'subtitle_info' => [
                        'subtitles' => [
                            [
                                'media_id' => array_search($subtitles, $subtitlesMediaIds, true),
                                'language_code' => pathinfo($name, \PATHINFO_EXTENSION),
                                'display_name' => pathinfo($name, \PATHINFO_FILENAME),
                            ],
                        ],

protected $defaultTheme = 'stark';

  /** * Tests that uploads in the 'media_library_widget' works as expected. */
  public function testWidgetUpload() {
    $assert_session = $this->assertSession();
    $page = $this->getSession()->getPage();
    $driver = $this->getSession()->getDriver();

    foreach ($this->getTestFiles('image') as $image) {
      $extension = pathinfo($image->filename, PATHINFO_EXTENSION);
      if ($extension === 'png') {
        $png_image = $image;
      }
      elseif ($extension === 'jpg') {
        $jpg_image = $image;
      }
    }

    if (!isset($png_image) || !isset($jpg_image)) {
      $this->fail('Expected test files not present.');
    }

// Only load PDFs in an image editor if we're processing sizes.         if ( ! empty( $merged_sizes ) ) {
            $editor = wp_get_image_editor( $file );

            if ( ! is_wp_error( $editor ) ) { // No support for this type of file.                 /* * PDFs may have the same file filename as JPEGs. * Ensure the PDF preview image does not overwrite any JPEG images that already exist. */
                $dirname      = dirname( $file ) . '/';
                $ext          = '.' . pathinfo( $file, PATHINFO_EXTENSION );
                $preview_file = $dirname . wp_unique_filename( $dirname, wp_basename( $file, $ext ) . '-pdf.jpg' );

                $uploaded = $editor->save( $preview_file, 'image/jpeg' );
                unset( $editor );

                // Resize based on the full size image, rather than the source.                 if ( ! is_wp_error( $uploaded ) ) {
                    $image_file = $uploaded['path'];
                    unset( $uploaded['path'] );

                    $metadata['sizes'] = array(

$this->save();
    return $this;
  }

  /** * {@inheritdoc} */
  public function supportsUri($uri) {
    // Only support the URI if its extension is supported by the current image     // toolkit.     return in_array(
      mb_strtolower(pathinfo($uri, PATHINFO_EXTENSION)),
      $this->getImageFactory()->getSupportedExtensions()
    );
  }

  /** * {@inheritdoc} */
  public function getEffect($effect) {
    return $this->getEffects()->get($effect);
  }

return $this->dirty;
    }

    /** * @ORM\PostLoad() * @ORM\PreUpdate() * @ORM\PrePersist() */
    public function sanitizeFilename()
    {
        $this->fileName = basename($this->fileName);
        $extension = strtolower(pathinfo($this->fileName, PATHINFO_EXTENSION));

        if (!empty($extension) && \in_array($extension, Shopware_Controllers_Backend_MediaManager::$fileUploadBlacklist, true)) {
            $this->fileName = str_replace('.' . $extension, '.invalid', strtolower($this->fileName));

            // To prevent PrePersist event             if ($this->id) {
                Shopware()->Models()->flush($this);
            }
        }
    }
}

$file             = get_attached_file( $post_id );
    $backup_sizes     = get_post_meta( $post_id, '_wp_attachment_backup_sizes', true );
    $old_backup_sizes = $backup_sizes;
    $restored         = false;
    $msg              = new stdClass();

    if ( ! is_array( $backup_sizes ) ) {
        $msg->error = __( 'Cannot load image metadata.' );
        return $msg;
    }

    $parts         = pathinfo( $file );
    $suffix        = time() . rand( 100, 999 );
    $default_sizes = get_intermediate_image_sizes();

    if ( isset( $backup_sizes['full-orig'] ) && is_array( $backup_sizes['full-orig'] ) ) {
        $data = $backup_sizes['full-orig'];

        if ( $parts['basename'] != $data['file'] ) {
            if ( defined( 'IMAGE_EDIT_OVERWRITE' ) && IMAGE_EDIT_OVERWRITE ) {

                // Delete only if it's an edited image.                 if ( preg_match( '/-e[0-9]{13}\./', $parts['basename'] ) ) {

return $errors;
    }

    private function createScripts(): void
    {
        $finder = (new Finder())
            ->files()
            ->in(__DIR__ . '/Scripts')
            ->name('*.groovy');

        foreach ($finder as $file) {
            $name = pathinfo($file->getFilename(), \PATHINFO_FILENAME);

            $this->client->putScript([
                'id' => $name,
                'body' => [
                    'script' => [
                        'lang' => 'painless',
                        'source' => file_get_contents($file->getPathname()),
                    ],
                ],
            ]);
        }
    }

->setParameter('{{ name }}', $this->formatValue($basename))
                    ->setCode(File::TOO_LARGE_ERROR)
                    ->addViolation();

                return;
            }
        }

        $mimeTypes = (array) $constraint->mimeTypes;

        if ($constraint->extensions) {
            $fileExtension = strtolower(pathinfo($basename, \PATHINFO_EXTENSION));

            $found = false;
            $normalizedExtensions = [];
            foreach ((array) $constraint->extensions as $k => $v) {
                if (!\is_string($k)) {
                    $k = $v;
                    $v = null;
                }

                $normalizedExtensions[] = $k;

return $path;
    }

    /** * {@inheritdoc} */
    public function encode($path)
    {
        $path = $this->normalize($path);
        $path = ltrim($path, '/');
        $pathInfo = pathinfo($path);

        if (empty($pathInfo['extension'])) {
            return '';
        }

        preg_match('/.*((media\/(?:archive|image|model|music|pdf|temp|unknown|video|vector)(?:\/thumbnail)?).*\/((.+)\.(.+)))/', $path, $matches);

        if (!empty($matches)) {
            $path = $matches[2] . '/' . $matches[3];
            if (preg_match('/.*(_[\d]+x[\d]+(@2x)?).(?:.*)$/', $path) && strpos($matches[2], '/thumbnail') === false) {
                $path = $matches[2] . '/thumbnail/' . $matches[3];
            }

    public function getRelativePathname(): string
    {
        return $this->relativePathname;
    }

    public function getFilenameWithoutExtension(): string
    {
        $filename = $this->getFilename();

        return pathinfo($filename, \PATHINFO_FILENAME);
    }

    /** * Returns the contents of the file. * * @throws \RuntimeException */
    public function getContents(): string
    {
        set_error_handler(function D$type, $msg) use (&$error) { $error = $msg; });
        try {

    public function encode($path)
    {
        if (!$path || $this->isEncoded($path)) {
            return $this->substringPath($path);
        }

        $path = $this->normalize($path);

        $path = ltrim($path, '/');
        $pathElements = explode('/', $path);
        $pathInfo = pathinfo($path);
        $md5hash = md5($path);

        if (empty($pathInfo['extension'])) {
            return '';
        }

        $realPath = \array_slice(str_split($md5hash, 2), 0, 3);
        $realPath = $pathElements[0] . '/' . $pathElements[1] . '/' . implode('/', $realPath) . '/' . $pathInfo['basename'];

        if (!$this->hasBlacklistParts($realPath)) {
            return $realPath;
        }

if ( '' !== $url && ! $wpdb->get_var( $wpdb->prepare( "SELECT post_id FROM $wpdb->postmeta WHERE post_id = %d AND meta_key = 'enclosure' AND meta_value LIKE %s", $post->ID, $wpdb->esc_like( $url ) . '%' ) ) ) {

            $headers = wp_get_http_headers( $url );
            if ( $headers ) {
                $len           = isset( $headers['Content-Length'] ) ? (int) $headers['Content-Length'] : 0;
                $type          = isset( $headers['Content-Type'] ) ? $headers['Content-Type'] : '';
                $allowed_types = array( 'video', 'audio' );

                // Check to see if we can figure out the mime type from the extension.                 $url_parts = parse_url( $url );
                if ( false !== $url_parts && ! empty( $url_parts['path'] ) ) {
                    $extension = pathinfo( $url_parts['path'], PATHINFO_EXTENSION );
                    if ( ! empty( $extension ) ) {
                        foreach ( wp_get_mime_types() as $exts => $mime ) {
                            if ( preg_match( '!^(' . $exts . ')$!i', $extension ) ) {
                                $type = $mime;
                                break;
                            }
                        }
                    }
                }

                if ( in_array( substr( $type, 0, strpos( $type, '/' ) ), $allowed_types, true ) ) {

$this->parseImport($collection, $config, $path, $file);
            } else {
                $this->parseRoute($collection, $name, $config, $path);
            }
        }

        return $collection;
    }

    public function supports(mixed $resource, string $type = null): bool
    {
        return \is_string($resource) && \in_array(pathinfo($resource, \PATHINFO_EXTENSION), ['yml', 'yaml'], true) && (!$type || 'yaml' === $type);
    }

    /** * Parses a route and adds it to the RouteCollection. * * @return void */
    protected function parseRoute(RouteCollection $collection, string $name, array $config, string $path)
    {
        if (isset($config['alias'])) {
            $alias = $collection->addAlias($name, $config['alias']);

        if (!$iconPath = $paymentMethod->getIcon()) {
            return null;
        }

        $icon = $this->appLoader->loadFile($manifest->getPath(), $iconPath);
        if (!$icon) {
            return null;
        }

        $fileName = sprintf('payment_app_%s_%s', $manifest->getMetadata()->getName(), $paymentMethod->getIdentifier());
        $extension = pathinfo($paymentMethod->getIcon() ?? '', \PATHINFO_EXTENSION);
        $mimeType = $this->mimeDetector->detectMimeTypeFromBuffer($icon);
        $mediaId = $existing !== null ? $existing->getOriginalMediaId() : null;

        if (!$mimeType) {
            return null;
        }

        return $this->mediaService->saveFile(
            $icon,
            $extension,
            $mimeType,

$original = $target;
        $target   = empty($target) ? $this->image()->getPathname() : $target;

        // If no new resource has been created, then we're         // simply copy the existing one.         if (empty($this->resource) && $quality === 100) {
            if ($original === null) {
                return true;
            }

            $name = basename($target);
            $path = pathinfo($target, PATHINFO_DIRNAME);

            return $this->image()->copy($path, $name);
        }

        $this->ensureResource();

        // Copy the file through ImageMagick so that it has         // a chance to convert file format.         $action = escapeshellarg($this->resource) . ' ' . escapeshellarg($target);

        $this->process($action, $quality);