Utilisation de "type" pour créer des enreg d'un fichier texte
5 réponses
Cage à lapins
Je dois écrire dans un fichier texte des enregistrements de longueur fixe
dont les données sont les unes derrière les autres sans séparateur.
J'ai créé une structure avec l'instruction "type" en tête du module
Type Enreg
donnee01 as string * 8
donnee02 as string * 12
...
P30_donnee72 as string * 25
end type
et une proc pour la création des enregistrements
Sub Creer_enreg()
Dim P30 as Enreg
Dim fs, Fichier
'Ouvrir le fichier
Set fs = CreateObject("Scripting.FileSystemObject")
Set Fichier = fs.CreateTextFile("c:\P30_test.txt", True)
'Renseigner les données de l'enreg
P30.donnee01 = toto
....
P30.donnee72 = titi
'Ecrire l'enregistrement
Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics
définis par l'utilisateur dans les modules objet publics peuvent être
utilisés comme paramètres ou types renvoyés pour les procédures publiques des
modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une
Fichier.Write(P30.Donnee01)
Fichier.Write(P30.Donnee02)
...
Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini
avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de
l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72
données une par une ?
N'utilisant généralement pas ni les modules de classes ni les 'type', je suis allé me renseigner sure : http://www.info-3000.com/vbvba/modulesdeclasse.php (D'ailleurs, j'ai compris que j'utiliserai désormais ces outils)
Je ne vois pas en quoi, dans 'Fichier.WriteLine (P30)', pourquoi P30 serait une concaténation de P30.* ???
Pour moi, ce qui se rapproche le plus de ta problématique serait de mettre une procédure de concaténation dans un module de classe.
Sur l'URL indiqué, ca ressembelerait à l'exmple qui trouve 'Je met des nappes en papier rouges avec une bougie'
Bon courage,
Poulpor.
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateur. J'ai créé une structure avec l'instruction "type" en tête du module Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics définis par l'utilisateur dans les modules objet publics peuvent être utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Bonjour,
N'utilisant généralement pas ni les modules de classes ni les 'type', je
suis allé me renseigner sure :
http://www.info-3000.com/vbvba/modulesdeclasse.php
(D'ailleurs, j'ai compris que j'utiliserai désormais ces outils)
Je ne vois pas en quoi, dans 'Fichier.WriteLine (P30)', pourquoi P30 serait
une concaténation de P30.* ???
Pour moi, ce qui se rapproche le plus de ta problématique serait de mettre
une procédure de concaténation dans un module de classe.
Sur l'URL indiqué, ca ressembelerait à l'exmple qui trouve 'Je met des
nappes en papier rouges avec une bougie'
Bon courage,
Poulpor.
Je dois écrire dans un fichier texte des enregistrements de longueur fixe
dont les données sont les unes derrière les autres sans séparateur.
J'ai créé une structure avec l'instruction "type" en tête du module
Type Enreg
donnee01 as string * 8
donnee02 as string * 12
...
P30_donnee72 as string * 25
end type
et une proc pour la création des enregistrements
Sub Creer_enreg()
Dim P30 as Enreg
Dim fs, Fichier
'Ouvrir le fichier
Set fs = CreateObject("Scripting.FileSystemObject")
Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg
P30.donnee01 = toto
....
P30.donnee72 = titi
'Ecrire l'enregistrement
Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics
définis par l'utilisateur dans les modules objet publics peuvent être
utilisés comme paramètres ou types renvoyés pour les procédures publiques des
modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une
Fichier.Write(P30.Donnee01)
Fichier.Write(P30.Donnee02)
...
Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini
avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de
l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72
données une par une ?
N'utilisant généralement pas ni les modules de classes ni les 'type', je suis allé me renseigner sure : http://www.info-3000.com/vbvba/modulesdeclasse.php (D'ailleurs, j'ai compris que j'utiliserai désormais ces outils)
Je ne vois pas en quoi, dans 'Fichier.WriteLine (P30)', pourquoi P30 serait une concaténation de P30.* ???
Pour moi, ce qui se rapproche le plus de ta problématique serait de mettre une procédure de concaténation dans un module de classe.
Sur l'URL indiqué, ca ressembelerait à l'exmple qui trouve 'Je met des nappes en papier rouges avec une bougie'
Bon courage,
Poulpor.
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateur. J'ai créé une structure avec l'instruction "type" en tête du module Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics définis par l'utilisateur dans les modules objet publics peuvent être utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Cage à lapins
Bonjour,
Effectivement le lien emmène sur une page qui explique bien l'usage des modules de classe. Je me suis surtout aperçu que l'instruction type ne permettait pas de déclarer une structure (comme on peut le faire en COBOL ou en PL1) mais plutôt un objet.
A ce stade, la seule solution (que j'utilise type, un module de classe, ou aucun de ces 2 objets) consistera malgré tout à écrire mes 72 données individuellement pour produire un enregistrement contenant toutes mes données.
Merci car même si mon problème initial n'est pas réglé (un seul write pour écrire toutes mes données) j'ai mieux compris à quoi servait l'instruction "type" et surtout qu'elle ne servait pas à faire ce que je cherchais.
Cdlt Marc
Bonjour,
Effectivement le lien emmène sur une page qui explique bien l'usage des
modules de classe. Je me suis surtout aperçu que l'instruction type ne
permettait pas de déclarer une structure (comme on peut le faire en COBOL ou
en PL1) mais plutôt un objet.
A ce stade, la seule solution (que j'utilise type, un module de classe, ou
aucun de ces 2 objets) consistera malgré tout à écrire mes 72 données
individuellement pour produire un enregistrement contenant toutes mes données.
Merci car même si mon problème initial n'est pas réglé (un seul write pour
écrire toutes mes données) j'ai mieux compris à quoi servait l'instruction
"type" et surtout qu'elle ne servait pas à faire ce que je cherchais.
Effectivement le lien emmène sur une page qui explique bien l'usage des modules de classe. Je me suis surtout aperçu que l'instruction type ne permettait pas de déclarer une structure (comme on peut le faire en COBOL ou en PL1) mais plutôt un objet.
A ce stade, la seule solution (que j'utilise type, un module de classe, ou aucun de ces 2 objets) consistera malgré tout à écrire mes 72 données individuellement pour produire un enregistrement contenant toutes mes données.
Merci car même si mon problème initial n'est pas réglé (un seul write pour écrire toutes mes données) j'ai mieux compris à quoi servait l'instruction "type" et surtout qu'elle ne servait pas à faire ce que je cherchais.
Cdlt Marc
JLuc
Cage à lapins avait soumis l'idée :
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateur. J'ai créé une structure avec l'instruction "type" en tête du module Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics définis par l'utilisateur dans les modules objet publics peuvent être utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Et si tu passais tout simplement par un tableau ? Dim P30(72)As String P30(1) = "Toto" ... P30(72) = "Titi"
For x = 1 To 72 Fichier.WriteLine(P30(x)) Next
-- JLuc
Cage à lapins avait soumis l'idée :
Je dois écrire dans un fichier texte des enregistrements de longueur fixe
dont les données sont les unes derrière les autres sans séparateur.
J'ai créé une structure avec l'instruction "type" en tête du module
Type Enreg
donnee01 as string * 8
donnee02 as string * 12
...
P30_donnee72 as string * 25
end type
et une proc pour la création des enregistrements
Sub Creer_enreg()
Dim P30 as Enreg
Dim fs, Fichier
'Ouvrir le fichier
Set fs = CreateObject("Scripting.FileSystemObject")
Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg
P30.donnee01 = toto
....
P30.donnee72 = titi
'Ecrire l'enregistrement
Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics
définis par l'utilisateur dans les modules objet publics peuvent être
utilisés comme paramètres ou types renvoyés pour les procédures publiques des
modules de classe ou comme champs des types publics définis par
l'utilisateur"
La solution est d'écrire les données une par une
Fichier.Write(P30.Donnee01)
Fichier.Write(P30.Donnee02)
...
Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini
avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de
l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72
données une par une ?
Et si tu passais tout simplement par un tableau ?
Dim P30(72)As String
P30(1) = "Toto"
...
P30(72) = "Titi"
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateur. J'ai créé une structure avec l'instruction "type" en tête du module Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types publics définis par l'utilisateur dans les modules objet publics peuvent être utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Et si tu passais tout simplement par un tableau ? Dim P30(72)As String P30(1) = "Toto" ... P30(72) = "Titi"
For x = 1 To 72 Fichier.WriteLine(P30(x)) Next
-- JLuc
Tschuß
Attends Cage à Lapin, ne déprime pas encore ! J'ai fait un pgm qui répond exactement à ton pb et j'ai aussi utilisé la déclaration TYPE un peu comme du Cobol et sans module de classe.
' Dabord je crée ma structure de fichier en sortie puis j'affecte mon type à une nouvelle variable
Public Type Format_Sortie Num_Ano As String * 4 Lib_Ano As String * 30 Num_Dossier As String * 9 Fin_Fichier As String * 2 End Type
Public Enregistrement As Format_Sortie
'Tu ouvres tes fichiers en respectant SCRUPULEUSEMENT ta longueur (sinon, c'est le bordel assuré). Le + 2 à la fin c'est pour le saut de ligne de mon fichier en entrée.
En lecture Open "fichier_lu.txt" For Random Access Read As #1 Len = Len("fichier_lu.txt") + 2
En écriture Open "fichier_ecrit.txt" For Random Access Write As #100 Len = 45
'Alors ensuite dans ta boucle qui alimente ton fichier tu écris ta procédure d'alimentation comme suit
Le seul vrai problème c'est d'ouvrir correctement ton fichier en entrée en respectant la bonne longueur
++
Cage à lapins avait soumis l'idée :
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateu r. J'ai créé une structure avec l'instruction "type" en tête du modu le Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types pu blics définis par l'utilisateur dans les modules objet publics peuvent êt re utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Et si tu passais tout simplement par un tableau ? Dim P30(72)As String P30(1) = "Toto" ... P30(72) = "Titi"
For x = 1 To 72 Fichier.WriteLine(P30(x)) Next
-- JLuc
Attends Cage à Lapin, ne déprime pas encore !
J'ai fait un pgm qui répond exactement à ton pb et j'ai aussi
utilisé la déclaration TYPE un peu comme du Cobol et sans module de
classe.
' Dabord je crée ma structure de fichier en sortie puis j'affecte mon
type à une nouvelle variable
Public Type Format_Sortie
Num_Ano As String * 4
Lib_Ano As String * 30
Num_Dossier As String * 9
Fin_Fichier As String * 2
End Type
Public Enregistrement As Format_Sortie
'Tu ouvres tes fichiers en respectant SCRUPULEUSEMENT ta longueur
(sinon, c'est le bordel assuré). Le + 2 à la fin c'est pour le saut
de ligne de mon fichier en entrée.
En lecture
Open "fichier_lu.txt" For Random Access Read As #1 Len =
Len("fichier_lu.txt") + 2
En écriture
Open "fichier_ecrit.txt" For Random Access Write As #100 Len = 45
'Alors ensuite dans ta boucle qui alimente ton fichier tu écris ta
procédure d'alimentation comme suit
Le seul vrai problème c'est d'ouvrir correctement ton fichier en
entrée en respectant la bonne longueur
++
Cage à lapins avait soumis l'idée :
Je dois écrire dans un fichier texte des enregistrements de longueur fixe
dont les données sont les unes derrière les autres sans séparateu r.
J'ai créé une structure avec l'instruction "type" en tête du modu le
Type Enreg
donnee01 as string * 8
donnee02 as string * 12
...
P30_donnee72 as string * 25
end type
et une proc pour la création des enregistrements
Sub Creer_enreg()
Dim P30 as Enreg
Dim fs, Fichier
'Ouvrir le fichier
Set fs = CreateObject("Scripting.FileSystemObject")
Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg
P30.donnee01 = toto
....
P30.donnee72 = titi
'Ecrire l'enregistrement
Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types pu blics
définis par l'utilisateur dans les modules objet publics peuvent êt re
utilisés comme paramètres ou types renvoyés pour les procédures publiques des
modules de classe ou comme champs des types publics définis par
l'utilisateur"
La solution est d'écrire les données une par une
Fichier.Write(P30.Donnee01)
Fichier.Write(P30.Donnee02)
...
Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini
avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de
l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72
données une par une ?
Et si tu passais tout simplement par un tableau ?
Dim P30(72)As String
P30(1) = "Toto"
...
P30(72) = "Titi"
Attends Cage à Lapin, ne déprime pas encore ! J'ai fait un pgm qui répond exactement à ton pb et j'ai aussi utilisé la déclaration TYPE un peu comme du Cobol et sans module de classe.
' Dabord je crée ma structure de fichier en sortie puis j'affecte mon type à une nouvelle variable
Public Type Format_Sortie Num_Ano As String * 4 Lib_Ano As String * 30 Num_Dossier As String * 9 Fin_Fichier As String * 2 End Type
Public Enregistrement As Format_Sortie
'Tu ouvres tes fichiers en respectant SCRUPULEUSEMENT ta longueur (sinon, c'est le bordel assuré). Le + 2 à la fin c'est pour le saut de ligne de mon fichier en entrée.
En lecture Open "fichier_lu.txt" For Random Access Read As #1 Len = Len("fichier_lu.txt") + 2
En écriture Open "fichier_ecrit.txt" For Random Access Write As #100 Len = 45
'Alors ensuite dans ta boucle qui alimente ton fichier tu écris ta procédure d'alimentation comme suit
Le seul vrai problème c'est d'ouvrir correctement ton fichier en entrée en respectant la bonne longueur
++
Cage à lapins avait soumis l'idée :
Je dois écrire dans un fichier texte des enregistrements de longueur fixe dont les données sont les unes derrière les autres sans séparateu r. J'ai créé une structure avec l'instruction "type" en tête du modu le Type Enreg donnee01 as string * 8 donnee02 as string * 12 ... P30_donnee72 as string * 25 end type
et une proc pour la création des enregistrements Sub Creer_enreg() Dim P30 as Enreg Dim fs, Fichier
'Ouvrir le fichier Set fs = CreateObject("Scripting.FileSystemObject") Set Fichier = fs.CreateTextFile("c:P30_test.txt", True)
'Renseigner les données de l'enreg P30.donnee01 = toto .... P30.donnee72 = titi
'Ecrire l'enregistrement Fichier.WriteLine (P30)
Mais la compilation génère le message suivant : "Seuls les types pu blics définis par l'utilisateur dans les modules objet publics peuvent êt re utilisés comme paramètres ou types renvoyés pour les procédures publiques des modules de classe ou comme champs des types publics définis par l'utilisateur"
La solution est d'écrire les données une par une Fichier.Write(P30.Donnee01) Fichier.Write(P30.Donnee02) ... Fichier.WrtiteLine(P30.Donnee72)
J'obtiens bien le résultat attendu mais l'utilisation de la structure défini avec "Type" ne présente plus trop d'intérêt.
Est-ce que quelqu'un aurait une solution pour générer l'écriture de l'enregistrement complet de façon moins fastidieuse qu'en écrivant les 72 données une par une ?
Et si tu passais tout simplement par un tableau ? Dim P30(72)As String P30(1) = "Toto" ... P30(72) = "Titi"
