Comparaison de la collection de méthodes d'opération de texte PHP

Le contenu de cet article est une comparaison d'une collection de méthodes d'opération de texte PHP. Maintenant, je le partage avec tout le monde et je peux également donner une référence aux amis dans le besoin

fgets et fputs, fread et fwrite, fscanf et fprintf

Fonctions de lecture et d'écriture de chaînes fgets et fputs

1. Fonction de lecture de chaîne La fonction de la fonction fgets est de lire une chaîne du fichier spécifié dans un tableau de caractères. L'appel de fonction est sous la forme : fgets. ( Nom du tableau de caractères, n, pointeur de fichier) ; où n est un entier positif. Indique que la chaîne lue dans le fichier ne dépasse pas n-1 caractères. Ajouter la marque de fin de chaîne ' après le dernier caractère luCet exemple de programme définit une structure stu, indiquant deux tableaux de structures boya et boyb et deux variables de pointeur de structure pp et qq. pp montre boya, qq montre boyb. La ligne 16 du programme ouvre le fichier binaire "stu_list" en mode lecture-écriture. Après avoir saisi deux données d'étudiant, il est écrit dans le fichier. Ensuite, le pointeur de position interne du fichier est déplacé au début du fichier. sur les deux blocs *, il s'affiche à l'écran.

Fonctions de lecture et d'écriture formatées fscanf et fprintf

Fonction fscanf, la fonction fprintf a des fonctions similaires aux fonctions scanf et printf précédemment utilisées, les deux sont des fonctions de lecture et d'écriture formatées . La différence entre les deux est que les objets de lecture et d'écriture de la fonction fscanf et de la fonction fprintf ne sont pas le clavier et le moniteur, mais des fichiers disque. Le format d'appel de ces deux fonctions est : fscanf (pointeur de fichier, chaîne de format, colonne de table d'entrée) ; fprintf (pointeur de fichier, chaîne de format, colonne de table de sortie) ; d%s",&i,s);
fprintf(fp,"%d%c",j,ch);

Le problème de l'exemple 10.6 peut également être résolu en utilisant les fonctions fscanf et fprintf . Le programme modifié est présenté dans l'exemple 10.7.

[Exemple 10.7]

#include
struct stu
{
char name[10]
int num
int âge;
char addr[15];
}boya[2],boyb[2],*pp,*qq;
main()
{
FILE *fp
char ch;
int i;
pp=boya;
qq=boyb;((fp=fopen("stu_list","wb+"))==NULL)
{
printf("Impossible d'ouvrir le fichier en appuyant sur une touche de sortie !");
getch();
exit(1)
printf("ninput datan"); 🎜>for(i=0;i<2;i++,pp++)
scanf("%s%d%d%s",pp->name,&pp->num,&pp->age, pp->addr);
pp=boya;
for(i=0;i<2;i++,pp++)
fprintf(fp,"%s %d %d %sn",pp ->nom,pp->num,pp->age,pp->
addr);
rewind(fp); qq++)
fscanf(fp,"%s %d %d %sn",qq->name,&qq->num,&qq->age,qq->addr
printf( "nnnametnumber age addrn");
qq=boyb;
for(i=0;i<2;i++,qq++)
printf("%st%5d %7d %sn",qq-> ;name,qq->num, qq->age,
qq->addr);
fclose(fp);
}

Par rapport à l'exemple 10.6, ce Les fonctions fscanf et fprintf du programme ne peuvent lire et écrire qu'un seul élément du tableau de structure à la fois, donc une instruction de boucle est utilisée pour lire et écrire tous les éléments du tableau. Notez également que les variables de pointeur pp et qq ont changé leurs valeurs en raison de la boucle, elles se voient donc réattribuer la première adresse du tableau respectivement aux lignes 25 et 32 ​​du programme.

Lecture et écriture aléatoires de fichiers

Les méthodes de lecture et d'écriture de fichiers présentées précédemment sont la lecture et l'écriture séquentielles, c'est-à-dire que la lecture et l'écriture de fichiers ne peuvent commencer que depuis le début et lire et écrire chaque donnée de manière séquentielle. Mais dans la pratique, il est souvent nécessaire de lire et d'écrire uniquement une partie spécifiée du fichier. Afin de résoudre ce problème, vous pouvez déplacer le pointeur de position à l'intérieur du fichier vers l'emplacement qui doit être lu et écrit, puis lire et écrire. Ce type de lecture et d'écriture est appelé lecture et écriture aléatoires. La clé pour obtenir une lecture et une écriture aléatoires est de déplacer le pointeur de position selon les besoins, ce que l'on appelle le positionnement du fichier. Il existe deux fonctions principales de positionnement de fichier pour déplacer le pointeur de position interne d'un fichier, à savoir la fonction de rembobinage et la fonction fseek.

La fonction rewind a été utilisée à plusieurs reprises auparavant. Sa forme d'appel est : rewind (pointeur de fichier) ; sa fonction est de déplacer le pointeur de position à l'intérieur du fichier jusqu'au début du fichier. Ce qui suit présente principalement la fonction
fseek.

La fonction fseek permet de déplacer le pointeur de position interne du fichier. Sa forme d'appel est : fseek (pointeur de fichier, déplacement, point de départ) où : le "pointeur de fichier" pointe vers le fichier déplacé. "Déplacement" représente le nombre d'octets déplacés, et le déplacement doit être une donnée longue afin qu'aucune erreur ne se produise lorsque la longueur du fichier est supérieure à 64 Ko. Lorsqu'une constante est utilisée pour représenter le déplacement, le suffixe « L » est requis. « Point de départ » indique où commencer le calcul du déplacement. Il existe trois points de départ spécifiés : le début du fichier, la position actuelle et la fin du fichier.

La méthode de représentation est celle indiquée dans le tableau 10.2.
Le point de départ représente les numéros de symboles
─────────────────────────────——
La première recherche -set 0
Position actuelle SEEK—CUR 1
Fin du fichier SEEK—END 2

Par exemple :

fseek(fp,100L,0); Sa signification est d'éloigner le pointeur de position des 100 premiers octets du fichier. A noter également que la fonction fseek est généralement utilisée pour les fichiers binaires. En raison de la nécessité de conversion dans les fichiers texte, des erreurs se produisent souvent dans les positions calculées. Après avoir déplacé le pointeur de position, une lecture et une écriture aléatoires de fichiers peuvent être effectuées à l'aide de l'une des fonctions de lecture et d'écriture présentées précédemment. Puisqu'un bloc de données est généralement lu et écrit, les fonctions fread et fwrite sont couramment utilisées. Les exemples suivants sont utilisés pour illustrer la lecture et l'écriture aléatoires de fichiers.

[Exemple 10.8] Lisez les données du deuxième élève dans la liste stu du dossier étudiant.

#include
struct stu
{
char name[10];
int num
int age; ];
}garçon,*qq;
main()
{
FILE *fp
char ch; 🎜>if((fp=fopen("stu_list","rb"))==NULL)
{
printf("Impossible d'ouvrir le fichier en appuyant sur une touche de sortie !"
getch();
exit(1);
}
rewind(fp);
fseek(fp,i*sizeof(struct stu),0); ,1,fp);
printf("nnnametnumber age addrn");
printf("%st%5d %7d %sn",qq->name,qq->num,qq-> age,
qq->addr);
}

Le fichier stu_list a été créé par le programme de l'exemple 10.6. Ce programme lit les données du deuxième élève en utilisant une lecture aléatoire. Dans le programme, boy est défini comme une variable de type stu et qq est un pointeur vers boy. Le fichier est ouvert pour la lecture des fichiers binaires et la ligne 22 du programme déplace le pointeur d'emplacement du fichier. La valeur i est 1, ce qui signifie qu'en partant de l'en-tête du fichier, en déplaçant la longueur d'un type stu, puis en lisant les données, les données du deuxième élève.

Fonction de détection de fichiers

Les fonctions de détection de fichiers couramment utilisées en langage C sont les suivantes.

1. Fonction de détection de fin de fichier format d'appel de la fonction feof : feof (pointeur de fichier) ;

Fonction : Déterminez si le fichier est à la fin du fichier. la valeur est 1, sinon 0.

2. Fonction de détection d'erreur de fichier de lecture et d'écriture format d'appel de la fonction ferror : ferror (pointeur de fichier) ;

Fonction : Vérifiez s'il y a des erreurs lors de la lecture et de l'écriture de fichiers à l'aide de diverses fonctions d'entrée et de sortie. . Si la valeur de retour de ferror est 0, cela signifie qu'il n'y a pas d'erreur, sinon cela signifie qu'il y a une erreur.

3. Définissez l'indicateur d'erreur de fichier et l'indicateur de fin de fichier sur 0. Format d'appel de la fonction clearerr : clearerr (pointeur de fichier)

Fonction : Cette fonction est utilisée pour effacer l'indicateur d'erreur et le fichier ; drapeau de fin, de sorte qu'ils aient une valeur de 0.

Fichiers de bibliothèque C

Le système C fournit une multitude de fichiers système, appelés fichiers de bibliothèque. Les fichiers de bibliothèque C sont divisés en deux catégories, l'une étant les fichiers avec l'extension ".h", appelés. un fichier d'en-tête, que nous avons utilisé plusieurs fois dans les commandes d'inclusion précédentes. Le fichier « .h » contient des informations telles que des définitions de constantes, des définitions de types, des définitions de macros, des prototypes de fonctions et divers paramètres de sélection de compilation. L'autre type est la bibliothèque de fonctions, qui comprend le code cible de diverses fonctions que les utilisateurs peuvent appeler dans le programme. Habituellement, lors de l'appel d'une fonction de bibliothèque dans un programme, le fichier ".h" où se trouve le prototype de la fonction doit être inclus avant l'appel.

Toutes les fonctions de la bibliothèque sont données en annexe.

ALLOC.H 　　Décrit les fonctions de gestion de la mémoire (allocation, libération, etc.).
ASSERT.H 　　Définition d'une macro de débogage d'assertion.
BIOS.H 　　　　　　　　　　　　　　　　　　　　　　　 Out over appellera diverses fonctions du sous-programme BIOS ROM IBM-PC.
CONIO.H 　　Décrit les différentes fonctions qui appellent le sous-programme d'E/S de la console DOS.
CTYPE.H Contient des informations sur le type de nom sur la classification et la conversion des caractères (tels que isalpha, toascii, etc.).
DIR.H 　　Contient des structures, des définitions de macros et des fonctions liées aux répertoires et aux chemins.
DOS.H 　　Définition et description de certaines constantes et fonctions appelées par MSDOS et 8086.
ERRON.H Définit le mnémonique des codes d'erreur.
FCNTL.H 　　Constantes symboliques définies lors de la connexion au sous-programme de la bibliothèque ouverte.
FLOAT.H 　　 Contient certains paramètres et fonctions liés aux opérations en virgule flottante.
GRAPHICS.H explique diverses fonctions liées aux fonctions graphiques, des définitions constantes de codes d'erreur graphiques, diverses valeurs de couleur​​pour différents pilotes et certaines structures spéciales utilisées par les fonctions.
IO.H 　　Contient la structure et la description des sous-programmes d'E/S de bas niveau.
LIMIT.H 　　Contient des informations sur divers paramètres d'environnement, les délais de compilation, les plages de numéros et d'autres informations.
MATH.H 　　Explique la fonction d'opération mathématique, définit également la macro HUGE VAL et explique la structure spéciale utilisée par matherr et les sous-programmes matherr.
MEM.H 　　Décrit certaines fonctions d'opération de mémoire (dont la plupart sont également décrites dans STRING.H).
PROCESS.H Décrit les différentes fonctions de gestion des processus, la description de la structure des fonctions spawn... et EXEC....
SETJMP.H Définissez le type jmp buf utilisé par les fonctions longjmp et setjmp, et décrivez ces deux fonctions.
SHARE.H Définit les paramètres de la fonction de partage de fichiers.
SIGNAL.H 　 Définissez les constantes SIG[ZZ(Z] [ZZ)]IGN et SIG[ZZ(Z] [ZZ)]DFL pour illustrer les deux fonctions rajse et signal.
STDARG.H 　　Définition des macros de lecture des tables de paramètres des fonctions. (Comme les fonctions vprintf, vscarf).
STDDEF.H Définit certains types de données publiques et macros.
STDIO.H Définit les types et macros standard et étendus définis par Kernighan et Ritchie dans Unix System V. Définit également les flux prédéfinis d'E/S standard : stdin, stdout et stderr, décrivant les sous-programmes de flux d'E/S.
STDLIB.H explique certains sous-programmes couramment utilisés : les sous-programmes de conversion, les sous-programmes de recherche/tri, etc.
STRING.H 　　Décrit certaines opérations de chaîne et fonctions d'opération de mémoire.
SYSSTAT.H Définit certaines constantes symboliques utilisées lors de l'ouverture et de la création de fichiers.
SYSTYPES.H explique la fonction ftime et la structure timeb.
SYSTIME.H Définit le type d'heure time[ZZ(Z] [ZZ)]t.
TIME.H 　　 Définir la structure des sous-programmes de conversion de temps asctime, localtime et gmtime, les types utilisés par ctime, difftime, gmtime, localtime et stime, et fournir des prototypes de ces fonctions.
VALUE.H Définit certaines constantes importantes, y compris celles qui dépendent du matériel de la machine et celles spécifiées pour la compatibilité avec Unix System V, y compris des plages de valeurs à virgule flottante et double précision.

Recommandations associées :

Classe de manipulation de texte PHP_Tutoriel PHP

Page de comparaison des collections de méthodes de manipulation de texte PHP 1/2_Tutoriel PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!