Share
Dans ce tutoriel Tuts + Premium, nous allons apprendre à travailler avec des opérations de fichiers en utilisant PHP. C’est l’un des sujets les plus fondamentaux de la programmation côté serveur en général. Les fichiers sont utilisés dans les applications Web de toutes tailles. Apprenons donc à lire, écrire, créer, déplacer, copier, supprimer des fichiers et plus encore.
Nous allons commencer par apprendre avec ces opérations car elles sont très simples et ne nécessitent pas de pointeur de fichier..
$ file = "test.txt"; $ new_file = "test_copy.txt"; copie ($ file, $ newfile);
$ file = "test.txt"; $ new_file = "test_copy.txt"; renommer ($ file, $ newfile);
Notez que la fonction est appelée "renommer" et non "déplacer". Renommer un fichier en interne revient à le déplacer vers un nouvel emplacement..
Le même code fonctionne lors de la modification du répertoire du fichier:
$ file = "test.txt"; $ new_file = "différent / dossier / test_copy.txt"; renommer ($ file, $ newfile);
Il n’existe pas de fonction telle que "supprimer". Ici, nous appelons la fonction "unlink".
$ file = "test.txt"; unlink ($ file, $ newfile);
Il est maintenant temps de commencer à traiter certains pointeurs de fichiers. Il existe plus d’une façon de lire le contenu d’un fichier en PHP, mais nous allons commencer par la méthode la plus élémentaire. Plus tard dans cet article, nous étudierons les méthodes alternatives.
Nous allons utiliser ici trois fonctions de fichier: fopen, fread et fclose.
$ file = "test.txt"; // ouvre le fichier $ fp = fopen ($ file, "r"); // lit 5k données du fichier $ contents = fread ($ fp, 5000); // ferme le fichier fclose ($ fp);
Lors de l'ouverture du fichier, nous incluons un deuxième paramètre, qui détermine le type d'accès. Dans ce cas, "r" signifie "lecture seule". Il y a d'autres types que nous devons utiliser pour l'écriture et l'ajout que nous couvrirons plus loin dans l'article.
La deuxième chose importante à prendre en compte est le deuxième paramètre de la fonction fread. Cela détermine la longueur des données (en octets) à lire dans le fichier. Pour lire tout le contenu du fichier, nous devons passer la taille totale du fichier. La fonction de taille de fichier fait le tour:
$ file = "test.txt"; // ouvre le fichier $ fp = fopen ($ file, "r"); // lit 5k données du fichier $ contents = fread ($ fp, taille du fichier ($ fichier)); // ferme le fichier fclose ($ fp);
Depuis que nous travaillons avec des pointeurs de fichiers, prenons un moment pour essayer de mieux les comprendre..
Un pointeur de fichier, également appelé fichier "handle", est une variable qui fait référence à un fichier. La valeur exacte de cette variable n'a pas d'importance. tout ce que nous avons besoin de savoir, c'est qu'il pointe vers un fichier spécifique. Le pointeur est généralement obtenu en ouvrant un fichier. En PHP, nous utilisons la fonction fopen.
Même si PHP possède un excellent ramasse-miettes qui ferme tous les pointeurs de fichiers ouverts à la fin de l'exécution d'un script, il est conseillé de les fermer manuellement à l'aide de la fonction fclose..
$ fp = fopen ($ file, 'r'); //… // ferme toujours les fichiers fclose ($ fp);
Le pointeur de fichier fait plus que simplement pointer sur un fichier. Il pointe également vers une position spécifique dans ce fichier. Dans la plupart des cas, lorsque vous ouvrez un fichier, le pointeur de fichier pointe vers le début (ou la position 0) de ce fichier. Nous aborderons ce concept plus en détail lorsque nous parlerons de "recherche" plus tard dans l'article.
Tout comme la lecture de fichiers, il existe plus d’une façon d’écrire dans un fichier. Nous verrons d’abord la méthode de base et, plus loin dans l’article, nous examinerons des alternatives.
Le code suivant écrit le contenu de la variable $ data dans le fichier test.txt.
$ file = "test.txt"; $ data = "0123456789abc"; // ouvre le fichier pour écrire $ fp = fopen ($ file, "w"); // écrit des données dans le fichier fwrite ($ fp, $ data); // ferme le fichier fclose ($ fp);
Cette fois, nous avons utilisé un indicateur différent pour ouvrir le fichier. L'indicateur "w" ouvre le fichier en écriture et remplace toutes les données existantes du fichier. S'il y avait quelque chose dans le fichier test.txt, il sera remplacé par la chaîne dans $ data.
La fonction fwrite était très simple, nous venons de passer le pointeur de fichier et les données à écrire dans le fichier. Il existe un troisième paramètre facultatif qui détermine la longueur des données à écrire:
$ file = "test.txt"; $ data = "0123456789abc"; // ouvre le fichier pour écrire $ fp = fopen ($ file, "w"); // écrit des données dans le fichier (seulement 5 octets) fwrite ($ fp, $ data, 5); // ferme le fichier fclose ($ fp);
Si vous exécutez le code ci-dessus, le contenu de test.txt sera uniquement "01234".
Les exemples ci-dessus fonctionnent également pour créer de nouveaux fichiers. Si le fichier test.txt n'existe pas, il sera créé automatiquement, uniquement par l'appel de la fonction fopen.
Si tout ce que vous voulez faire est de créer un nouveau fichier vide, sans y écrire aucune donnée, ce code fonctionnera:
$ file = "does_not_exist.txt"; // crée et ouvre le fichier $ fp = fopen ($ file, "w"); // ferme le fichier fclose ($ fp);
Le fait de déplacer l’emplacement des pointeurs de fichier s’appelle "recherche". Pour rechercher nous pouvons utiliser la fonction fseek, et pour obtenir la position d’un pointeur donné, nous pouvons utiliser la fonction ftell.
Avant d'utiliser la recherche, créons un fichier contenant 10 octets de données.
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ fichier, "w"); fwrite ($ fp, $ data); fclose ($ fp);
Voyons maintenant comment ces fonctions se comportent. Voici quelques exemples différents:
$ file = "test.txt"; // ouvrant pour la lecture, le pointeur devrait être à 0 $ fp = fopen ($ file, "r"); echo "open:"; // génère 0 echo ftell ($ fp). "\ n"; // ----- // cherche à octroyer 4 fseek ($ fp, 4); echo "cherche 4:"; // génère 4 echo ftell ($ fp). "\ n"; // ----- // vous pouvez sortir des limites fseek ($ fp, 9000); echo "hors limites:"; // génère 9000 fichiers d'écho ($ fp). "\ n"; // ---- // c'est ainsi que vous arrivez à la fin fseek ($ fp, 0, SEEK_END); echo "end:"; // génère 10 echo ftell ($ fp). "\ n"; // ---- // déplacer par rapport à la position actuelle // nombres négatifs travail fseek ($ fp, -3, SEEK_CUR); echo "retourne par 3:"; // génère 7 echo ftell ($ fp). "\ n"; // ---- // ou recherche relative à la fin // encore une fois, œuvres négatives fseek ($ fp, -3, SEEK_END); echo "retourne par 3 de la fin:"; // génère 7 echo ftell ($ fp). "\ n"; // ---- // fait la même chose que chercher 0 rembobiner ($ fp); echo "rewind:"; // génère 0 echo ftell ($ fp). "\ n"; fclose ($ fp);
La position du pointeur de fichier peut se déplacer par des opérations autres que fseek.
Par exemple, la lecture déplace la position:
$ file = "test.txt"; $ fp = fopen ($ file, "r"); // lecture de 6 octets $ data = fread ($ fp, 6); // génère 6 echo ftell ($ fp); fclose ($ fp);
L'écriture le déplace aussi:
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ fichier, "w"); // écriture de 10 octets fwrite ($ fp, $ data); // génère 10 echo ftell ($ fp); fclose ($ fp);
Maintenant que nous maîtrisons les concepts de lecture, d’écriture et de recherche, il est temps de mieux comprendre les différents modes d’accès aux fichiers. Lors de l'ouverture d'un fichier avec la fonction fopen, le deuxième paramètre doit être fourni, à savoir le mode d'accès au fichier. Il y a un tableau dans le manuel PHP qui les décrit:
En les regardant, vous pouvez constater que nous avons plus d'options que nous en avions parlé jusqu'à présent. Voici quelques facteurs importants à prendre en compte pour choisir la bonne option:
Il existe de nombreuses informations que nous pouvons obtenir sur un fichier en plus de son contenu (taille, heure du dernier accès, heure de modification, etc.). La fonction principale utilisée à cet effet est stat.
Il retourne les informations dans un tableau:
Accentsconagua
$ data = stat ("test.txt"); print_r ($ data); / * affiche: Array ([0] => 2 [1] => 0 [2] => 33206 [3] => 1 [4] => 0 [5] => 0 [6] => 2 [7 ] => 10 [8] => 1264374556 [9] => 1264374556 [10] => 1264373231 [11] => -1 [12] => -1 [dev] => 2 [ino] => 0 [mode ] => 33206 [nlink] => 1 [uid] => 0 [gid] => 0 [rdev] => 2 [taille] => 10 [atime] => 1264374556 [mtime] => 1264374556 [ctime] = > 1264373231 [taille de bloc] => -1 [blocs] => -1) * / Les données sont en 12 morceaux et sont répétées, d'abord avec des clés numériques, puis à nouveau avec des clés de chaîne.
Le manuel PHP contient un tableau expliquant chacun d’entre eux:
Comme je l'ai mentionné plus tôt, d'autres fonctions peuvent être utilisées pour lire et écrire des fichiers. Passons en revue certains d'entre eux.
Cette fonction renvoie tout le contenu d'un fichier donné. De plus, vous n’avez pas besoin de gérer les pointeurs de fichiers..
$ file = "test.txt"; $ contents = fichier_get_contents ($ fichier);
La fonction accepte quatre paramètres supplémentaires, comme décrit dans le manuel PHP. Par exemple, pour ne lire qu'une partie du fichier, vous pouvez définir les quatrième et cinquième paramètres:
$ file = "test.txt"; // lit 5 octets de données, en commençant par l'octet 3 $ contents = file_get_contents ($ file, NULL, NULL, 3, 5);
Oui, cette fonction est simplement nommée fichier et renvoie à nouveau tout le contenu d’un fichier. Mais cette fois, le contenu est divisé en un tableau, par le caractère de nouvelle ligne.
Créons un fichier avec le contenu suivant:
abc 123 ligne vide après cette dernière ligne
Maintenant, utilisez la fonction:
$ file = "test.txt"; $ contents = fichier ($ fichier); print_r ($ contents); / * affiche Array ([0] => abc [1] => 123 [2] => ligne vide après cette [3] => [4] => dernière ligne) * /
Cela peut ne pas être évident, mais il y a un caractère de nouvelle ligne à la place de chaque élément du tableau. Si vous ne les voulez pas, vous pouvez les couper manuellement ou utiliser l'indicateur FILE_IGNORE_NEW_LINES:
$ file = "test.txt"; $ contents = file ($ file, FILE_IGNORE_NEW_LINES); print_r ($ contents); / * affiche Array ([0] => abc [1] => 123 [2] => ligne vide après cette [3] => [4] => dernière ligne) * /
Si vous ne voulez pas non plus les lignes vides, vous pouvez utiliser l'indicateur FILE_SKIP_EMPTY_LINES:
$ file = "test.txt"; $ contents = fichier ($ fichier, FILE_SKIP_EMPTY_LINES | FILE_IGNORE_NEW_LINES); print_r ($ contents); / * affiche Array ([0] => abc [1] => 123 [2] => ligne vide après cette [3] => dernière ligne) * /
Encore une fois, il n’est pas nécessaire d’utiliser des pointeurs de fichier. Cette fonction écrit simplement les données données dans le fichier donné:
$ file = "test.txt"; $ data = "0123456789"; fichier_put_contents ($ file, $ data);
Ce sont des alternatives à la fonction stat pour obtenir des informations sur les fichiers.
$ file = "test.txt"; // récupère la taille du fichier echo filesize ($ file); // récupère la dernière modification du fichier echo filemtime ($ file); // récupère le dernier accès au fichier echo fileatime ($ file);
Les systèmes de type Unix ont une norme de permissions de fichiers assez détaillée. Les systèmes Windows ont un peu plus simple. Tout le sujet des autorisations de fichiers peut être long et un article séparé peut être écrit dessus. Au lieu de cela, nous examinerons seulement deux concepts simples d'autorisations de fichier: être "lisible" et "écrire"..
Votre script peut avoir ou non un accès en lecture et / ou en écriture à un fichier pour diverses raisons. Avant de tenter d'ouvrir un fichier en lecture ou en écriture, il est sage de vérifier si vous en avez l'autorisation:
$ file = "test.txt"; if (is_readable ($ file)) // le fichier est lisible if (is_writable ($ file)) // le fichier est en écriture
Pour définir les autorisations d'un fichier, nous utilisons la fonction chmod:
$ file = "test.txt"; // rend le fichier en lecture seule chmod ($ file, 0444); // rend le fichier lisible et accessible en écriture chmod ($ file, 0666);
Le code ci-dessus devrait fonctionner sur les systèmes Unix et Windows. Cependant, vous ne pourrez peut-être pas définir les autorisations si vous ne possédez pas le fichier ou si vous en possédez déjà une..
Pour mieux comprendre les autorisations de chmod et des fichiers en général, vous pouvez consulter ces liens:
La dernière chose dont nous allons parler est un conseil rapide pour gérer de gros fichiers. Cela a des conséquences sur les performances.
Le moyen le plus simple de lire et d’extraire un fichier est le suivant:
$ file = "test.txt"; echo file_get_contents ($ file);
Mais cela provoque le chargement de tout le contenu du fichier dans la mémoire. Il persistera tant qu'il sera téléchargé par l'internaute. Si plusieurs personnes téléchargent des fichiers simultanément, la mémoire de votre serveur Web peut être consommée très rapidement..
Une meilleure idée pour gérer cela serait d'utiliser une boucle pour lire uniquement de petits morceaux du fichier à la fois. Pour la condition de boucle, nous utiliserons la fonction feof:
$ file = "test.txt"; $ fp = fopen ($ file, 'r'); tandis que (! feof ($ fp)) echo fread ($ fp, 4092); fclose ($ fp);
Le code ci-dessus ne chargera que 4 Ko de données en une fois dans la mémoire, ce qui réduira considérablement l'utilisation de la mémoire pour les sorties de fichiers volumineux. La fonction feof retourne vrai quand nous arrivons à la fin du fichier et cela sort de la boucle.
