Przykładowe użycie:

Klasa PHP:

<?php

/**
 *  Simple upload class.
 *
 * @package     SimpleUpload
 * @version     1.0
 * @author      Mateusz Lerczak <mateusz@lerczak.eu>
 * @link        https://github.com/retio/SimpleUpload
 * @license     http://opensource.org/licenses/gpl-3.0.html
 */
class SimpleUpload {
    /**
     * Wersja klasy SimpleUpload
     */
    const version       = '1.0';

    /**
     * Tablica z dozwolonymi typami MIME,
     * pusta tablica = wszystki typy plików dozwolone
     * @var array
     */
    public $allowedType = array();

    /**
     * Docelowa ścierzka do zapisu pliku
     * @var string
     */
    public $destDir     = 'uploaded/';

    /**
     * Zmienna przechowuje kod błędu
     * 0 = brak błędu
     * @var int
     */
    private $_errorCode   = 0;

    /**
     * Tablica z błędami
     * @var array
     */
    private $_errorsList  = array(
        1 => "Przesłany plik jest większy niż dopuszczalny limit",
        2 => "Przesłany plik jest większy niż dopuszczalny limit!",
        3 => "Tylko część pliku została przesłana!",
        4 => "Nie przesłano pliku!",
        5 => "Przesłano niedozwolony plik!",
        6 => "Docelowa ścierzka nie istnieje!",
        7 => "Brak praw do zapisu!"
    );

    /**
     * Rozszerzenie wgranego pliku
     * @var string
     */
    public $fileExt     = null;

    /**
     * Nazwa pliku, domyślnie oryginalna nazwa w bezpiecznym formacie
     * ( bez polskich liter, znaków specjalnych )
     * @var string
     */
    public $fileName    = null;

    /**
     * Prefix dla nazwy pliku
     * domyślnie brak
     * @var string
     */
    public $filePrefix  = null;

    /**
     * Wielkość wgranego pliku
     * @var int
     */
    private $_fileSize  = 0;

    /**
     * Typ MIME pliku
     * @var string
     */
    private $_fileType  = null;

    /**
     * Limit wagi wgranego pliku w MiB
     * @var int
     */
    public $sizeLimit   = 2; // MiB

    /**
     * Tymczasowa ścierzka do pliku
     * @var string
     */
    private $_tmpName   = null;

    /**
     * Konstruktor, przyjmuje parametr $_FILES['nazwa_pliku'];
     * @param array $file
     */
    public function __construct($file) {
        $fileNameArray = explode('.', $file['name']);

        $this->_fileType = $file['type'];
        $this->_fileSize = $file['size'];
        $this->_tmpName = $file['tmp_name'];

        $this->fileExt = array_pop($fileNameArray);
        $this->fileName = implode('-', $fileNameArray);

        if ($this->fileName == '')
            $this->fileName = time();

        $this->_errorCode = $file['error'];
    }

    /**
     * Metoda do usuwania polskich znaków oraz znaków specjalnych.
     * @param string $string
     * @return string
     */
    private function _convertToSaveFormat($string) {
        $string     = stripslashes($string);
        $unSafe     = array('.',' ',"'",'"','/','Ą','ą','Ć','ć','Ę','ę','Ł','ł','Ń','ń','Ó','ó','Ś','ś','Ź','ź','Ż','ż');
        $safe       = array('-','-','','','','A','a','C','c','E','e','L','l','N','n','O','o','S','s','Z','z','Z','z');

        $safeString = str_replace($unSafe, $safe, $string);

        return $safeString;
    }

    /**
     * Metoda sprawdzająca czy wgrany plik jest dozwolony
     * @return boolean (true|false)
     */
    private function _isAllowedFileType() {
        if (empty($this->allowedType))
            return true;

        $allowed = (in_array($this->_fileType, $this->allowedType)) ? true : false;
        if ($allowed === false)
            $this->_errorCode = 5;

        return $allowed;
    }

    /**
     * Metoda sprawdzająca czy docelowy katalog jest zapisywalny
     * @return boolean (true|false)
     */
    private function _isDestDirIsWritable() {
        $isWritable = (is_writable($this->destDir)) ? true : false;

        if ($isWritable === false)
            $this->_errorCode = 7;

        return $isWritable;
    }

    /**
     * Metoda sprawdzająca czy docelowy katalog istnieje
     * @return boolean (true|false)
     */
    private function _isDestDirExists() {
        $dirExists = (is_dir($this->destDir)) ? true : false;

        if ($dirExists === false)
            $this->_errorCode = 6;

        return $dirExists;
    }

    /**
     * Metoda sprawdzająca czy docelowy plik nie przekracza dopuszczalnej wielkości.
     * @return boolean (true|false)
     */
    private function _isAllowedFileSize() {
        $sizeMiB = ceil($this->_convertBytes($this->_fileSize));

        $allowed = ($sizeMiB <= $this->sizeLimit) ? true : false;
        if ($allowed === false)
            $this->_errorCode = 2;

        return $allowed;
    }

    /**
     * Metoda konwertująca bajty na KiB, MiB, GiB
     * @param int $bytes
     * @param string $to
     * @param int $precision
     * @return float
     */
    private function _convertBytes($bytes, $to = 'M', $precision = 2) {
        $float      = (float) floatval($bytes);
        $notation   = (int) 1024;
        $precision  = (int) ($precision > 0) ? $precision : 2;

        switch($to) {
            case 'G':            // GiB
                $float /= $notation;
            case 'M':            // MiB
                $float /= $notation;
            case 'K':            // KiB
                $float /= $notation;
        }
        unset($bytes, $to);
        return round($float, $precision);
    }

    /**
     * Metoda zwraca typ MIME pliku
     * @return string
     */
    public function getFileType() {
        return ($this->_fileType) ? $this->_fileType : false;
    }

    /**
     * Metoda zwraca wielkość wgranego pliku
     * - jeżeli istnieje parametr $format, zwraca wielkość w danym formacie,
     * - jeżeli istnieje dodatkowo parametr $precision zwraca wielkość z podaną precyzją
     * @param string $format
     * @param int $precision
     * @return float
     */
    public function getFileSize($format = null, $precision = null) {
        return $this->_convertBytes($this->_fileSize, $format, $precision);
    }

    /**
     * Metoda zwraca komunikat błędu.
     * @return string|boolean
     */
    public function error() {
        return ($this->_errorCode != 0) ? $this->_errorsList[$this->_errorCode] : false;
    }

    /**
     * Metoda główna, zapisuj plik na serwer.
     * @return string|boolean
     */
    public function save() {
        if ($this->_tmpName
                && $this->_isDestDirExists()
                && $this->_isDestDirIsWritable()
                && $this->_isAllowedFileType()
                && $this->_isAllowedFileSize())
            if (is_uploaded_file($this->_tmpName)) {
                $fileName               = $this->_convertToSaveFormat($this->fileName);
                $fileNameWithExtension  = ($this->filePrefix != '' && $this->filePrefix != $fileName) ? "{$this->filePrefix}_{$fileName}.{$this->fileExt}" : "$fileName.$this->fileExt";
                $stat = move_uploaded_file(
                    $this->_tmpName, // tymczasowa sciezka pliku
                    $this->destDir . $fileNameWithExtension // nowa sciezka pliku
                );
                return $this->destDir . $fileNameWithExtension;
            }
        return false;
    }
}

Kod HTML:

<form action="upload-file.php" enctype="multipart/form-data" method="post">
<table class="uploadForm">
<thead>
<tr>
<th colspan="3">Formularz uploadu pliku</th>
</tr>
</thead>
<tbody>
<tr>
<td class="catLeft">Wybierz plik:</td>
<td><input name="plik" size="32" type="file" /></td>
<td class="comments">// Wybierz plik do uploadu</td>
</tr>
<tr>
<td class="catLeft">Katalog docelowy:</td>
<td><input name="dest_dir" type="text" value="uploaded/" /></td>
<td class="comments">// Wybierz katalog docelowy lub pozostaw domyślny</td>
</tr>
<tr>
<td class="catLeft">Prefix:</td>
<td><input name="file_prefix" type="text" /></td>
<td class="comments">// Wpisz prefix dla pliku, domyślnie brak prefixu</td>
</tr>
<tr>
<td class="catLeft">Nazwa pliku:</td>
<td><input name="file_name" type="text" /></td>
<td class="comments">// Wpisz nazwę dla pliku, domyślnie nazwa oryginalna (zabezpieczona)</td>
</tr>
<tr>
<td></td>
<td><input name="Submit" type="submit" value="Wyślij" /></td>
<td class="comments"></td>
</tr>
</tbody>
</table>
</form>

Kod PHP:

    require_once 'class/SimpleUpload.class.php';

    if (isset($_FILES)) {
        $upload = new SimpleUpload($_FILES['plik']); // Tworzymy nowy obiekt

//        $upload->sizeLimit = 10; // Maksymalny rozmiar pliku w MB
//        $upload->allowedType = array('image/jpeg'); // Możemy wgrać tylko zdjęcia typu jpg

        // Katalog
        if ($_POST['dest_dir'] != '')
            $upload->destDir        = $_POST['dest_dir'];

        // Prefix
        if ($_POST['file_prefix'] != '')
            $upload->filePrefix     = $_POST['file_prefix'];
        else
            $upload->filePrefix     = time();

        // Nazwa pliku
        if ($_POST['file_name'] != '')
            $upload->fileName       = $_POST['file_name'];

        $fileSizeB  = $upload->getFileSize(); // bajt B
        $fileSizeK  = $upload->getFileSize('K'); // kibibajt - KiB
        $fileSizeM  = $upload->getFileSize('M'); // mebibajt - MiB
        $fileType   = $upload->getFileType();

        $stat = $upload->save();
        if ($stat === false)
            echo "Błąd: ".$upload->error();
        else
            echo "Poprawnie dodano plik: " . $stat;
    }

Kod będzie stopniowo rozwijany, pomysły i uwagi mile widziane. Śmiało proszę pisać