Divers code utile pour les fichier texte

[dayvid]

Salut a tous !

Voici quelques code pour les fichier texte:


Permet de lire un fichier texte très rapidement
utile notamment pour les très gros fichier texte (plusieurs Mo)

Code : Tout sélectionner

; Lire un fichier a la vitesse de l'éclair
; Par M Dieppedalle David le dimanche 3 octobre 2010

file$ = OpenFileRequester("Sélectionnez un fichier","","Text (.txt)|*.txt|All files (*.*)|*.*",0)
  If file$
    If ReadFile(0, file$)
      length = Lof(0) ; Lit la taille en octets du fichier
      *MemoryID = AllocateMemory(length) ; alloue un bloc mémoire de la taille du fichier "length"
      If *MemoryID ; si l'allacation a bien fonctionner ont continue
        ReadData(0, *MemoryID, length)   ; Lit les données du fichier et les place dans le bloc mémoire "*MemoryID" de la taille correspondant à "length"
        *Fichier.String = @*MemoryID ; "*Fichier" a pour valeur l'adresse où réside la chaîne de caractères en mémoire "*MemoryID"
        Fichier$ = *Fichier\s ; "Fichier$" à pour valeur le texte où réside la chaîne de caractères en mémoire "*MemoryID"
        Debug Fichier$
      EndIf
      CloseFile(0)
    EndIf
  EndIf

Permet d'écrire dans le fichier a la ligne voulue
et a la position souhaitez

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l WriteFileLigne(NonFichier$, Texte$, NumeroLigne, Position) ; Position -1 = écrire a la fin de la ligne
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  Debug Position
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$) + 1
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = InsertString(Ligne$, Texte$, Position)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Pour savoir le nombre de ligne dans le fichier

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NombreLigne = 0

Procedure CountFileLine(NonFichier$)
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      ReadString(1) ; lit ligne par ligne le contenu du fichier
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    MessageRequester("Information","Impossible d'ouvrir le fichier !")
  EndIf
EndProcedure

Ceci permet de supprimer la ligne spécifier dans le fichier

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l DeleteFileLigne(NonFichier$, NumeroLigne)
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) + Chr(13) + Chr(10) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      DeleteElement(ComptenueFichier(), 1)
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteString(1, ComptenueFichier())
      Next ComptenueFichier()
      
      CloseFile(1)
    Else ; Sinon ont affiche un message d'avertissement
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Ceci permet de supprimer une ou plusieurs
chaine d'un coup a la ligne souhaiter dans le fichier

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l RemoveCharFileLigne(NonFichier$, ChaineASupprimer$, NumeroLigne, Position, Mode, SupprimerNombreOccurence) ; Position -1 = supprimer le dernier caractère a la fin de la ligne
  
  If Mode = 0
    Mode = #PB_String_NoCase
  ElseIf Mode = 1
    Mode = 0
  Else
    Mode = #PB_String_NoCase
  EndIf
  
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$)
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = RemoveString(Ligne$, ChaineASupprimer$, Mode, Position, SupprimerNombreOccurence)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Ceci permet de remplacer une chaine a la ligne
souhaiter dans le fichier

Code : Tout sélectionner

; Par M Dieppedalle David en avril  2011

Global NewList ComptenueFichier.s()

Procedure.l ReplaceCharFileLigne(NonFichier$, ChaineARechercher$, RemplacerChainePar$, NumeroLigne, PositionDepart, Mode) ; Position -1 = Remplacer le dernier caractère a la fin de la ligne
  
  If Mode = 0
    Mode = #PB_String_NoCase
  ElseIf Mode = 1
    Mode = 0
  Else
    Mode = #PB_String_NoCase
  EndIf
  
  NombreLigne = 0
  If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
    While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
      NombreLigne + 1
      AddElement(ComptenueFichier())
      ComptenueFichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
    Wend
    CloseFile(1) ; Ferme le fichier précédemment ouvert
  Else ; Sinon ont affiche un message d'avertissement
    ProcedureReturn 0
  EndIf
  
  ForEach ComptenueFichier()
    Index = ListIndex(ComptenueFichier())
    If Index = NumeroLigne - 1
      Ligne$ = ComptenueFichier()
      If Position = -1
        Position = Len(Ligne$)
      ElseIf Position <= 0
        Position = 1
      ElseIf Position > Len(Ligne$)
        Position = Len(Ligne$)
      EndIf
      Ligne$ = ReplaceString(Ligne$, ChaineARechercher$, RemplacerChainePar$, Mode, Position)
      ComptenueFichier() = Ligne$
      Break
    EndIf
  Next ComptenueFichier()
  
  If DeleteFile(NonFichier$)
    If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
      ForEach ComptenueFichier()
        WriteStringN(1, ComptenueFichier())
      Next ComptenueFichier()
      CloseFile(1)
    Else
      ProcedureReturn 0
    EndIf
  Else
    ProcedureReturn 0
  EndIf
  
  ProcedureReturn 1
EndProcedure

Sinon j'ai essayer de faire une fonction pour tous sa mais c'est pas encore au point

Code : Tout sélectionner

Global NewList Fichier.s()
Global NombreLigne = 0

Procedure.l FileOperation(NomFichier$ = "", TypeOperation$ = "", NumeroLigne = 1, Chaine1$ = "", Chaine2$ = "", Position = 1, Mode = 0, Occurence = 1)
  
  ClearList(Fichier())
  
  If TypeOperation$ = "ReadSimple"
    
    If ReadFile(1, NomFichier$) ; Si le fichier peut être lu , on continue...
      While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File') 
        AddElement(Fichier())
        Fichier() = ReadString(1) ; Affiche ligne par ligne le contenu du fichier
      Wend
      CloseFile(1) ; Ferme le fichier précédemment ouvert
      ProcedureReturn 1
    Else ; Sinon ont affiche un message d'avertissement
      ProcedureReturn 0
    EndIf
    
  ElseIf NomFichier$ = "ReadSpeed"
    ; Lire un fichier a la vitesse de l'éclair
    ; Par M Dieppedalle David le dimanche 3 octobre 2010
    Ligne = 0
        If ReadFile(1, file$) 
          length = Lof(1) ; Lit la taille en octets du fichier 
          *MemoryID = AllocateMemory(length) ; alloue un bloc mémoire de la taille du fichier "length"
          If *MemoryID ; si l'allacation a bien fonctionner ont continue
            ReadData(1, *MemoryID, length)   ; Lit les données du fichier et les place dans le bloc mémoire "*MemoryID" de la taille correspondant à "length"
            *Fichier.String = @*MemoryID ; "*Fichier" a pour valeur l'adresse où réside la chaîne de caractères en mémoire "*MemoryID"
            Donnee$ = *Fichier\s ; "Fichier$" à pour valeur le texte où réside la chaîne de caractères en mémoire "*MemoryID"
            
            Repeat
              Ligne + 1
              AddElement(Fichier())
              Fichier() = StringField(Donnee$, Ligne, Chr(13) + Chr(10))
            Until Lecture$ = ""
            
            ProcedureReturn 1
          Else
            ProcedureReturn 0
          EndIf
          CloseFile(0)
        Else
          ProcedureReturn 0
        EndIf
      
    ElseIf NomFichier$ = "WriteSimple"
      If OpenFile(1, NomFichier$)    ; Ouvre un fichier existant ou en crée un nouveau s'il n'existait pas
        FileSeek(1, Lof(1))         ; Place le pointeur à la fin du fichier en utilisant le résultat de Lof() 
        WriteStringN(1, Chaine1$)
        CloseFile(1)
        ProcedureReturn 1
      Else ; Sinon ont affiche un message d'avertissement
        ProcedureReturn 0
      EndIf
      
    ElseIf NomFichier$ = "WriteStringLine"
      
      ; Position -1 = écrire a la fin de la ligne
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        Debug Position
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$) + 1
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = InsertString(Ligne$, Chaine1$, Position)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "CountLine"
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            ReadString(1) ; lit ligne par ligne le contenu du fichier
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
          ProcedureReturn 1
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
    ElseIf NomFichier$ = "RemoveLine"
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) + Chr(13) + Chr(10) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            DeleteElement(Fichier(), 1)
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteString(1, Fichier())
            Next Fichier()
            
            CloseFile(1)
          Else ; Sinon ont affiche un message d'avertissement
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "RemoveStringLine"
      ; Position -1 = supprimer le dernier caractère a la fin de la ligne
        If Mode = 0
          Mode = #PB_String_NoCase
        ElseIf Mode = 1
          Mode = 0
        Else
          Mode = #PB_String_NoCase
        EndIf
        
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$)
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = RemoveString(Ligne$, Chaine1$, Mode, Position, Occurence)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
      
    ElseIf NomFichier$ = "ReplaceStringLine"
      ; Par M Dieppedalle David en avril  2011
      ; Position -1 = Remplacer le dernier caractère a la fin de la ligne
        
        If Mode = 0
          Mode = #PB_String_NoCase
        ElseIf Mode = 1
          Mode = 0
        Else
          Mode = #PB_String_NoCase
        EndIf
        
        NombreLigne = 0
        If ReadFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
          While Eof(1) = 0 ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File')
            NombreLigne + 1
            AddElement(Fichier())
            Fichier() = ReadString(1) ; lit ligne par ligne le contenu du fichier et l'enregistre dans la liste
          Wend
          CloseFile(1) ; Ferme le fichier précédemment ouvert
        Else ; Sinon ont affiche un message d'avertissement
          ProcedureReturn 0
        EndIf
        
        ForEach Fichier()
          Index = ListIndex(Fichier())
          If Index = NumeroLigne - 1
            Ligne$ = Fichier()
            If Position = -1
              Position = Len(Ligne$)
            ElseIf Position <= 0
              Position = 1
            ElseIf Position > Len(Ligne$)
              Position = Len(Ligne$)
            EndIf
            Ligne$ = ReplaceString(Ligne$, Chaine1$, Chaine2$, Mode, Position)
            Fichier() = Ligne$
            Break
          EndIf
        Next Fichier()
        
        If DeleteFile(NonFichier$)
          If OpenFile(1, NonFichier$) ; Si le fichier peut être lu , on continue...
            ForEach Fichier()
              WriteStringN(1, Fichier())
            Next Fichier()
            CloseFile(1)
          Else
            ProcedureReturn 0
          EndIf
        Else
          ProcedureReturn 0
        EndIf
        
        ProcedureReturn 1
           
    Else
      
    EndIf
    
  EndProcedure
  
; IDE Options = PureBasic 4.60 Beta 2 (Windows - x86)
; CursorPosition = 8
; Folding = -
; EnableXP
; EnableUser
; EnableOnError
; EnableCompileCount = 11
; EnableBuildCount = 0
; EnableExeConstant

[ricou 94]

Bonjour Dayvid !
C'est toujours pour moi un plaisir de te lire car tes interventions me permettent de mettre en évidence des conceptes de programmations. Grâce à ces nouveaux conceptes, je retouche mes applications et bien souvent, elles sont plus fluïdes lors de leur exécutions, et le nombre d'erreur qu'elles renferment diminu.
Ici, par exemple, tu m'as permis, d'imaginer et de concevoir un objet ou appareil capable de manipuler plusieurs fichiers textes en même temps.
Trouvant cette idée intéressante, je me permet d'intervenir dans ce poste. J'essairai, d'être assez précis dans mes explications pour que vous, chers lecteurs, puissiez comprendre ce concepte, et utiliser, à votre tour, ce nouvel objet, qui j'espère, répondra à vos attentes !
Je tiens également à remercier Dräke, qui grâce à son tutoriel sur la programmation orientée objet en pure basic, m'a permis de mieux comprendre l'idée de pointeur, de structures, et m'a montré, comment, l'on pouvait les faire jouer ensembles pour créer des objets capables de se transformer, et créer des ensembles informatiques assez complexes, mais très puissants !
Mais au fait ! pourquoi je parle de "programmation orientée objet ?" Pour le savoir, il suffit de reprendre le code de Dayvid.
En effet, la procédure "fileoperation" peut être considérée comme une "boîte à outils" renfermant toutes les fonctions que tu as décrites plus haut. La variable "typeoperation$" permet d'indiquer au programme la tâche ou la méthode qu'il doit effectuer. En d'autres termes, l'outil qu'il doit utiliser.
Les autres paramètres de cette procédure peuvent être considérés comme des "membres" qui seront utilisés par les différentes méthodes de cette procédure.
On a donc bien un concept de programmation orientée objet. Le module "textfile.pbi" ci-dessous, décrit un objet appelé "textfile" capable de travailler avec des fichiers *.txt, et regroupant les différentes procédures que tu as développées ci-dessus.
//

Code : Tout sélectionner

; textfile.pbi
; ce module permet de créer un objet pour manipuler rapidement des fichiers textes.
; explication pour mieux comprendre ce code.
; notre objet peut être assimilé à une boîte dans laquelle on utilise la procédure "textfile_new" pour introduir le / les fichiers *.txt à modifier ou à créer.
; Cette procédure prend comme paramètre d'entrée le nom du fichier texte qu'elle stockera dans le champ "filename" de la structure "textfile_class.
; Elle alouera une zone mémoire de la taille de la structure "textfile_class" capable de recevoir du texte. (ce texte sera stocké dans "buffertext"
; champ de la structure "textfile_class".
; Chaque texte introduit dans cet objet est considéré comme une instance de celui-ci.
; C'est la raison pour laquelle "textfile_new" retourne un pointeur "*instance_textfile" permettant d'accéder aux membres de la structure "textfile_class".
; Pour que notre objet serve à quelque chose, il est essentiel que les outils qu'il renferme (autrement dit ses méthodes),
; puissent transformer le fichier texte qu'on aura introduit grâce à "textfile_new".
; Il faut donc que les méthodes de notre objet puissent aussi accéder à ce texte. 
; C'est pourquoi chaque méthode doit prendre comme premier paramètre d'entrée "*instance_textfile.textfile_class".
; De manière plus générale, le format "pe" ou "portable exécutable", propre aux fichiers exécutables, utilise un bloc mémoire pour chaque élément qu'il aura à stocker, lire ou modifier.
; celà explique les mots "global", "shared", ou "protected" que l'on trouve dans "purebasic".
; Notre objet n'échappe donc pas à cette règle.
; Chaque procédure / méthode et même chaque instance de celui-ci, est stocké dans des blocs de mémoires indépendants.
; C'est pourquoi nous devons créer une "interface physique" qui reprenne les méthodes décrites dans le bloc "interface ... endinterface",
; pour stocker l'adresse de ces méthodes après compilation.
; Cette interface physique est symbolisée par la structure "textfile_methodes".
; Cette structure se compose d'une série de pointeurs dans laquelle chaque pointeur reprend le nom de chaque entêtes de méthode décrites dans le bloc "interface ... endinterface".
; Par la suite, c'est le bloc "with ... endwith" qui associe chaque pointeur à l'adresse mémoire de la procédure leur correspondant.
; la variable "textfile_mthds" permet d'accéder à cette table.
; de même que la variable "*textfile_" permet au programme qui aura demandé l'instanciation de "textfile" d'accéder aux membres de chaque instance.
 
 #endofline = Chr(13) ; fin de ligne
#endofparagraph = Chr(13)+Chr(10) ; fin de paragraphe
objectname$ = "textfile" ; variable qui sera utilisée par les macros à la fin de ce fichier. 

; déclaration de la partie publique.
; le bloc suivant décrit la partie externe de notre boîte à texte,
; et présente les outils qu'elle contient.
Interface textfile
  loadtextfile ()
  countline ()
  Inserttext (nouvelle_chaine.s,ligne.l=-1,colonne.l=0)
  deleteline (ligne.l)
  savebuffertext ()
getwordline .l (word.s,start.l=1)  
EndInterface

; déclaration de la classe de l'objet
; Nous décrivons maintenant la partie interne de notre boîte à texte. 

Structure textfile_class
  *methodes ; pointeur indiquant à une instance de l'objet l'emplacement de ses méthodes.
  ; définition des membres de l'objet textfile.
  buffertext.s ; chaîne contenant le texte écrit dans le fichier *.txt
  filename.s ; chaîne contenant le chemin complet du fichier (unité:\dossier\nomfichier.extension)
EndStructure
Global *textfile_.textfile_class ; pointeur permettant au monde extérieur de modifier les propriétés d'une instance de textfile.
; création des méthodes (partie interne de l'objet).
Procedure .l loadtextfile (*instance_textfile.textfile_class)
  ; charge un fichier *.txt et stocke son contenu dans la variable (buffertext).
  ; paramètre d'entrée : 
  ; *instance_textfile : pointeur faisant référence à une instance de l'objet "textfile".
  ; Si vous appelez cette procédure en utilisant une instance de "textfile", ce pointeur ne doit pas être mentionné.
  ; par ailleurs, la procédure "new_textfile", doit être appelée avant l'utilisation de cette procédure. 
  ; en retour, la procédure renvoie le nombre de caractères copiés dans "buffertext".
  ; lecture des informations contenues dans le fichier *.txt
  numfile = ReadFile (#PB_Any,*instance_textfile\filename)
  If numfile > 0 ; le fichier a pu être ouvert on stocke son contenu dans buffertext
        While Not Eof(numfile)
          *instance_textfile\buffertext+ReadString (numfile)+#endofparagraph
        Wend
        CloseFile (numfile)
        ProcedureReturn Len(*instance_textfile\buffertext)
      Else ; erreur pendant le chargement ou la lecture du fichier
        CloseFile (numfile)
                ProcedureReturn 0
                EndIf ; fin de condition concernant le teste de numfile
              EndProcedure
              Procedure .l countline (*instance_textfile.textfile_class)
                ; retourne le nombre de lignes d'un fichier *.txt
                ; paramètre d'entrée : 
                ; - *instance_textfile : un pointeur faisant référence à une instance de textfile.
                ; celui-ci n'a pas besoin d'être précisé si vous utilisez une instance de cet objet.
                
                ProcedureReturn CountString (*instance_textfile\buffertext,Chr(13))+1
                EndProcedure
                
                Procedure Inserttext (*instance_textfile.textfile_class,nouvelle_chaine.s,ligne.l=-1,colonne.l=1)
                  ; insère du texte dans buffertext
                  ; paramètres d'entrée : 
                  ; - *instance_textfile : un pointeur faisant référence à une instance de l'objet textfile.
                  ; (lors de l'appel, ce pointeur n'a pas besoin d'être mentionné).
                  ; car il l'a déjà été lors de l'initialisation de la nouvelle instance de textfile.
                  ; (voir procédure "new").
                  ; de plus, lorsque pour appeler cette procédure on écrira : "nouvelleinstance\inserttext"
; nouvelleinstance est en réalité le pointeur (*instance_textfile")                  
                  ; - nouvelle_chaine : chaîne contenant le texte à insérer.
                  ; - ligne : contient le numéro de la ligne où doit s'effectuer l'insertion.
                  ; Si ce paramètre n'est pas préciser lors de l'appel, le texte sera inséré à la fin de buffertext.
                  ; - colonne : la colonne où doit s'effectuer l'insertion.
                  ; Si ce paramètre n'est pas précisé lors de l'appel, le texte est inséré au début de buffertext.
                  ; où au début de la ligne spécifiée dans la variable ligne.
                  Protected position_insertion.l ; contient la position où s'effectuera l'insertion.
                  Protected position_finligne_premiereligne.l ; position du premier retour chariot.
                  Protected position_finligne.l ; position d'une fin de ligne quelconque.
                  
                  Protected chaine.s ; chaîne provisoire.
                  
                  ; A. examen des paramètres
                  ; et calcul de la position où s'effectuera l'insertion.
                  
                  position_finligne_premiereligne = FindString(*instance_textfile\buffertext,Chr(13),1)
                  
                  If ligne=-1 Or colonne >= Len(*instance_textfile\buffertext)
                    ; on insère à la fin de buffertext
                    position_insertion = Len(*instance_textfile\buffertext)+1
                    
                  Else ; le développeur a précisé une ligne pour l'insertion
                    Select ligne
                      Case 0 ; ligne invalide, on insère la nouvelle chaîne au début de buffertext
                        position_insertion = 1
                      Case 1
                        ; inutile de parcourir toute la chaîne, l'insertion s'effectuera sur la première ligne.
                        ; toutefois, on s'assure que la colonne n'est pas supérieure au nombre de caractères présents sur la ligne.
                        If colonne >= position_finligne_premiereligne
                          position_insertion = position_finligne_premiereligne-1
                        Else ; chaîne insérée dans la ligne.
                          position_insertion = colonne
                        EndIf
                      Default
                        ; l'insertion s'effectuera dans une ligne quelconque de buffertext
                        ; Comme les chaînes de caractères sont constituées d'une suite de caractères stockés linéairements
                        ; et que la fin de ces chaînes n'est pas symbolisé par le retour à la ligne mais par le caractère chr(0),
                        ; il faut déterminer la position de la ligne précisée lors de l'appel de la procédure.
                        position_finligne = 1
                        
                        For i = 1 To ligne-1
                          position_insertion = FindString (*instance_textfile\buffertext,Chr(13),position_finligne)
                          position_finligne = position_insertion+1
                          
                        Next i
                        ; il faut maintenant s'assurer que la colonne ne soit pas plus grande que la longueur de la ligne où doit s'effectuer l'insertion.
                        ; si tel était le cas, nouvellechaine serait insérée à la mauvaise ligne.
                        If colonne <= position_finligne-1 ; ligne moin le retour chariot
                          position_insertion + colonne ; le texte sera inséré sur la bonne ligne
                        Else ; on ignore le paramètre colonne
                          ; et on insère le nouveau texte à la fin de la ligne.
                          position_insertion + (position_finligne-1)
                    EndIf ; fin de la condition liée au contrôle du paramètre colonne      
                    EndSelect ; fin des conditions liées au numéro de ligne
                  EndIf ; fin du calcul de la position d'insertion
                  *instance_textfile\buffertext = InsertString (*instance_textfile\buffertext,nouvelle_chaine,position_insertion)
                  
                EndProcedure
                
                Procedure deleteline (*instance_textfile.textfile_class,ligne.l)
                  ; efface une ligne
                  ; paramètre d'entrée : 
                  ; *instance_textfile : ce pointeur n'a pas besoin d'être précisé lors de l'appel,
                  ; car il s'agit du pointeur retourné par l'instance utilisée pour appeler cette procédure.
                  ; - ligne : nombre contenant le numéro de la ligne à supprimer.
                  chaine.s ; chaîne de caractères provisoire
                  ; chaque fin de ligne de texte d'un fichier *.txt est symbolisées par #endofline  ou  #endofparagraph.
                  ; Dans ces deux cas, on retrouve un #endofline !
 ; grâce à stringfield, on peut directement extraire la ligne à supprimer sans passer par des fonctions de listes.
                  chaine = StringField (*instance_textfile\buffertext,ligne,#endofline)
                  ; et on la supprime
                  *instance_textfile\buffertext = RemoveString (*instance_textfile\buffertext,chaine,ligne,ligne-1,2)
                  
                  EndProcedure
                  
                  Procedure .l savebuffertext (*instance_textfile.textfile_class)
                    ; sauvegarde sur un média physique le contenu de buffertext.
                    ; paramètre d'entrée : 
                    ; - *instance_textfile : pointeur faisant référence à l'instance de l'objet textfile.
                    ; Lors de l'appel, ce pointeur ne doit pas être mentionné, 
                    ; car il l'a déjà été lors de l'invocation de cette méthode.
                    ; en retour, la procédure renvoie "0" si une erreur est survenue,
                    ; si aucune erreur ne survient, la procédure renverra un nombre différent de 0.
                    ; (voir l'instruction "writestring").
                    Protected erreur.l ; code d'erreur
                    Protected numfile.l ; numéro du fichier ouvert par "creatfile".
                    
                    ; regarde si le champ "filename" de la structure textfile_class comporte un nom de fichier.
                    If Len(*instance_textfile\filename) = 0 ; aucun nom de fichier.
                      ; on invite le développeur ou l'utilisateur à indiquer l'emplacement physique de stockage du nouveau fichier.
                      *instance_textfile\filename = SaveFileRequester ("où voulez-vous enregistrer votre texte ?","c:\","fichiers textes (*.txt)|*.txt",0)
                    EndIf ; fin de condition liée à l'examen de "textfile_class\filename"
                    ; on sauvegarde le texte.
                    erreur = 0
                    numfile = CreateFile (#PB_Any,*instance_textfile\filename)
                    erreur = WriteString (numfile,*instance_textfile\buffertext)
                    CloseFile (numfile)
                    ProcedureReturn erreur
                  EndProcedure
                  
                  Procedure .l getwordline (*instance_textfile.textfile_class,word.s,startingline.l=1)
                    ; retourne le numéro de la ligne sur laquelle a eu lieu la première apparition du mot "word"
                    ; *instance_textfile : pointeur faisant référence à une instance de l'objet _textfile.
                    ; - word : le mot à rechercher.
                    ; startingline : le numéro de la ligne où doit commencer la recherche.
                    ; si ce paramètre n'est pas mentionné, la recherche commence au début du fichier.
                    ; en retour, la procédure renvoie un entier 32 bits, indiquant le numéro de la ligne, ou 0 si la recherche a été infructueuse.
                    
                    Protected position_depart.l=0
                    Protected derniere_ligne.l=0
                    
                    ; regardez la ligne suivante !
                    ; on appelle une méthode de notre objet textfile, 
                    ; ici, on précisera *instance_textfile car à ce stade, notre objet n'est pas initialisé.
                    derniere_ligne = countline (*instance_textfile)
                    finrecherche=#False
                    position_depart = startingline
                    ; boucle de recherche
                    For position_depart = startingline To derniere_ligne
                      ;a. on extrait une ligne du fichier :
                      ligne$ = LTrim (StringField (*instance_textfile\buffertext,position_depart,#endofline))
                      If CountString (ligne$,word) > 0 ; la ligne extraite contient l'expression contenue dans le paramètre d'entrée word.
                        finrecherche=#True ; indique que la recherche est finie
                        Break ; sort de la boucle de recherche
                        EndIf ; fin de condition countstring>0
                      Next position_depart ; fin de la boucle de recherche
                      ; la recherche a-t-elle été fructueuse ?
                      If finrecherche=#False ; non !
                        ; position_depart contient le numéro de la dernière ligne de texte du fichier, on remet cette variable à 0  
                        position_depart=0
                      EndIf ; fin de condition if finrecherche=#false
                      ProcedureReturn position_depart
                  EndProcedure
; maintenant que toutes les méthodes de notre objet ont été développées,
; on les références dans une table 
              Structure textfile_methodes
                *loadtextfile
                *countline
                *inserttext
                *deleteline
                *savebuffertext
                *getwordline
              EndStructure
              Global textfile_mthds.textfile_methodes
              ; initialisation de cette table
              With textfile_mthds
              \loadtextfile = @loadtextfile ()
                \countline = @countline ()
                \inserttext = @Inserttext ()
                \deleteline = @deleteline ()
                \savebuffertext = @savebuffertext()
                \getwordline = @getwordline ()
EndWith                
              ;constructeur de l'objet
              Procedure .l textfile_new (filename.s)
                ; initialise l'objet
                ; en entrée la procédure reçoit le nom du fichier text
                ; en retour, la procédure renvoie un pointeur faisant référence à la nouvelle instance de l'objet
                Shared textfile_mthds
                ; création d'une zone mémoire contenant l'objet textfile.
                
                *instance_textfile.textfile_class = AllocateMemory (SizeOf(textfile_class))
                   *instance_textfile\methodes = @textfile_mthds ; pointeur faisant référence à la table des méthodes de l'objet
                    *instance_textfile\filename = filename ; le nom du fichier *.txt de la nouvelle instance.
                    *textfile_ = *instance_textfile ; contient l'adresse de la nouvelle instance (utile pour pouvoir accéder aux membres de la nouvelle instance).)
                    
                ProcedureReturn *instance_textfile
              EndProcedure

Le développeur voulant manipuler du texte ou des textes, n'a plus qu'à initialiser cet objet, en lui passant le nom du fichier *.txt à examiner ou modifier ainsi que l'opération à effectuer.
L'objet, quant à lui, exécute des méthodes / procédures internes pour lire ou modifier ce fichier, puis renvoie, pour chaque opération, un résultat pour que le développeur puisse avoir un contrôle sur le travail accompli.
Celà nous conduit au code suivant :

//

Code : Tout sélectionner

; demotextfile.pb 
; démonstration pour instancier et utiliser l'objet textfile
XIncludeFile ("textfile.pbi") ; le module ci-dessus

Global texte.textfile
; texte est un pointeur référençant l'objet "textfile".
texte = textfile_new ("demo.txt")
; la méthode "textfile_new" de l'objet textfile est appelée, et initialise une zone mémoire pour notre instance "texte".
; le champ "filename" de la structure "textfile_class" prend la chaîne de caractères "demo.txt".
; Pour le moment, notre fichier "demo.txt" est vide, il n'est pas encore créé physiquement sur une unité de stockage,
; mais la zone "buffertext" de la structure "textfile_class" est prête à être remplie.
texte\Inserttext ("texte bidon !"+#endofparagraph)
; voici une première ligne de texte qui vient d'être ajoutée à buffertext.
              texte\inserttext ("juste pour tester"+#endofparagraph,2,2)
              texte\inserttext ("méthode insertext de l'objet textfile"+#endofparagraph,3,2)
              ; puis deux autres !
              ; En me relisant je me suis apperçu que j'avais oublié le mot "la" 
              ; nous l'insérons à notre texte.
              texte\inserttext ("la ",3,2)
              texte\inserttext ("Si vous avez des fins de paragraphes à faire, "+#endofparagraph,4,4)
              texte\inserttext ("n'oubliez pas d'insérer votre texte à partir de la deuxième colonne de chaque ligne, afin de garder le code retour chariot.",-1)
              ;
              
              ; on sauvegarde sur disque ce petit texte.
              erreur = texte\savebuffertext ()
              ; et on l'affiche.
              ; remarquez la variable "textfile_" qui permet d'accéder à un membre de l'objet "textfile"
              ; -membre qui se trouve dans la structure textfile_class-.
              
              Debug *textfile_\buffertext
              Debug "notre fichier de démonstration contient "+Str(texte\countline ())+" lignes de textes."
              ; les deux prochaines lignes, montrent l'utilisation de la méthode "getwordline"
              ; qui permet de retrouver le numéro de la ligne qui contient le texte spécifié dans le paramètre d'entrée "word".
              
              Debug "et le mot méthode se trouve sur la ligne n° "+Str(texte\getwordline ("méthode"))+"."
              Debug "la première apparition du mot ins se trouve à la ligne n° "+Str(texte\getwordline ("ins"))
              Debug "on peut également retrouver ce mot sur la ligne "+Str(texte\getwordline("insé",4))
              
              If erreur = 0
                Debug "l'enregistrement de ce petit texte a échoué"
              Else
                Debug "ce texte a été enregistré dans le dossier où se trouve le fichier textfile.pbi"
              EndIf
              End
 

La deuxième démonstration montre l'utilisation de "dim" pour mettre dans notre "boîte à textes" plusieurs textes.
//

Code : Tout sélectionner

; demo2.pb
; cette deuxième démonstration montre comment créer une collection de textes avec l'objet "textfile".
XIncludeFile ("textfile.pbi")
Dim mestextes.textfile(4) ; 4 textes seront chargés en mémoire
; les deux lignes suivantes vont recharger notre fichier demo.txt qui a été créé après l'exécution de notre première démonstration. 
mestextes(1) = textfile_new ("demo.txt")
mestextes(1)\loadtextfile ()
; on va maintenant créer une deuxième instance 
mestextes(2) = textfile_new ("text2.txt")
mestextes(2)\inserttext ("voici un deuxième texte de démonstration"+#endofparagraph,-1)
mestextes(2)\inserttext ("pour démontrer que notre objet supporte une collection"+#endofparagraph,2,2)
mestextes(3) = textfile_new ("texte3.txt")
mestextes(3)\inserttext ("Dans notre prochaine démonstration (demo3.pb), nous verrons comment l'on peut surcharger une méthode pour modifier son comportement"+#endofparagraph,3,2)
; Nous pourrions afficher ces trois textes.
; mais pour nous amuser un peu, nous allons les fusionner dans notre quatrième zone mémoire "buffertext(4)".

For i = 1 To 3
  *textfile_ = mestextes(i)
  texte$ + #endofparagraph+*textfile_\buffertext+#endofparagraph
Next i
mestextes(4) = textfile_new ("fusion.txt")
mestextes(4)\inserttext (texte$)
mestextes(4)\savebuffertext () ; "fusion.txt" vient d'être enregistré dans votre disque dur !
; la ligne suivante montre que l'on peu, grâce à l'accesseur "*textfile_" manipuler facilement un membre de notre objet.
*textfile_ = mestextes(4)
*textfile_\buffertext+#endofparagraph+"comme vous pouvez le constater, la fusion a bien été faite ! mais cette dernière ligne n'apparaîtra pas dans fusion.txt"
; nous allons maintenant renommer "fusion.txt" en "fusion2.txt"
*textfile_\filename = "fusion2.txt"
mestextes(4)\savebuffertext  (); ce fichier vient d'être créé physiquement.

Debug *textfile_\buffertext

End

Le code ci-dessus montre que chaque fichier de texte est stocké dans une zone mémoire de taille identique "sizeof(textfile_class)". On est donc face à une pile où le registre de base est "texte", et l'index est l'offset qui permet d'accéder à un texte.
Le pointeur textfile_ prend l'adresse : "texte(index)".
Si l'on veut, par exemple, libérer de la mémoire en supprimant le premier texte de notre boîte à texte, il suffit d'écrire :
//

Code : Tout sélectionner

freememory (texte(1))

La troisième démonstration est un peu plus technique et montre comment on peut "modifier" partiellement notre objet pour qu'il réponde à des besoins spécifiques.
Ici, nous utilisons la variable "textfile_mthds" qui fait référence à une table des méthodes ou interface physique de "textfile".

Code : Tout sélectionner

 ;demo3.pb
; ici, nous allons modifier le comportement de la méthode "countline" de l'objet textfile.

XIncludeFile ("textfile.pbi")
Global textebidon.textfile
textebidon = textfile_new ("demo3.txt")
textebidon\inserttext ("voici une ligne de texte, pour montrer que la méthode countline de l'objet textfile fonctionne pour l'instant normalement",-1)
MessageRequester ("demo3.pb","le fichier demo3.txt qui n'est pour l'instant que virtuel, contient "+Str(textebidon \countline ())+" ligne de texte "+#endofparagraph+"je sais encore compter !!!",0)
; création de notre nouvelle méthode / routine
Procedure idontknow (*instance_textfile.textfile_class)
; insérer ici le nouveau code 
  ProcedureReturn @"Désolé mais la méthode countline n'habite plus à l'adresse indiquée !"
  EndProcedure
; comme le faisait les virus sous ms-dos avec la table des interruptions,
; nous allons transformer la table des méthodes de notre objet "textfile"
; pour que le pointeur *countline qui référence la méthode countline()
; prenne l'adresse de notre nouvelle procédure "Idontknow".

textfile_mthds\countline = @idontknow()
Debug PeekS (textebidon\countline ())
End
[code/]
Je ne m'atarderai pas sur cette dernière démonstration. J'espère en tout cas, Dayvid avoir répondu à ta question : "J'essaie de faire une fonction pour tout çà mais c'est pas encore au point".
Pour ceux qui auraient été séduit par cet objet ou "boîte à texte", je développe une série de macros qu'il faudra ajouter à la fin de "textfile.pbi". Ces macros permettront d'utiliser l'objet "textfile" comme une feuille de style. Cette feuille de style pourra être utilisée pour créer d'autres objets, dérivants de textfile.

[MLD]

Sacre bleu Je suis vert

[dayvid]

C'est toujours pour moi un plaisir de te lire car tes interventions me permettent de mettre en évidence des conceptes de programmations. Grâce à ces nouveaux conceptes, je retouche mes applications et bien souvent, elles sont plus fluïdes lors de leur exécutions, et le nombre d'erreur qu'elles renferment diminu.
Ici, par exemple, tu m'as permis, d'imaginer et de concevoir un objet ou appareil capable de manipuler plusieurs fichiers textes en même temps.
Trouvant cette idée intéressante, je me permet d'intervenir dans ce poste. J'essairai, d'être assez précis dans mes explications pour que vous, chers lecteurs, puissiez comprendre ce concepte, et utiliser, à votre tour, ce nouvel objet, qui j'espère, répondra à vos attentes !
Je tiens également à remercier Dräke, qui grâce à son tutoriel sur la programmation orientée objet en pure basic, m'a permis de mieux comprendre l'idée de pointeur, de structures, et m'a montré, comment, l'on pouvait les faire jouer ensembles pour créer des objets capables de se transformer, et créer des ensembles informatiques assez complexes, mais très puissants !
Mais au fait ! pourquoi je parle de "programmation orientée objet ?" Pour le savoir, il suffit de reprendre le code de Dayvid.
En effet, la procédure "fileoperation" peut être considérée comme une "boîte à outils" renfermant toutes les fonctions que tu as décrites plus haut. La variable "typeoperation$" permet d'indiquer au programme la tâche ou la méthode qu'il doit effectuer. En d'autres termes, l'outil qu'il doit utiliser.
Les autres paramètres de cette procédure peuvent être considérés comme des "membres" qui seront utilisés par les différentes méthodes de cette procédure.
On a donc bien un concept de programmation orientée objet. Le module "textfile.pbi" ci-dessous, décrit un objet appelé "textfile" capable de travailler avec des fichiers *.txt, et regroupant les différentes procédures que tu as développées ci-dessus.

Bonjour ricou 94

Merci, c'est un honneur de savoir que je t'es fait avencer même si mes codes sont très loins d'être optimiser
je regarde tous sa et te dis ce que j'en pense, merci a toi de partager t'es code !

Bonne continuation a toi et si tu veut faire un petit projet ensemble et si j'en suis capable, pourquoi pas !

[ricou 94]

Merci Dayvid, je suis tout à fait d'accord pour partager un projet ensemble. Par contre, je suis désolé pour mes balises de début ou de fin de code.

[dayvid]

Pas grave mais essaie de corriger tous sa, sa fera mieux je pense et enlève le double poste aussi

[Atlante]

Pas grave mais essaie de corriger tous sa, sa fera mieux je pense et enlève le double poste aussi

Pour le double post c'est fait.
Cordialement.

Atlante

[ricou 94]

Pas grave mais essaie de corriger tous sa, sa fera mieux je pense et enlève le double poste aussi

Pour le double post c'est fait.
Cordialement.

Atlante

Merci Atlante pour la correction ! encore désolé !

[dayvid]

J'ai regardé ça très vite fait, c'est pas mal malgrée que j'ai pas tous capter
bref, je vais voir pour crée une espèce de procedure pour tous rasembler quoique
je ne suis pas sur du résulta finale, je suis pas très bon là dans moi lol

Bon boulot en tous qu'a

Pourquoi utiliser des interface, je sais pas a quoi ça sert sa
et aussi le code witch ou un truc du genre

Tu veut bien si tu a le temps de me faire quelques exemple simple
pour piger comment ça marche, de mon coté si je peut t'aider malgrée mon niveau insertain en Pure Basic

A plus