Skip to main content

PHP File Information

Introduction​

When working with files in PHP applications, you often need to retrieve and manipulate information about these files. PHP provides several built-in functions that allow you to examine file properties such as size, type, path, modification time, and permissions. Understanding these functions is essential for effective file management in PHP applications.

In this tutorial, we'll explore the various methods to access and work with file information, providing practical examples that demonstrate how to implement these techniques in real-world scenarios.

File Existence and Properties​

Checking If a File Exists​

Before performing operations on a file, it's often necessary to check if the file actually exists:

php
$filename = 'example.txt';

if (file_exists($filename)) {
    echo "The file $filename exists.";
} else {
    echo "The file $filename does not exist.";
}

Output:

The file example.txt exists.

Determining File Type​

To check if a path is a file or directory:

php
$path = 'example.txt';

if (is_file($path)) {
    echo "$path is a regular file.";
} else if (is_dir($path)) {
    echo "$path is a directory.";
} else {
    echo "$path is neither a file nor a directory.";
}

Output:

example.txt is a regular file.

File Size Information​

Getting File Size​

PHP provides the filesize() function to retrieve the size of a file in bytes:

php
$filename = 'example.txt';

if (file_exists($filename)) {
    $size_in_bytes = filesize($filename);
    echo "File size: $size_in_bytes bytes";
    
    // Converting to KB, MB, GB for readability
    $size_in_kb = round($size_in_bytes / 1024, 2);
    $size_in_mb = round($size_in_bytes / (1024 * 1024), 2);
    
    echo "<br>File size: $size_in_kb KB";
    echo "<br>File size: $size_in_mb MB";
}

Output:

File size: 1024 bytes
File size: 1.00 KB
File size: 0.00 MB

Creating a Human-Readable File Size Function​

Here's a practical function to convert file sizes to human-readable format:

php
function formatFileSize($bytes) {
    if ($bytes >= 1073741824) {
        return number_format($bytes / 1073741824, 2) . ' GB';
    } else if ($bytes >= 1048576) {
        return number_format($bytes / 1048576, 2) . ' MB';
    } else if ($bytes >= 1024) {
        return number_format($bytes / 1024, 2) . ' KB';
    } else {
        return $bytes . ' bytes';
    }
}

$filename = 'large_file.zip';
if (file_exists($filename)) {
    echo formatFileSize(filesize($filename));  // Example: "2.50 MB"
}

Path Information​

Getting File Path Information​

The pathinfo() function returns an array containing information about a file path:

php
$path = '/var/www/html/uploads/document.pdf';
$info = pathinfo($path);

echo "Directory name: " . $info['dirname'] . "<br>";
echo "Base name: " . $info['basename'] . "<br>";
echo "File extension: " . $info['extension'] . "<br>";
echo "Filename without extension: " . $info['filename'] . "<br>";

// You can also get individual components directly
echo "Extension only: " . pathinfo($path, PATHINFO_EXTENSION);

Output:

Directory name: /var/www/html/uploads
Base name: document.pdf
File extension: pdf
Filename without extension: document
Extension only: pdf

Extracting File Extensions​

To get just the file extension:

php
$filename = 'report.2023.final.xlsx';
$extension = pathinfo($filename, PATHINFO_EXTENSION);
echo "The file extension is: $extension";

Output:

The file extension is: xlsx

File Time Information​

PHP provides several functions to retrieve file timestamps:

php
$file = 'example.txt';

if (file_exists($file)) {
    // Last access time
    $access_time = fileatime($file);
    echo "Last accessed: " . date("F d Y H:i:s", $access_time) . "<br>";
    
    // Last modification time
    $modification_time = filemtime($file);
    echo "Last modified: " . date("F d Y H:i:s", $modification_time) . "<br>";
    
    // Creation time (may not be available on all systems)
    $creation_time = filectime($file);
    echo "Created/changed: " . date("F d Y H:i:s", $creation_time);
}

Output:

Last accessed: January 15 2023 14:32:07
Last modified: January 10 2023 09:45:12
Created/changed: January 05 2023 11:22:30

File Permissions​

Checking File Permissions​

You can use the is_readable(), is_writable(), and is_executable() functions to check file permissions:

php
$file = 'config.php';

if (file_exists($file)) {
    if (is_readable($file)) {
        echo "The file is readable.<br>";
    }
    
    if (is_writable($file)) {
        echo "The file is writable.<br>";
    }
    
    if (is_executable($file)) {
        echo "The file is executable.<br>";
    }
    
    // Get octal permission value
    $perms = fileperms($file);
    $octal_perms = substr(sprintf('%o', $perms), -4);
    echo "File permissions (octal): $octal_perms";
}

Output:

The file is readable.
The file is writable.
File permissions (octal): 0644

Converting Octal Permissions to Human-Readable Format​

Here's a useful function to display permissions in a more readable format:

php
function getFilePermissions($file) {
    $perms = fileperms($file);
    
    switch ($perms & 0xF000) {
        case 0xC000: // Socket
            $info = 's';
            break;
        case 0xA000: // Symbolic Link
            $info = 'l';
            break;
        case 0x8000: // Regular
            $info = '-';
            break;
        case 0x6000: // Block special
            $info = 'b';
            break;
        case 0x4000: // Directory
            $info = 'd';
            break;
        case 0x2000: // Character special
            $info = 'c';
            break;
        case 0x1000: // FIFO pipe
            $info = 'p';
            break;
        default: // Unknown
            $info = 'u';
    }
    
    // Owner
    $info .= (($perms & 0x0100) ? 'r' : '-');
    $info .= (($perms & 0x0080) ? 'w' : '-');
    $info .= (($perms & 0x0040) ? (($perms & 0x0800) ? 's' : 'x') : (($perms & 0x0800) ? 'S' : '-'));
    
    // Group
    $info .= (($perms & 0x0020) ? 'r' : '-');
    $info .= (($perms & 0x0010) ? 'w' : '-');
    $info .= (($perms & 0x0008) ? (($perms & 0x0400) ? 's' : 'x') : (($perms & 0x0400) ? 'S' : '-'));
    
    // World
    $info .= (($perms & 0x0004) ? 'r' : '-');
    $info .= (($perms & 0x0002) ? 'w' : '-');
    $info .= (($perms & 0x0001) ? (($perms & 0x0200) ? 't' : 'x') : (($perms & 0x0200) ? 'T' : '-'));
    
    return $info;
}

$file = 'example.txt';
echo "Permissions: " . getFilePermissions($file);  // Example: "-rw-r--r--"

MIME Type Detection​

Finding a File's MIME Type​

The mime_content_type() function or finfo extension can determine a file's MIME type:

php
// Using mime_content_type (if available)
if (function_exists('mime_content_type')) {
    $filename = 'image.jpg';
    $mime_type = mime_content_type($filename);
    echo "MIME type (mime_content_type): $mime_type<br>";
}

// Using FileInfo extension (more reliable)
if (class_exists('finfo')) {
    $finfo = new finfo(FILEINFO_MIME_TYPE);
    $mime_type = $finfo->file('image.jpg');
    echo "MIME type (finfo): $mime_type";
}

Output:

MIME type (mime_content_type): image/jpeg
MIME type (finfo): image/jpeg

Practical Example: File Manager​

Here's a practical example that combines multiple file information functions to create a simple file listing utility:

php
function listDirectoryFiles($dir) {
    $files = scandir($dir);
    echo "<table border='1'>
            <tr>
                <th>Filename</th>
                <th>Type</th>
                <th>Size</th>
                <th>Last Modified</th>
                <th>Permissions</th>
            </tr>";
            
    foreach ($files as $file) {
        if ($file != '.' && $file != '..') {
            $fullPath = $dir . '/' . $file;
            
            echo "<tr>";
            echo "<td>" . htmlspecialchars($file) . "</td>";
            
            // Type
            $isDir = is_dir($fullPath);
            echo "<td>" . ($isDir ? "Directory" : pathinfo($fullPath, PATHINFO_EXTENSION)) . "</td>";
            
            // Size
            if ($isDir) {
                echo "<td>-</td>";
            } else {
                echo "<td>" . formatFileSize(filesize($fullPath)) . "</td>";
            }
            
            // Last Modified
            echo "<td>" . date("Y-m-d H:i:s", filemtime($fullPath)) . "</td>";
            
            // Permissions
            echo "<td>" . getFilePermissions($fullPath) . "</td>";
            
            echo "</tr>";
        }
    }
    
    echo "</table>";
}

// Usage:
// listDirectoryFiles('/path/to/directory');

File Information Process Flow​

Here's a visual representation of how PHP processes file information:

Summary​

In this tutorial, we've explored the essential functions and techniques for working with file information in PHP:

  • Checking file existence with file_exists()
  • Determining file types with is_file() and is_dir()
  • Getting file sizes with filesize()
  • Extracting path information with pathinfo()
  • Retrieving timestamps with filemtime(), fileatime(), and filectime()
  • Checking permissions with is_readable(), is_writable(), and is_executable()
  • Detecting MIME types with mime_content_type() and the finfo extension

Understanding these functions is crucial for effective file management in PHP applications, whether you're building a file upload system, a content management system, or any application that deals with files.

Additional Resources​

Exercises​

  1. Create a function that recursively calculates the total size of all files in a directory.
  2. Build a simple file uploader that validates files based on their MIME type and size.
  3. Create a backup utility that copies only files modified within the last 24 hours.
  4. Implement a function that lists all files of a specific type (e.g., all .jpg files) in a directory.
  5. Build a simple file permission manager that can change file permissions based on user input.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)