Operacje na plikach w PHP to nic innego jak tworzenie plików z danymi oraz odczytywanie danych z plików. Pełną listę funkcji znajdziecie w dokumentacji PHP – funkcje systemu plików,  poniżej najczęściej wykorzystywane.

Operacje na plikach w PHP mają podobną formę jak w C.

Zapisywanie danych w pliku następuje w 3 etapach:

1. Otwieramy plik lub go tworzymy
2. Zapisujemy dane w pliku
3. Zamykamy plik

Odczytywanie danych z pliku również przebiega 3-etapowo:

1. Otwieramy plik, a jeżeli takowy nie może zostać otwarty musi zostać oprogramowane zgłoszenie błędu
2. Odczytujemy dane
3. Zamykamy plik

file_exists() – sprawdzamy czy plik istnieje

Funkcja sprawdza czy plik lub katalog istnieje.

<?php
if (file_exists('plik.txt')) {
    echo "Plik istnieje";
} else {
    echo "Plik nie istnieje";
}

// Sprawdź przed operacją
if (!file_exists('dane.txt')) {
    file_put_contents('dane.txt', '');  // utwórz pusty plik
}

 is_file() / is_dir() / is_readable() / is_writable()

<?php
$path = 'dokument.pdf';

// Czy to plik?
if (is_file($path)) {
    echo "$path jest plikiem\n";
}

// Czy można odczytać?
if (is_readable($path)) {
    echo "Można odczytać\n";
}

// Czy można zapisać?
if (is_writable($path)) {
    echo "Można zapisać\n";
}

// Czy to katalog?
if (is_dir('uploads')) {
    echo "uploads jest katalogiem\n";
}

fopen(nazwa_pliku, tryb_otwierania) – otwieranie pliku

Przykład:

<?php
$plik = fopen('dane.txt', 'r');

if ($plik === false) {
    die('Nie udało się otworzyć pliku');
}

// ... operacje na pliku ...

fclose($plik);

nazwa pliku – musimy pamiętać o ścieżce dostępu do naszego pliku, jeżeli tryb otwierania jest ustawiony na ”r” czyli tylko do odczytu, to za nazwę pliku może służyć adres URL do pliku. Należy uważać, by nie stworzyć pliku o nazwie, która już istnieje – istniejący plik zostanie wtedy trwale usunięty w miejsce nowo stworzonego.

Tryby otwierania pliku

<?php
// Odczyt - plik musi istnieć
$plik = fopen('dane.txt', 'r');

// Zapis - nadpisze cały plik
$plik = fopen('dane.txt', 'w');

// Dopisywanie - na końcu pliku
$plik = fopen('log.txt', 'a');

// Utwórz nowy - błąd jeśli istnieje
$plik = fopen('nowy.txt', 'x');

fclose() – zamykanie pliku

<?php
$plik = fopen('dane.txt', 'r');

// ... operacje ...

fclose($plik);

Zapisywanie danych do pliku

fwrite() / fputs() – zapis danych

fputs() to alias dla fwrite(). Powyższa funkcja zapisuje do pliku tekst, zawarty w zmiennej $tresc. Podczas wywołania funkcji można dodać trzeci, opcjonalny argument, $dlugosc. Jeżeli go zamieścimy, do pliku zostanie zapisanych maksymalnie $dlugosc znaków. Zależnie od trybu otwarcia, zawartość zostanie dopisana na końcu pliku, lub nadpisze istniejącą treść. Jest ona równoważna z instrukcją fputs().

<?php
$plik = fopen('dane.txt', 'w');

if ($plik === false) {
    die('Błąd otwarcia pliku');
}

$tresc = "To jest przykładowa treść.\n";
$tresc .= "Druga linia tekstu.\n";

fwrite($plik, $tresc);
fclose($plik);

echo "Dane zapisane!";

Poniżej przykład z użyciem limitu znaków:

<?php
$plik = fopen('dane.txt', 'w');

$tresc = "Przykładowa treść, którą umieścimy w pliku.";
fwrite($plik, $tresc, 30);  // zapisze tylko 30 znaków

fclose($plik);

Pełny przykład zapisu:

<?php
// 1. Otwieramy plik w trybie dopisywania
$plik = fopen('log.txt', 'a') or die('Nie można otworzyć pliku');

// 2. Przygotuj dane
$data = date('Y-m-d H:i:s');
$wiadomosc = "[$data] Użytkownik zalogował się\n";

// 3. Zapisz do pliku
fwrite($plik, $wiadomosc) or die('Nie można zapisać danych');

// 4. Zamknij plik
fclose($plik);

echo "Wpis dodany do logu!";

Odczytywanie pliku

Istnieje kilka sposobów na odczytanie zawartości pliku.

fread() – odczyt określonej długości

Funkcja  czyta z pliku określoną długość znaków. Czytanie zakończy się, jeżeli osiągnięta zostanie $dlugość znaków, koniec pliku lub odczytanych zostanie 8192 bajtów. Długość całego pliku możemy określić za pomocą funkcji filesize(„nazwa_pliku.txt”)

Przykład:

<?php
$plik = fopen('dane.txt', 'r');

if ($plik === false) {
    die('Nie można otworzyć pliku');
}

// Odczytaj 100 znaków
$zawartosc = fread($plik, 100);

// Lub odczytaj cały plik
// $zawartosc = fread($plik, filesize('dane.txt'));

echo $zawartosc;
fclose($plik);

fgets() – odczyt linia po linii

Innym sposobem na czytanie zawartości jest funkcja . Czyta ona jedną linię pliku, dopóki nie napotka znacznika przejścia do kolejnej linii. Żeby odczytać cały plik, wystarczy użyć pętli. W przypadku tej metody nie musimy się martwić, czy cały plik zostanie odczytany, czy przypadkiem nie przekroczyliśmy długości znaków. Funkcja feof() zwraca true, jeśli osiągnęliśmy koniec pliku. Przykład czytania pliku z użyciem fgets:

<?php
$plik = fopen('dane.txt', 'r');

if ($plik === false) {
    die('Nie można otworzyć pliku');
}

echo "<pre>";

// Czytaj linię po linii
while (!feof($plik)) {
    $linia = fgets($plik);
    echo htmlspecialchars($linia);
}

echo "</pre>";
fclose($plik);

feof() – zwraca true, gdy osiągnięto koniec pliku.

fgetc() – odczyt znak po znaku

jest bardzo podobna w użyciu do fgets, z tą jednak różnicą, że czytamy po jednym znaku. Przykład niemal identyczny:

<?php
$plik = fopen('dane.txt', 'r');

if ($plik === false) {
    die('Nie można otworzyć pliku');
}

$zawartosc = '';

while (!feof($plik)) {
    $znak = fgetc($plik);
    $zawartosc .= $znak;
}

echo $zawartosc;
fclose($plik);

rewind() – cofnij wskaźnik na początek

UWAGA: jeżeli kursor znajduje się na końcu pliku, to żeby odczytać dane należy przenieść kursor na początek:

<?php
$plik = fopen('dane.txt', 'r+');

// Odczytaj cały plik
$zawartosc = fread($plik, filesize('dane.txt'));

// Cofnij wskaźnik na początek
rewind($plik);

// Zapisz nowe dane
fwrite($plik, 'Nowa treść');

fclose($plik);

Blokowanie plików

Blokowanie plików ważnym zagadnieniem w kontekście operacji na plikach. Jeśli wiele osób jednocześnie wchodzi na stronę i plik jest zapisywany (np. licznik), może dojść do nadpisania danych.
Dlatego używamy blokad – flock()

Tryby blokad:

• LOCK_SH – blokada współdzielona (tylko odczyt, wiele procesów może czytać jednocześnie)

• LOCK_EX – blokada wyłączna (zapis, tylko jeden proces ma dostęp (zapis))

• LOCK_UN – zwolnienie blokady

• LOCK_NB – nie czekaj, jeśli plik jest zablokowany

<?php
$plik = fopen('licznik.txt', 'r+');

// Zablokuj plik (wyłącznie)
flock($plik, LOCK_EX);

// Odczytaj aktualną wartość
$liczba = (int)fread($plik, filesize('licznik.txt'));
$liczba++;

// Cofnij wskaźnik i zapisz nową wartość
rewind($plik);
fwrite($plik, $liczba);
fflush($plik);  // wymuś zapis na dysk

// Odblokuj plik
flock($plik, LOCK_UN);

fclose($plik);

echo "Liczba odwiedzin: $liczba";

Dlaczego flock() jest ważny:
Bez niego kilku użytkowników jednocześnie mogłoby odczytać tę samą wartość i zapisać ją, przez co licznik „zgubiłby” odwiedziny.

Ważne: Zawsze zamykaj pliki po użyciu, aby zwolnić zasoby systemowe.

Przykład: licznik odwiedzin

<?php
function incrementCounter(string $file): int {
    // Utwórz plik jeśli nie istnieje
    if (!file_exists($file)) {
        file_put_contents($file, '0');
    }
    
    $fp = fopen($file, 'r+');
    
    if ($fp === false) {
        return 0;
    }
    
    // Blokada wyłączna
    flock($fp, LOCK_EX);
    
    // Odczytaj
    $liczba = (int)fread($fp, filesize($file));
    $liczba++;
    
    // Zapisz
    rewind($fp);
    fwrite($fp, $liczba);
    fflush($fp);
    
    // Odblokuj i zamknij
    flock($fp, LOCK_UN);
    fclose($fp);
    
    return $liczba;
}

// Użycie
$odwiedziny = incrementCounter('licznik.txt');
echo "Odwiedziny: $odwiedziny";

unlink() – usuwanie pliku

Przykład:

<?php
$plik = 'do_usuniecia.txt';

if (file_exists($plik)) {
    if (unlink($plik)) {
        echo "Plik usunięty";
    } else {
        echo "Błąd usuwania";
    }
} else {
    echo "Plik nie istnieje";
}

Nie każdy plik może zostać usunięty, wszystko zależy od odpowiednich praw dostępu.

Uwaga: Plik jest usuwany permanentnie (nie trafia do kosza).

copy() – kopiowanie pliku

Pozwala utworzyć duplikat pliku w nowej lokalizacji.

Przykład:

<?php
$zrodlo = 'dane.txt';
$cel = 'kopia_dane.txt';

if (copy($zrodlo, $cel)) {
    echo "Plik skopiowany";
} else {
    echo "Błąd kopiowania";
}

// Kopiowanie do innego katalogu
copy('dane.txt', 'backup/dane.txt');

Uwaga: Jeśli plik docelowy istnieje, zostanie nadpisany.

rename() – zmiana nazwy / przenoszenie

Ta funkcja zmienia nazwę pliku lub przenosi go do innego katalogu.

Przykład:

<?php
// Zmiana nazwy
rename('stara_nazwa.txt', 'nowa_nazwa.txt');

// Przeniesienie do innego katalogu
rename('plik.txt', 'archiwum/plik.txt');

// Przeniesienie + zmiana nazwy
rename('dane.txt', 'backup/dane_2025.txt');

// Działa też dla katalogów
rename('stary_folder', 'nowy_folder');

Działa także dla katalogów.

filesize() – rozmiar pliku

<?php
$plik = 'dokument.pdf';

if (file_exists($plik)) {
    $rozmiar = filesize($plik);
    echo "Rozmiar: $rozmiar bajtów\n";
    
    // Sformatowany
    echo "Rozmiar: " . formatBytes($rozmiar);
}

function formatBytes(int $bytes, int $precision = 2): string {
    $units = ['B', 'KB', 'MB', 'GB', 'TB'];
    
    for ($i = 0; $bytes > 1024 && $i < count($units) - 1; $i++) {
        $bytes /= 1024;
    }
    
    return round($bytes, $precision) . ' ' . $units[$i];
}

filemtime() – data ostatniej modyfikacji

<?php
$plik = 'dane.txt';

if (file_exists($plik)) {
    $timestamp = filemtime($plik);
    
    echo "Ostatnia modyfikacja: " . date('Y-m-d H:i:s', $timestamp);
    
    // Sprawdź wiek pliku
    $wiek = time() - $timestamp;
    $dni = floor($wiek / (60 * 60 * 24));
    
    echo "\nPlik ma $dni dni";
}

Alternatywne podejście

Trzeba pamiętać, że funkcja fopen() daje większą kontrolę i lepiej sprawdza się w „poważniejszych” zastosowaniach (duże dane, blokady, odczyt/zapis równocześnie). Istnieje dla niej prostsza alternatywa.

file_put_contents() – prostszy zapis

W PHP najprostszy i najszybszy sposób zapisu danych do pliku to użycie funkcji file_put_contents():

• jedna linijka kodu
• automatyczne otwarcie i zamknięcie
• szybkie i czytelne

<?php
// Podstawowy zapis (nadpisuje plik)
$dane = "To jest przykładowy tekst.\n";
file_put_contents('plik.txt', $dane);

// Dopisywanie na końcu
file_put_contents('log.txt', $dane, FILE_APPEND);

// Zapis tablicy
$tablica = ['Jan', 'Anna', 'Piotr'];
file_put_contents('lista.txt', implode("\n", $tablica));

// Sprawdź czy się udało
$wynik = file_put_contents('dane.txt', 'treść');
if ($wynik !== false) {
    echo "Zapisano $wynik bajtów";
}

• tworzy plik plik.txt (jeśli nie istnieje),
• zapisuje w nim zawartość zmiennej $dane,
• jeśli plik już istnieje — nadpisze go.

Dopisywanie do istniejącego pliku (zamiast nadpisywania):

Użycie flagi FILE_APPEND:

<?php
$dane = "Nowa linia\n";
file_put_contents("plik.txt", $dane, FILE_APPEND);
?>

Wtedy kolejne wywołania dopisują treść na końcu pliku.

file_get_contents() – prostszy odczyt

<?php
// Odczyt całego pliku
$zawartosc = file_get_contents('dane.txt');
echo $zawartosc;

// Z zewnętrznego URL
$html = file_get_contents('https://example.com');

// Sprawdź błędy
$zawartosc = file_get_contents('dane.txt');
if ($zawartosc === false) {
    echo "Błąd odczytu";
}

file() – odczyt do tablicy

Każda linia pliku staje się elementem tablicy.

<?php
// Odczyt linii do tablicy
$linie = file('dane.txt');

foreach ($linie as $nr => $linia) {
    echo "Linia " . ($nr + 1) . ": " . $linia;
}

// Bez pustych linii i \n
$linie = file('dane.txt', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

print_r($linie);

Flagi:

• FILE_IGNORE_NEW_LINES – usuwa \n z końca linii
• FILE_SKIP_EMPTY_LINES – pomija puste linie

Porównanie metod

<?php
// ============================================
// TRADYCYJNA METODA (3 kroki)
// ============================================
$plik = fopen('dane.txt', 'w');
fwrite($plik, 'Treść');
fclose($plik);

// ============================================
// NOWOCZESNA METODA (1 linijka)
// ============================================
file_put_contents('dane.txt', 'Treść');


// ============================================
// ODCZYT - tradycyjny
// ============================================
$plik = fopen('dane.txt', 'r');
$zawartosc = fread($plik, filesize('dane.txt'));
fclose($plik);

// ============================================
// ODCZYT - nowoczesny
// ============================================
$zawartosc = file_get_contents('dane.txt');

Przykłady praktyczne

1. System logowania

<?php
function logEvent(string $message, string $level = 'INFO'): void {
    $logFile = 'app.log';
    $timestamp = date('Y-m-d H:i:s');
    $logEntry = "[$timestamp] [$level] $message\n";
    
    file_put_contents($logFile, $logEntry, FILE_APPEND | LOCK_EX);
}

// Użycie
logEvent('Użytkownik zalogowany', 'INFO');
logEvent('Błąd połączenia z bazą', 'ERROR');
logEvent('Ostrzeżenie: mało miejsca', 'WARNING');

2. Cache systemu

<?php
function cache(string $key, callable $callback, int $ttl = 3600): mixed {
    $cacheFile = "cache/$key.cache";
    
    // Sprawdź czy cache jest aktualny
    if (file_exists($cacheFile) && (time() - filemtime($cacheFile)) < $ttl) {
        return unserialize(file_get_contents($cacheFile));
    }
    
    // Wygeneruj nowe dane
    $data = $callback();
    
    // Zapisz w cache
    if (!is_dir('cache')) {
        mkdir('cache', 0755, true);
    }
    file_put_contents($cacheFile, serialize($data), LOCK_EX);
    
    return $data;
}

// Użycie
$users = cache('users', function() {
    // Symulacja wolnego zapytania do bazy
    sleep(2);
    return ['Jan', 'Anna', 'Piotr'];
}, 60);  // cache na 60 sekund

print_r($users);

3. Prosty licznik odwiedzin

<?php
function getVisitCount(string $file = 'counter.txt'): int {
    if (!file_exists($file)) {
        file_put_contents($file, '0');
    }
    
    $fp = fopen($file, 'r+');
    flock($fp, LOCK_EX);
    
    $count = (int)fgets($fp);
    $count++;
    
    rewind($fp);
    fwrite($fp, $count);
    fflush($fp);
    
    flock($fp, LOCK_UN);
    fclose($fp);
    
    return $count;
}

$visits = getVisitCount();
echo "Odwiedziny: $visits";

4. CSV reader/writer

<?php
class CSVHandler {
    private string $file;
    
    public function __construct(string $file) {
        $this->file = $file;
    }
    
    public function read(): array {
        if (!file_exists($this->file)) {
            return [];
        }
        
        $data = [];
        $handle = fopen($this->file, 'r');
        
        // Pomijamy nagłówek
        fgetcsv($handle);
        
        while (($row = fgetcsv($handle)) !== false) {
            $data[] = $row;
        }
        
        fclose($handle);
        return $data;
    }
    
    public function write(array $data, array $header = []): void {
        $handle = fopen($this->file, 'w');
        
        // Zapisz nagłówek
        if (!empty($header)) {
            fputcsv($handle, $header);
        }
        
        // Zapisz dane
        foreach ($data as $row) {
            fputcsv($handle, $row);
        }
        
        fclose($handle);
    }
    
    public function append(array $row): void {
        $handle = fopen($this->file, 'a');
        fputcsv($handle, $row);
        fclose($handle);
    }
}

// Użycie
$csv = new CSVHandler('users.csv');

// Zapis
$csv->write([
    ['Jan', 'Kowalski', 30],
    ['Anna', 'Nowak', 25]
], ['Imię', 'Nazwisko', 'Wiek']);

// Odczyt
$users = $csv->read();
print_r($users);

// Dopisz
$csv->append(['Piotr', 'Wiśniewski', 35]);

5. Prosty szablon z plikami

<?php
function renderTemplate(string $template, array $vars = []): string {
    $file = "templates/$template.html";
    
    if (!file_exists($file)) {
        throw new Exception("Template not found: $template");
    }
    
    $content = file_get_contents($file);
    
    // Zamień zmienne {{zmienna}}
    foreach ($vars as $key => $value) {
        $content = str_replace("{{" . $key . "}}", $value, $content);
    }
    
    return $content;
}

// templates/email.html:
// <h1>Witaj {{name}}!</h1>
// <p>Twoje konto zostało utworzone. Twój email to: {{email}}</p>

// Użycie
echo renderTemplate('email', [
    'name' => 'Jan',
    'email' => 'jan@example.com'
]);

6. Zapis/odczyt danych z formularza do pliku i usunięcie pliku

index.php:

<?php
// ============================================
// FORMULARZ Z ZAPISEM DO PLIKU
// ============================================

if (empty($_POST['pole1']) && empty($_POST['pole2'])) {
    // Wyświetl formularz
    ?>
    <!DOCTYPE html>
    <html lang="pl">
    <head>
        <meta charset="UTF-8">
        <title>Formularz</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                max-width: 600px;
                margin: 50px auto;
                padding: 20px;
            }
            input, textarea {
                width: 100%;
                padding: 10px;
                margin: 10px 0;
                box-sizing: border-box;
            }
            button {
                background: #007bff;
                color: white;
                padding: 10px 20px;
                border: none;
                cursor: pointer;
            }
            button:hover {
                background: #0056b3;
            }
        </style>
    </head>
    <body>
        <h2>Formularz zapisu danych</h2>
        <form method="POST">
            <label>Tytuł:</label>
            <input type="text" name="pole1" required>
            
            <label>Treść:</label>
            <textarea name="pole2" rows="5" required></textarea>
            
            <button type="submit">Zapisz</button>
        </form>
    </body>
    </html>
    <?php
} else {
    // Przetwórz formularz
    $pole1 = trim($_POST['pole1']);
    $pole2 = trim($_POST['pole2']);
    
    // Walidacja
    if (empty($pole1) || empty($pole2)) {
        die('Wszystkie pola są wymagane!');
    }
    
    // Zabezpieczenia
    $pole1 = htmlspecialchars($pole1, ENT_QUOTES, 'UTF-8');
    $pole2 = htmlspecialchars($pole2, ENT_QUOTES, 'UTF-8');
    
    // Przygotuj dane (separator `)
    $dane = $pole1 . "`" . $pole2 . "\n";
    
    // Zapisz z blokowaniem
    $file = "baza.txt";
    $fp = fopen($file, "a");
    
    if ($fp === false) {
        die('Błąd otwarcia pliku');
    }
    
    flock($fp, LOCK_EX);        // blokada
    fwrite($fp, $dane);          // zapis
    fflush($fp);                 // wymuś zapis
    flock($fp, LOCK_UN);         // odblokuj
    fclose($fp);
    
    echo '<!DOCTYPE html>
    <html lang="pl">
    <head>
        <meta charset="UTF-8">
        <title>Sukces</title>
        <style>
            body { font-family: Arial; max-width: 600px; margin: 50px auto; }
            .success { background: #d4edda; padding: 15px; border: 1px solid #c3e6cb; }
            a { color: #007bff; }
        </style>
    </head>
    <body>
        <div class="success">
            <h2>Dane zostały zapisane!</h2>
        </div>
        <p><a href="podglad.php">Zobacz wszystkie wpisy</a></p>
        <p><a href="index.php">Dodaj kolejny wpis</a></p>
    </body>
    </html>';
}

podglad.php:

<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Podgląd wpisów</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        .wpis {
            background: #f8f9fa;
            padding: 15px;
            margin: 15px 0;
            border-left: 4px solid #007bff;
        }
        .tytul {
            font-size: 1.2em;
            font-weight: bold;
            color: #007bff;
            margin-bottom: 10px;
        }
        .tresc {
            color: #333;
            line-height: 1.6;
        }
        .nav {
            margin: 20px 0;
        }
        a {
            display: inline-block;
            margin-right: 10px;
            padding: 10px 15px;
            background: #007bff;
            color: white;
            text-decoration: none;
            border-radius: 4px;
        }
        a:hover {
            background: #0056b3;
        }
        .danger {
            background: #dc3545;
        }
        .danger:hover {
            background: #c82333;
        }
    </style>
</head>
<body>
    <h2>📝 Wszystkie wpisy</h2>
    
    <?php
    if (!file_exists('baza.txt') || filesize('baza.txt') == 0) {
        echo '<p>Brak wpisów w bazie.</p>';
    } else {
        $file = file('baza.txt', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
        
        foreach ($file as $nr => $value) {
            // Rozdziel po znaku `
            $exp = explode('`', $value);
            
            if (count($exp) >= 2) {
                echo '<div class="wpis">';
                echo '<div class="tytul">' . ($nr + 1) . '. ' . $exp[0] . '</div>';
                echo '<div class="tresc">' . nl2br($exp[1]) . '</div>';
                echo '</div>';
            }
        }
    }
    ?>
    
    <div class="nav">
        <a href="index.php">Dodaj kolejne dane</a>
        <a href="del.php" class="danger" onclick="return confirm('Czy na pewno usunąć wszystkie dane?')">Usuń plik</a>
    </div>
</body>
</html>

del.php:

<?php
// Usuń plik
if (file_exists('baza.txt')) {
    if (unlink('baza.txt')) {
        $message = 'Plik został usunięty';
        $class = 'success';
    } else {
        $message = 'Błąd podczas usuwania pliku';
        $class = 'error';
    }
} else {
    $message = 'Plik nie istnieje';
    $class = 'warning';
}
?>
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Usuwanie pliku</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 600px;
            margin: 50px auto;
            padding: 20px;
        }
        .message {
            padding: 15px;
            margin: 20px 0;
            border-radius: 4px;
        }
        .success {
            background: #d4edda;
            border: 1px solid #c3e6cb;
            color: #155724;
        }
        .error {
            background: #f8d7da;
            border: 1px solid #f5c6cb;
            color: #721c24;
        }
        .warning {
            background: #fff3cd;
            border: 1px solid #ffeeba;
            color: #856404;
        }
        a {
            display: inline-block;
            margin-top: 20px;
            padding: 10px 20px;
            background: #007bff;
            color: white;
            text-decoration: none;
            border-radius: 4px;
        }
        a:hover {
            background: #0056b3;
        }
    </style>
</head>
<body>
    <div class="message <?= $class ?>">
        <h2><?= $message ?></h2>
    </div>
    
    <a href="index.php">Powrót do formularza</a>
</body>
</html>

Tabela funkcji – szybka ściąga

Dobre praktyki

1. Zawsze sprawdzaj wynik operacji

// ŹLE
$plik = fopen('dane.txt', 'r');
$zawartosc = fread($plik, 100);

// DOBRZE
$plik = fopen('dane.txt', 'r');
if ($plik === false) {
    die('Błąd otwarcia pliku');
}
$zawartosc = fread($plik, filesize('dane.txt'));
fclose($plik);

2. Używaj file_put_contents() dla prostych operacji

// ŹLE - zbyt skomplikowane
$plik = fopen('log.txt', 'a');
fwrite($plik, 'wpis');
fclose($plik);

// DOBRZE - prosty i czytelny
file_put_contents('log.txt', 'wpis', FILE_APPEND);

3. Zawsze używaj flock() dla współbieżności

// ŹLE - ryzyko utraty danych
$fp = fopen('licznik.txt', 'r+');
$liczba = fgets($fp);
$liczba++;
rewind($fp);
fwrite($fp, $liczba);
fclose($fp);

// DOBRZE - bezpieczne
$fp = fopen('licznik.txt', 'r+');
flock($fp, LOCK_EX);
$liczba = fgets($fp);
$liczba++;
rewind($fp);
fwrite($fp, $liczba);
fflush($fp);
flock($fp, LOCK_UN);
fclose($fp);

4. Waliduj dane przed zapisem

// ŹLE
$dane = $_POST['dane'];
file_put_contents('plik.txt', $dane);

// DOBRZE
$dane = trim($_POST['dane']);
$dane = htmlspecialchars($dane, ENT_QUOTES, 'UTF-8');

if (empty($dane)) {
    die('Dane nie mogą być puste');
}

file_put_contents('plik.txt', $dane);

5. Używaj try-catch dla krytycznych operacji

<?php
try {
    if (!file_exists('config.ini')) {
        throw new Exception('Plik konfiguracyjny nie istnieje');
    }
    
    $config = file_get_contents('config.ini');
    
    if ($config === false) {
        throw new Exception('Błąd odczytu pliku');
    }
    
    // ... przetwarzanie ...
    
} catch (Exception $e) {
    error_log($e->getMessage());
    die('Błąd aplikacji');
}

Podsumowanie

Kluczowe pojęcia:

• fopen/fclose – tradycyjne otwieranie/zamykanie plików
• fread/fgets/fgetc – różne metody odczytu
• fwrite/fputs – zapis danych
• flock – blokowanie dla współbieżności
• file_put_contents/file_get_contents – nowoczesne, szybkie metody

Tryby otwierania:

• r – odczyt (plik musi istnieć)
• w – zapis (nadpisuje/tworzy)
• a – dopisywanie (na końcu)
• x – tworzenie (błąd jeśli istnieje)
• + – odczyt i zapis

Pamiętaj:

• Zawsze zamykaj pliki fclose()
• Używaj flock() dla współbieżnego dostępu
• Preferuj file_put_contents() dla prostych operacji
• Sprawdzaj wynik operacji (może być false)
• Waliduj dane przed zapisem
• Używaj FILE_APPEND do dopisywania
• Nie ufaj danym użytkownika
• Nie zapomnij o fflush() przy blokadach

Najważniejsze funkcje:

// Proste operacje
file_put_contents()  // zapis
file_get_contents()  // odczyt
file()              // odczyt do tablicy

// Zaawansowane
fopen()    // otwórz
fwrite()   // zapisz
fread()    // czytaj
flock()    // zablokuj
fclose()   // zamknij

// Pomocnicze
file_exists()  // czy istnieje
filesize()     // rozmiar
filemtime()    // data modyfikacji
copy()         // kopiuj
rename()       // zmień nazwę
unlink()       // usuń

Zadania do wykonania:

Zadanie 1

Generowanie i analiza losowych liczb z zapisem do pliku.

Wymagania:

1. Wygeneruj 20 losowych liczb (1-100)
2. Zapisz do liczby.txt z blokowaniem
3. Odczytaj i oblicz:
   • sumę
   • średnią
   • min i max
   • liczby parzyste/nieparzyste
4. Zapisz statystyki do statystyki.txt

Zadanie 2

Losowanie liczb w stylu Lotto z zapisem.

Wymagania:

1. Wygeneruj 6 unikalnych liczb (1-49)
2. Pobierz aktualną datę
3. Zapisz do liczby.txt w formacie: 2025-10-13 15:20:00 wylosowano liczby: 3, 15, 22, 31, 42, 45
4. Odczytaj i wyświetl zawartość