File Handling and I/O Operations in PHP

1<?php
2declare(strict_types=1);
3
4// Read entire file into string
5$content = file_get_contents('data.txt');
6echo $content;
7
8// Read file into array (one line per element)
9$lines = file('data.txt');
10foreach ($lines as $line) {
11    echo $line;
12}
13
14// Read file line by line (memory efficient)
15$file = fopen('data.txt', 'r');
16while (!feof($file)) {
17    $line = fgets($file);
18    echo $line;
19}
20fclose($file);
21
22// Read specific number of bytes
23$file = fopen('data.txt', 'r');
24$chunk = fread($file, 1024); // Read 1KB
25fclose($file);
26?>

1<?php
2// Write string to file (overwrites existing content)
3file_put_contents('output.txt', 'Hello, World!');
4
5// Append to file
6file_put_contents('log.txt', "Log entry\n", FILE_APPEND);
7
8// Write with exclusive lock
9file_put_contents(
10    'config.txt',
11    'Setting=Value',
12    LOCK_EX
13);
14
15// Write using file handle
16$file = fopen('data.txt', 'w');
17fwrite($file, "Line 1\n");
18fwrite($file, "Line 2\n");
19fclose($file);
20?>

1<?php
2// 'r'  - Read only, pointer at beginning
3// 'r+' - Read/write, pointer at beginning
4// 'w'  - Write only, truncates file or creates new
5// 'w+' - Read/write, truncates file or creates new
6// 'a'  - Append, pointer at end, creates if doesn't exist
7// 'a+' - Read/append, pointer at end, creates if doesn't exist
8// 'x'  - Create and open for write only, fails if exists
9// 'x+' - Create and open for read/write, fails if exists
10// 'c'  - Open for writing, creates if doesn't exist, doesn't truncate
11// 'c+' - Open for read/write, creates if doesn't exist, doesn't truncate
12
13$file = fopen('data.txt', 'r+');
14// Read and write operations
15fclose($file);
16?>

1<?php
2// Read binary file
3$image = file_get_contents('photo.jpg');
4
5// Write binary file
6file_put_contents('copy.jpg', $image);
7
8// Read binary with chunks
9$source = fopen('video.mp4', 'rb');
10$dest = fopen('copy.mp4', 'wb');
11
12while (!feof($source)) {
13    $chunk = fread($source, 8192); // 8KB chunks
14    fwrite($dest, $chunk);
15}
16
17fclose($source);
18fclose($dest);
19?>

1<?php
2function appendToLog(string $message): void {
3    $file = fopen('app.log', 'a');
4
5    // Acquire exclusive lock
6    if (flock($file, LOCK_EX)) {
7        fwrite($file, date('Y-m-d H:i:s') . " - $message\n");
8
9        // Release lock
10        flock($file, LOCK_UN);
11    }
12
13    fclose($file);
14}
15
16// Safe for concurrent writes
17appendToLog("User logged in");
18appendToLog("User logged out");
19?>

1<?php
2declare(strict_types=1);
3
4$file = 'document.pdf';
5
6// Check if file exists
7if (file_exists($file)) {
8    echo "File exists\n";
9}
10
11// Check if path is a file
12if (is_file($file)) {
13    echo "Is a file\n";
14}
15
16// Check if path is a directory
17if (is_dir('uploads')) {
18    echo "Is a directory\n";
19}
20
21// Check if file is readable/writable
22if (is_readable($file)) {
23    echo "File is readable\n";
24}
25
26if (is_writable($file)) {
27    echo "File is writable\n";
28}
29
30// Get file size
31$size = filesize($file);
32echo "Size: " . number_format($size) . " bytes\n";
33
34// Get file modification time
35$mtime = filemtime($file);
36echo "Modified: " . date('Y-m-d H:i:s', $mtime) . "\n";
37
38// Get file permissions
39$perms = fileperms($file);
40echo "Permissions: " . substr(sprintf('%o', $perms), -4) . "\n";
41?>

1<?php
2// Copy file
3copy('source.txt', 'destination.txt');
4
5// Rename/move file
6rename('old_name.txt', 'new_name.txt');
7
8// Delete file
9unlink('temp.txt');
10
11// Create symbolic link
12symlink('target.txt', 'link.txt');
13
14// Get file extension
15$ext = pathinfo('document.pdf', PATHINFO_EXTENSION);
16echo "Extension: $ext\n"; // pdf
17
18// Get filename without extension
19$name = pathinfo('document.pdf', PATHINFO_FILENAME);
20echo "Filename: $name\n"; // document
21
22// Get directory name
23$dir = dirname('/var/www/html/index.php');
24echo "Directory: $dir\n"; // /var/www/html
25
26// Get base name
27$base = basename('/var/www/html/index.php');
28echo "Basename: $base\n"; // index.php
29?>

1<?php
2// Create directory
3mkdir('uploads');
4
5// Create nested directories
6mkdir('uploads/images/thumbnails', 0755, true);
7
8// Remove empty directory
9rmdir('temp');
10
11// Change current directory
12chdir('/var/www');
13echo "Current directory: " . getcwd() . "\n";
14
15// List directory contents
16$files = scandir('.');
17foreach ($files as $file) {
18    echo "$file\n";
19}
20
21// Recursive directory iterator
22function listFilesRecursive(string $dir): void {
23    $items = scandir($dir);
24
25    foreach ($items as $item) {
26        if ($item === '.' || $item === '..') {
27            continue;
28        }
29
30        $path = $dir . DIRECTORY_SEPARATOR . $item;
31
32        if (is_dir($path)) {
33            echo "[DIR] $path\n";
34            listFilesRecursive($path);
35        } else {
36            echo "[FILE] $path\n";
37        }
38    }
39}
40
41listFilesRecursive('.');
42?>

1<?php
2// Find all PHP files
3$phpFiles = glob('*.php');
4
5// Find all files in subdirectories
6$allFiles = glob('**/*.txt', GLOB_BRACE);
7
8// Find files with multiple patterns
9$images = glob('{*.jpg,*.png,*.gif}', GLOB_BRACE);
10
11// Check if files exist
12if (count($phpFiles) > 0) {
13    echo "Found " . count($phpFiles) . " PHP files\n";
14}
15
16// Process each file
17foreach ($images as $image) {
18    echo "Image: $image\n";
19}
20?>

1<?php
2declare(strict_types=1);
3
4// Simple CSV reading
5$file = fopen('data.csv', 'r');
6
7// Read header
8$header = fgetcsv($file);
9
10// Read data rows
11$data = [];
12while (($row = fgetcsv($file)) !== false) {
13    $data[] = array_combine($header, $row);
14}
15
16fclose($file);
17
18print_r($data);
19
20// Using callback
21function processCSV(string $filename, callable $callback): void {
22    $file = fopen($filename, 'r');
23    $header = fgetcsv($file);
24
25    while (($row = fgetcsv($file)) !== false) {
26        $callback(array_combine($header, $row));
27    }
28
29    fclose($file);
30}
31
32processCSV('users.csv', function($user) {
33    echo "Processing: {$user['name']}\n";
34});
35?>

1<?php
2$users = [
3    ['id' => 1, 'name' => 'John Doe', 'email' => '[email protected]'],
4    ['id' => 2, 'name' => 'Jane Smith', 'email' => '[email protected]'],
5    ['id' => 3, 'name' => 'Bob Johnson', 'email' => '[email protected]']
6];
7
8$file = fopen('export.csv', 'w');
9
10// Write header
11fputcsv($file, ['ID', 'Name', 'Email']);
12
13// Write data
14foreach ($users as $user) {
15    fputcsv($file, $user);
16}
17
18fclose($file);
19
20echo "CSV file created: export.csv\n";
21?>

1<?php
2class CSVReader {
3    private $file;
4    private array $header = [];
5
6    public function __construct(string $filename) {
7        $this->file = fopen($filename, 'r');
8        $this->header = fgetcsv($this->file) ?: [];
9    }
10
11    public function __destruct() {
12        if (is_resource($this->file)) {
13            fclose($this->file);
14        }
15    }
16
17    public function getRows(): \Generator {
18        while (($row = fgetcsv($this->file)) !== false) {
19            yield array_combine($this->header, $row);
20        }
21    }
22
23    public function filter(callable $callback): array {
24        $results = [];
25        foreach ($this->getRows() as $row) {
26            if ($callback($row)) {
27                $results[] = $row;
28            }
29        }
30        return $results;
31    }
32
33    public function map(callable $callback): array {
34        $results = [];
35        foreach ($this->getRows() as $row) {
36            $results[] = $callback($row);
37        }
38        return $results;
39    }
40}
41
42// Usage
43$csv = new CSVReader('data.csv');
44
45// Filter rows
46$filtered = $csv->filter(fn($row) => $row['age'] > 18);
47
48// Transform rows
49$names = $csv->map(fn($row) => $row['name']);
50?>

1<?php
2declare(strict_types=1);
3
4// Read JSON file
5$json = file_get_contents('config.json');
6$data = json_decode($json, true);
7
8// Check for errors
9if (json_last_error() !== JSON_ERROR_NONE) {
10    throw new Exception('JSON decode error: ' . json_last_error_msg());
11}
12
13print_r($data);
14
15// With error handling
16function readJSON(string $filename): array {
17    if (!file_exists($filename)) {
18        throw new Exception("File not found: $filename");
19    }
20
21    $json = file_get_contents($filename);
22    $data = json_decode($json, true);
23
24    if (json_last_error() !== JSON_ERROR_NONE) {
25        throw new Exception(
26            "Invalid JSON in $filename: " . json_last_error_msg()
27        );
28    }
29
30    return $data;
31}
32
33try {
34    $config = readJSON('config.json');
35} catch (Exception $e) {
36    echo "Error: " . $e->getMessage() . "\n";
37}
38?>

1<?php
2$data = [
3    'app' => [
4        'name' => 'My Application',
5        'version' => '1.0.0',
6        'debug' => true
7    ],
8    'database' => [
9        'host' => 'localhost',
10        'port' => 3306,
11        'name' => 'myapp'
12    ]
13];
14
15// Write JSON with pretty formatting
16file_put_contents(
17    'config.json',
18    json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)
19);
20
21// Write JSON safely
22function writeJSON(string $filename, array $data): void {
23    $json = json_encode(
24        $data,
25        JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE
26    );
27
28    if ($json === false) {
29        throw new Exception('JSON encode error: ' . json_last_error_msg());
30    }
31
32    $result = file_put_contents($filename, $json, LOCK_EX);
33
34    if ($result === false) {
35        throw new Exception("Failed to write file: $filename");
36    }
37}
38
39writeJSON('output.json', $data);
40?>

1<?php
2class JSONStore {
3    public function __construct(private string $filename) {
4        if (!file_exists($filename)) {
5            file_put_contents($filename, '[]');
6        }
7    }
8
9    public function read(): array {
10        $json = file_get_contents($this->filename);
11        return json_decode($json, true) ?: [];
12    }
13
14    public function write(array $data): void {
15        $json = json_encode($data, JSON_PRETTY_PRINT);
16        file_put_contents($this->filename, $json, LOCK_EX);
17    }
18
19    public function add(array $item): void {
20        $data = $this->read();
21        $data[] = $item;
22        $this->write($data);
23    }
24
25    public function find(callable $callback): ?array {
26        $data = $this->read();
27        foreach ($data as $item) {
28            if ($callback($item)) {
29                return $item;
30            }
31        }
32        return null;
33    }
34
35    public function update(callable $finder, array $updates): bool {
36        $data = $this->read();
37        foreach ($data as $key => $item) {
38            if ($finder($item)) {
39                $data[$key] = array_merge($item, $updates);
40                $this->write($data);
41                return true;
42            }
43        }
44        return false;
45    }
46
47    public function delete(callable $finder): bool {
48        $data = $this->read();
49        $originalCount = count($data);
50
51        $data = array_filter($data, fn($item) => !$finder($item));
52
53        if (count($data) < $originalCount) {
54            $this->write(array_values($data));
55            return true;
56        }
57
58        return false;
59    }
60}
61
62// Usage
63$store = new JSONStore('users.json');
64
65// Add user
66$store->add(['id' => 1, 'name' => 'John', 'email' => '[email protected]']);
67
68// Find user
69$user = $store->find(fn($u) => $u['id'] === 1);
70
71// Update user
72$store->update(
73    fn($u) => $u['id'] === 1,
74    ['email' => '[email protected]']
75);
76
77// Delete user
78$store->delete(fn($u) => $u['id'] === 1);
79?>

1<?php
2declare(strict_types=1);
3
4if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_FILES['upload'])) {
5    $file = $_FILES['upload'];
6
7    // Check for upload errors
8    if ($file['error'] !== UPLOAD_ERR_OK) {
9        $error = match($file['error']) {
10            UPLOAD_ERR_INI_SIZE => 'File too large (server limit)',
11            UPLOAD_ERR_FORM_SIZE => 'File too large (form limit)',
12            UPLOAD_ERR_PARTIAL => 'File partially uploaded',
13            UPLOAD_ERR_NO_FILE => 'No file uploaded',
14            default => 'Upload error'
15        };
16        throw new Exception($error);
17    }
18
19    // Move uploaded file
20    $destination = 'uploads/' . basename($file['name']);
21    if (!move_uploaded_file($file['tmp_name'], $destination)) {
22        throw new Exception('Failed to move uploaded file');
23    }
24
25    echo "File uploaded: $destination\n";
26}
27?>

1<?php
2class FileUploader {
3    private int $maxSize = 5242880; // 5MB
4    private array $allowedTypes = [
5        'image/jpeg',
6        'image/png',
7        'image/gif'
8    ];
9    private string $uploadDir = 'uploads/';
10
11    public function upload(array $file): string {
12        // Validate upload
13        $this->validateUpload($file);
14
15        // Generate unique filename
16        $extension = pathinfo($file['name'], PATHINFO_EXTENSION);
17        $filename = bin2hex(random_bytes(16)) . '.' . $extension;
18        $destination = $this->uploadDir . $filename;
19
20        // Create upload directory if needed
21        if (!is_dir($this->uploadDir)) {
22            mkdir($this->uploadDir, 0755, true);
23        }
24
25        // Move file
26        if (!move_uploaded_file($file['tmp_name'], $destination)) {
27            throw new Exception('Failed to save file');
28        }
29
30        return $destination;
31    }
32
33    private function validateUpload(array $file): void {
34        // Check for errors
35        if ($file['error'] !== UPLOAD_ERR_OK) {
36            throw new Exception('Upload error');
37        }
38
39        // Check file size
40        if ($file['size'] > $this->maxSize) {
41            throw new Exception('File too large. Max: 5MB');
42        }
43
44        // Check MIME type
45        $finfo = finfo_open(FILEINFO_MIME_TYPE);
46        $mimeType = finfo_file($finfo, $file['tmp_name']);
47        finfo_close($finfo);
48
49        if (!in_array($mimeType, $this->allowedTypes)) {
50            throw new Exception('Invalid file type');
51        }
52
53        // Check file extension
54        $extension = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION));
55        $allowedExtensions = ['jpg', 'jpeg', 'png', 'gif'];
56
57        if (!in_array($extension, $allowedExtensions)) {
58            throw new Exception('Invalid file extension');
59        }
60    }
61}
62
63// Usage
64try {
65    $uploader = new FileUploader();
66    $path = $uploader->upload($_FILES['image']);
67    echo "File saved: $path\n";
68} catch (Exception $e) {
69    echo "Upload failed: " . $e->getMessage() . "\n";
70}
71?>

1<?php
2class ImageUploader extends FileUploader {
3    public function upload(array $file): string {
4        parent::upload($file);
5
6        // Additional image validation
7        $imageInfo = getimagesize($file['tmp_name']);
8
9        if ($imageInfo === false) {
10            throw new Exception('Invalid image file');
11        }
12
13        [$width, $height] = $imageInfo;
14
15        // Check dimensions
16        if ($width > 4000 || $height > 4000) {
17            throw new Exception('Image too large. Max: 4000x4000');
18        }
19
20        if ($width < 100 || $height < 100) {
21            throw new Exception('Image too small. Min: 100x100');
22        }
23
24        // Continue with upload
25        return parent::upload($file);
26    }
27}
28?>