0Pricing
PHP Academy · Lekcja

Obsługa przesyłania plików

Bezpiecznie przetwarzaj przesłane pliki za pomocą superglobalnej _FILES

Obsługa przesyłania plików to bezpłatna lekcja PHP Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej PHP Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs PHP Academy zawiera 4 lekcji w sumie.

Przegląd przesyłania plików w PHP

PHP obsługuje przesyłanie plików za pomocą superglobalnej zmiennej $_FILES. Formularz musi używać method="POST" oraz enctype="multipart/form-data".

Formularz HTML do przesyłania plików

Konfiguracja formularza HTML do przesyłania jednego lub wielu plików:

<!-- Single file -->
<form method="POST" action="upload.php"
      enctype="multipart/form-data">
    <input type="file" name="document">
    <button>Upload</button>
</form>

<!-- Multiple files -->
<form method="POST" enctype="multipart/form-data">
    <input type="file" name="photos[]" multiple>
    <button>Upload All</button>
</form>

Struktura $_FILES

Każdy przesłany plik ma pięć elementów w $_FILES:

<?php
$file = $_FILES['document'];

echo $file['name'];      // original name: report.pdf
echo $file['type'];      // browser-reported MIME: application/pdf
echo $file['tmp_name'];  // server temp path: /tmp/phpXXXXXX
echo $file['error'];     // error code: 0 = UPLOAD_ERR_OK
echo $file['size'];      // file size in bytes

Kody błędów przesyłania

Przed przetworzeniem pliku należy zawsze sprawdzić $file['error']:

<?php
$errorMessages = [
    UPLOAD_ERR_INI_SIZE   => 'Exceeds upload_max_filesize in php.ini',
    UPLOAD_ERR_FORM_SIZE  => 'Exceeds MAX_FILE_SIZE in form',
    UPLOAD_ERR_PARTIAL    => 'Only partially uploaded',
    UPLOAD_ERR_NO_FILE    => 'No file uploaded',
    UPLOAD_ERR_NO_TMP_DIR => 'Missing temp folder',
    UPLOAD_ERR_CANT_WRITE => 'Failed to write to disk',
    UPLOAD_ERR_EXTENSION  => 'PHP extension stopped upload',
];

$err = $_FILES['doc']['error'];
if ($err !== UPLOAD_ERR_OK) {
    die($errorMessages[$err] ?? 'Unknown error');
}

Bezpieczna walidacja typu pliku

Nigdy nie należy ufać typowi MIME podanemu przez przeglądarkę — należy go zweryfikować na podstawie rzeczywistej zawartości pliku:

<?php
$tmp  = $_FILES['image']['tmp_name'];
$allowed = ['image/jpeg', 'image/png', 'image/webp'];

// Check real MIME type from file content
$realMime = mime_content_type($tmp);

if (!in_array($realMime, $allowed)) {
    die('Invalid file type: ' . $realMime);
}

Walidacja rozmiaru pliku

Należy wymuszać limity rozmiaru po stronie serwera, nawet jeśli formularz HTML zawiera ukryte pole MAX_FILE_SIZE:

<?php
$maxBytes = 5 * 1024 * 1024;  // 5MB
$size     = $_FILES['video']['size'];

if ($size > $maxBytes) {
    $mb = round($size / 1024 / 1024, 2);
    die("File too large: {$mb}MB (max 5MB)");
}

is_uploaded_file i move_uploaded_file

Należy zawsze używać tych dwóch funkcji, aby potwierdzić, że plik został przesłany przez HTTP, oraz bezpiecznie go przenieść:

<?php
$tmp  = $_FILES['photo']['tmp_name'];
$dest = '/var/www/uploads/' . basename($_FILES['photo']['name']);

if (!is_uploaded_file($tmp)) {
    die('Not an uploaded file — possible attack');
}

if (!move_uploaded_file($tmp, $dest)) {
    die('Failed to move uploaded file');
}

echo 'Upload saved to: ' . $dest;

Generowanie bezpiecznych nazw plików

Należy wygenerować losową nazwę pliku, aby zapobiec atakom polegającym na przechodzeniu przez katalogi i nadpisywaniu plików:

<?php
$originalName = $_FILES['doc']['name'];
$ext          = strtolower(pathinfo($originalName, PATHINFO_EXTENSION));

$allowedExts = ['jpg', 'jpeg', 'png', 'pdf'];
if (!in_array($ext, $allowedExts)) {
    die('File type not allowed');
}

$safeName = bin2hex(random_bytes(16)) . '.' . $ext;
$dest     = '/var/www/uploads/' . $safeName;

move_uploaded_file($_FILES['doc']['tmp_name'], $dest);

Obsługa przesyłania wielu plików

Podczas używania name="photos[]" zmienna $_FILES zawiera tablice — należy je iterować:

<?php
$files = $_FILES['photos'];
$count = count($files['name']);

for ($i = 0; $i < $count; $i++) {
    if ($files['error'][$i] !== UPLOAD_ERR_OK) continue;
    
    $tmp  = $files['tmp_name'][$i];
    $ext  = pathinfo($files['name'][$i], PATHINFO_EXTENSION);
    $dest = '/uploads/' . uniqid() . '.' . strtolower($ext);
    
    move_uploaded_file($tmp, $dest);
    echo "Saved: $dest" . PHP_EOL;
}

Ustawienia przesyłania w php.ini

Najważniejsze dyrektywy php.ini wpływające na przesyłanie plików:

  • file_uploads = On — włączenie przesyłania
  • upload_max_filesize = 8M — maksymalny rozmiar pojedynczego pliku
  • post_max_size = 32M — maksymalny rozmiar treści żądania POST (musi być większy niż upload_max_filesize)
  • max_file_uploads = 20 — maksymalna liczba plików w jednym żądaniu

Zmiana rozmiaru obrazu po przesłaniu

Po przesłaniu obrazu należy użyć biblioteki GD, aby zmienić jego rozmiar:

<?php
function resizeImage(string $src, string $dst, int $maxW): void {
    [$w, $h, $type] = getimagesize($src);
    $ratio   = $maxW / $w;
    $newH    = (int) ($h * $ratio);
    $srcImg  = imagecreatefromjpeg($src);
    $dstImg  = imagecreatetruecolor($maxW, $newH);
    imagecopyresampled($dstImg, $srcImg, 0,0,0,0, $maxW, $newH, $w, $h);
    imagejpeg($dstImg, $dst, 90);
    imagedestroy($srcImg);
    imagedestroy($dstImg);
}

Szybkie sprawdzenie

Jaka funkcja PHP jest wymagana do bezpiecznego przeniesienia przesłanego pliku do miejsca docelowego?

Podsumowanie: przesyłanie plików

Lista kontrolna obsługi przesyłania plików:

  • formularz musi używać method=POST enctype=multipart/form-data
  • należy sprawdzić $_FILES['field']['error'] === UPLOAD_ERR_OK
  • należy zweryfikować rzeczywisty typ MIME za pomocą mime_content_type()
  • należy zweryfikować rozmiar pliku po stronie serwera
  • należy używać move_uploaded_file(), a nie rename/copy
  • należy generować losowe nazwy plików, aby zapobiegać konfliktom

Często zadawane pytania

Czy lekcja „Obsługa przesyłania plików” jest bezpłatna?

Tak — pełny tekst „Obsługa przesyłania plików” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu PHP Academy, przejdź na CoddyKit PRO. Kurs PHP Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa przesyłania plików”?

Bezpiecznie przetwarzaj przesłane pliki za pomocą superglobalnej _FILES Ćwiczysz PHP Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć PHP Academy?

Nie wymagamy żadnego doświadczenia. PHP Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Obsługa przesyłania plików”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji PHP Academy?

Tak. Każda lekcja PHP Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Odczytywanie plików za pomocą PHP
  2. Zapisywanie danych w plikach i dopisywanie do nich
  3. Praca z katalogami
  4. Obsługa przesyłania plików
← Powrót do PHP Academy