1. <?php
2. class ma_classe
3. {
4. //Déclaration des variables
5. public $variable1;
6. private $variable2;
7. protected $variable3;
9. /*j'ai bien capté ce qu'était public private et protected*/
11. public function __construct()
12. {
13. $this->variable1='localhost';
14. $this->variable2='autre_valeur';
15. $this->variable3=array();
16. }
18. /* $this -> ca j'ai pas capté... c'est comme une structure de données ? */
20. private function autre_fonction()
21. {
22. return 'ok';
23. }
25. }
26. ?>

1. <?php
2.         class Personne
4.         {
6.                public $nom;
7.                public $metier;
8.                private $distance;
9.                private $direction;
11.                function __tostring()
12.                         {
13.                          return "Cette classe permet de définir et manipuler une personne.<br/>";
14.                         }
16.               function __construct($nom, $metier, $distance=0, $direction=0)
17.                         {
18.                             $this->nom = $nom;
19.                             $this->metier = $metier;
20.                             $this->distance = $distance;
21.                             $this->direction = $direction;
22.                         }
24.                function arreter()
25.                         {
26.                             echo "$this->nom a arrêté toute activité en cours.<br/>";
27.                         }
29.                function marcher($pas)
30.                         {
31.                              $this->distance += $pas;
32.                              echo "$this->nom avance de $pas pas.<br/>";
33.                         }
35.                function tourne($degres)
36.                         {
37.                              $this->direction += $degres;
38.                              echo "$this->nom a tourné de $degres degré(s).<br/>";
39.                         }
41.                function etat()
42.                         {
43.                         echo "Le $this->metier $this->nom a avancé de $this->distance pas depuis le début, il fait maintenant face au degré     $this->direction.<br/>";
44.                         }
46.         }
49. $xavier = new Personne('Xavier', 'rédacteur', 0, 27);
50. $xavier->etat();
51. $xavier->marcher(50);
52. $xavier->tourne(-90);
53. $xavier->arreter(2);
54. $xavier->etat();
56. ?>

1. <?php
2. include("testclass1.php" );
3. $myFile=isset($_FILES['myFile'])?$_FILES['myFile']:null;
5.     if ($myFile!=null) {
6.     //    instanciation de la classe
7.     $myUpload=new myUpload();
8.     //    appel des méthodes publiques pour le paramétrage de l'upload
9.     //    types de fichiers acceptées
10.     $myUpload->addFileType("application/x-zip-compressed" );
11.     $myUpload->addFileType("application/vnd.ms-excel" );
12.     //    je déclare le fichier à envoyer
13.     $myUpload->setFile($myFile);
14.     //    taille maximale du fichier en octets
15.     //    je la place à 1mo
16.     $myUpload->setMaxSize(1000000);
17.     //    dossier de destination du fichier
18.     $myUpload->setMyDir("fichiers/" );
19.     //    je crée le nom du fichier
20.     $myUpload->setMyName("fichier_envoye" );
21.     //    j'exécute l'upload
22.     $myUpload->myUpload();
23.     }
25. ?>
27. <form method="post" enctype="multipart/form-data" >
28.    Mon fichier : <input type="file" name="myFile" id="myFile" /> <br />
29.    <input type="submit" value="envoyer" />
30. </form>

1. <?
3. class myUpload {
4. // pour la coloration syntaxique d'asp-php
5.     /*~*~*~*~*~*~*~*~*~*~*/
6.     /*  1. propriétés    */
7.     /*~*~*~*~*~*~*~*~*~*~*/
8.     /**
9.     * @var (String)
10.     * @desc Fichier envoyé par formulaire
11.     */
12.     private $myFile;
13.     /**
14.     * @var (String)
15.     * @desc Dossier dans lequel seront stockés les fichiers envoyés
16.     */
17.     private $myDir;
18.     /**
19.     * @var (Integer)
20.     * @desc Taille maximale acceptée pour un fichier envoyé
21.     */
22.     private $myMaxSize;
23.     /**
24.     * @var (Array)
25.     * @desc Types de fichiers envoyés acceptés
26.     */
27.     private $myTypes;
28.     /**
29.     * @var (string)
30.     * @desc Nom du fichier après copie
31.     */
32.     private $myName;
33. /*~*~*~*~*~*~*~*~*~*~*/
34. /*  2. méthodes      */
35. /*~*~*~*~*~*~*~*~*~*~*/
37.     public function __construct() {
38.     //    $this->myTypes est un tableau à deux dimensions.
39.     //    on le déclare ainsi
40.     $this->myTypes=array();
41.     //    on place la valeur de myName à null
42.     $this->myName=null;
43.     } 
44.     // pour la coloration syntaxique d'asp-php
45.     /*~*~*~*~*~*~*~*~*~*~*~*~*~*/
46.     /*  2.1 méthodes privées   */
47.     /*~*~*~*~*~*~*~*~*~*~*~*~*~*/
48.     /**
49.     * Vérifie l'existence d'un dossier
50.     *  
51.     * <p>Teste l'existence d'un dossier,
52.     * renvoie une erreur si le dossier est introuvable</p>
53.     *  
54.     * @name myUpload::testDir()
55.     * @param $dir
56.     * @return string
57.     */
58.     private function testDir($dir) {
59.         //    la fonction is_dir teste l'existence d'un dossier
60.         if (is_dir($dir)) {
61.         //    si le dossier existe, j'applique la valeur $dir
62.         //    à la propriété $this->dir
63.         //    lorsque nous lanceront la copie de fichier,  
64.         //    nous rappelleront la propriété $this->dir
65.         $myDir=$dir;
66.         }
67.         else {
68.         //    si il y a une erreur lors du paramétrage,  
69.         //    je renvoie une valeur nulle
70.         $myDir=null;
71.         }
72.     //    $myDir est la valeur retournée (string)
73.     return $myDir;
74.     }
75.     /*
76.     * Renvoie la taille du fichier
77.     *  
78.     * <p>Renvoie la taille du fichier en octets</p>
79.     *  
80.     * @name myUpload::fileSizer()
81.     * @param $file
82.     * @return int
83.     */
84.     private function fileSizer($file) {
85.     return $file['size'];
86.        }
87.     /*
88.     * Renvoie la taille du fichier
89.     *  
90.     * <p>Renvoie la taille du fichier en octets</p>
91.     *  
92.     * @name myUpload::fileType()
93.     * @param $file
94.     * @return string
95.     */
96.       private function fileType($file) {
97.       return $file['type'];
99.    }
100.     /*
101.     * Exécute la copie du fichier
102.     *  
103.     * <p>Copie le fichier dans le dossier spécifié</p>
104.     *  
105.     * @name myUpload::fileSizer()
106.     * @param $dir
107.     * @return voix
108.     */
109.     private function myCopy($file, $dir, $nom) {
110.     //    aucune vérification à faire, puisque nos contrôles
111.     //    ont été effectués en amont
112.     if(!copy($file['tmp_name'], $dir."/".$nom));
113.     {
114.     echo "copie de fichier impossible. Je sais pas pourquoi :-/";
115.     }
116.     }
117.     /*~*~*~*~*~*~*~*~*~*~*~*~*~*/
118.     /*  2.1 méthodes publiques */
119.     /*~*~*~*~*~*~*~*~*~*~*~*~*~*/
120.     /*
121.     * Déclare le fichier posté
122.     *  
123.     * <p>Déclaration du fichier posté. </p>
124.     *  
125.     * @name myUpload::setFile()
126.     * @param $file
127.     * @return string
128.     */
129.     public function setFile($file) {
130.         //    on teste que le fichier envoyé est bien nommé
131.         //    s'il n'est pas nommé, cela signifie qu'il y a
132.         //    soit une erreur dans le formulaire,  
133.         //    soit une erreur dans l'instanciation
134.         if ($file['tmp_name']!="" ) {
135.         $myFile=$file;
136.         }
137.         else {
138.         //    si le fichier est en erreur, on renvoie un null
139.         $myFile=null;
140.         }
141.     $this->myFile=$myFile;
142.     }
143.     /**
144.     * Déclare le nom du fichier à copier
145.     *  
146.     * <p>Le nom du fichier après copie. </p>
147.     *  
148.     * @name myUpload::setName()
149.     * @param $name
150.     * @return string
151.     */
152.     public function setMyName($name) {
153.     $this->myName=$name;
154.     }
155.     /**
156.     * Déclare un nouveau type de fichier accepté
157.     *  
158.     * <p>Liste les types de fichiers acceptés.</p>
159.     *  
160.     * @name myUpload::addFileType()
161.     * @param $typeFile
162.     * @return void
163.     */
164.     public function addFileType($typeFile) {
165.     //    on déclare un petit compteur
166.     //    qui servira à compter le nombre
167.     //    de type de fichiers acceptés
168.     $i=0;
169.         //    J'ai besoin de connaître le nombre de fichiers
170.         //    acceptés lors de l'instanciation. Pour ça, je
171.         //    boucle sur la propriété myTypes (array)
172.         //    et j'incrémente le compteur
173.         foreach($this->myTypes as $key) {
174.         $i++;
175.         }
176.     //    on ajoute comme valeur $typeFile à la propriété $this->myTypes
177.     //    Comme la propriété myTypes est un tableau (array), on incrémente
178.     //    $i de 1 pour ne pas écraser la valeur précédente
179.     $this->myTypes[$i]=$typeFile;
180.     //    j'ai appliqué la valeur directement à ma propriété.  
181.     //    je ne retourne donc directement rien
182.     }
183.     /**
184.     * Taille maximale de fichier accepté
185.     *  
186.     * <p>Déclare la taille maximale en Octets acceptée par
187.     * le programme. Si le fichier envoyé est trop grand, on  
188.     * renvoie une valeur nulle.</p>
189.     *  
190.     * @name myUpload::setMaxSize()
191.     * @param $typeFile
192.     * @return void
193.     */
194.     public function setMaxSize($max) {
195.         //    je vérifie que la valeur de $max est bien
196.         //    un nombre entier
197.         if (is_integer($max)) {
198.         $myMax=$max;
199.         }
200.         else {
201.         //    si une erreur est détectée, on renvoie une valeur null
202.         $myMax=null;
203.         }
204.     $this->myMaxSize=$myMax;
205.     }
206.     /**
207.     * Déclaration du dossier cible
208.     *  
209.     * <p>Déclare la taille maximale en Octets acceptée par
210.     * le programme. Si le fichier envoyé est trop grand, on  
211.     * renvoie une valeur nulle.</p>
212.     *  
213.     * @name myUpload::setMyDir()
214.     * @param $dir
215.     * @return void
216.     */
217.     public function setMyDir($dir) {
218.     //    j'appelle la méthode de test du dossier
219.     //    que j'ai crée plus tôt.  
220.     //    le nom de la variable n'a aucune  
221.     //    importance.  
222.     //    seul compte le nom de la propriété ($this->myDir)
223.     $myDir=$this->testDir($dir);
224.     $this->myDir=$myDir;
225.     if ($this->myDir==null)
226.     {echo "repertoire vide";}
227.     }
228.     public function myUpload() {
229.     //    on teste les propriétés une par une
230.     //    $this->myFile
231.     if ($this->myFile!=null) {
232.     echo "fichier detecté : OK \n  ";
233.         //    $this->myMaxSize
234.         if ($this->myMaxSize!=null) {
235.             //    $this->myDir
236.             if ($this->myDir!=null) {
237.                 //    $this->myName
238.                 echo "Repertoire detecté $this->myDir \n  ";
239.                 if ($this->myName!=null) {
240.                     //    $this->myTypes
241.                     echo "nom de fichier : $this->myName \n  ";
242.                     if ($this->myTypes[0]!=null) {
243.                     //    je récupère maintenant la taille du fichier
244.                     $mySize=$this->fileSizer($this->myFile);
245.                         //    je la compare à la taille maximale acceptée
246.                         if ($mySize<=$this->myMaxSize) {
247.                         //    je récupère le type de fichier
248.                         $fileType=$this->fileType($this->myFile);
249.                             //    et je le compare à la liste des types acceptés
250.                             foreach ($this->myTypes as $key) {
251.                             //    puis exécution de l'upload
252.                             if ($key==$fileType) {
253.                             $this->myCopy($this->myFile, $this->myDir, $this->myName);
254.                             }
255.                             }
256.                         }
257.                         else {
258.                         echo ("Le fichier est trop gros" );
259.                         }
260.                     }
261.                     else {
262.                     echo ("Vous devez specifier les types de fichiers acceptes." );
263.                     }
264.                 }
265.                 else {
266.                 echo ("Vous devez specifier un nom pour le fichier." );
267.                 }
268.             }
269.             else {
270.             echo ("Le dossier de destination n'est pas bon. Veuillez corriger." );
271.             }
272.         }
273.         else {
274.         echo ("La taille maximale n'a pas ete specifiee, veuillez corriger." );
275.         }
276.     }
277.     else {
278.     echo ("Le fichier n'a pas ete reçu." );
279.     }
280.     }
281.     /**
282.     * Destructeur
283.     *  
284.     * <p>Destruction de l'instance de classe</p>
285.     *  
286.     * @name myUpload::__destruct()
287.     * @return void
288.     */
289.     public function __destruct(){
290.     }
291. }
292. ?>

class Upload {
    public $destination_dir;
    public $destination_name;
    private $temp_name;
    private $type;
 
    /**
        Fournir un fichier $_FILES au constructeur
    */
    public function __construct($file);
    public function execute();
}

<?php
    class Upload {
        public $temp_name;
        public $destination_name;
        public $max_size;
        public $type;
        public $destination_folder=null;
 
        public function __construct($file) {
            $this->destination_name = $file['name'];
            $this->max_size = $file['size'];
            $this->type = $file['type'];
            $this->temp_name = $file['tmp_name'];
        }
 
        public function execute() {
            if($this->destination_folder === null)
                throw new Exception('No destination folder set');
            if(!move_uploaded_file($this->temp_name, $this->destination_folder."/".$this->destination_name))
                throw new Exception("Failed upload: server error" );
        }
    }
?>

<?php
    include('modules/upload.php');
    if(isset($_FILES) && isset($_FILES['userfile'])) {
        $upload = new Upload($_FILES['userfile']);
        $upload->destination_folder="/wamp/www/files";
        $upload->destination_name="uploaded_file";
        $upload->execute();
    }
 
?><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <title>Test upload</title>
    <head>
    <body>
        <form enctype="multipart/form-data" action="" method="post">
            <fieldset>
                <legend>Upload your file</legend>
                <input name="userfile" type="file" /> <input type="submit" value="Envoyer">
            </fieldset>
        </form>
        <?php
            if(isset($upload)) echo "<p>Upload success to ".$upload->destination_folder."/".$upload->destination_name."</p>"
        ?>
    </body>
</html>