auto bug

Je me suis bugger tout seul.
J'ai ecrit ceci :

Code:

 dim k$,d$,d2$,d3$
 dim k%
 dim ligne,ligne$
 k$=";"

 dlist 1
 file_load 1,"Monfichier.txt"
 for ligne= 1 to count(1)
 
 rem 'Détermination de la position du separateur
 
 ligne$=item_read$(1,ligne)
 K%=instr(ligne$,k$)
 
 rem 'Capture de la première donnée

 d$=left$(ligne$,k%-1)
 print "Ligne n°: "+str$(ligne)
 print d$

 rem 'Capture de la seconde donnée
 
 ligne$ = MID$(ligne$, k% + 1, LEN(ligne$) - k%)
 d2$=left$(ligne$,k%-1)
 ligne$ = MID$(ligne$, k% + 1, LEN(ligne$) - k%)
 d3$=left$(ligne$,k%-1)
 print d2$
 print d3$
 next ligne

puis j'ai voulu utiliser ce bout de code avec un autre fichier .txt
et là c'est le bug:

Code:

dim ligne,ligne$,k$,k%,d$,d2$,d3$,d4$,d5$,d6$,d7$

 
 dlist 118
 file_load 118,"Bases\effectif.txt"
 
 for ligne= 1 to count(118)
 ligne$=item_read$(118,ligne)
 k$="/"
 K%=instr(ligne$,k$)
 d$=left$(ligne$,k%-1)
 print d$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d2$=left$(ligne$,k%-1)
 print d2$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d3$=left$(ligne$,k%-1)
 print d3$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d4$=left$(ligne$,k%-1)
 print d4$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d5$=left$(ligne$,k%-1)
 print d5$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d6$=left$(ligne$,k%-1)
 print d6$
 ligne$=MID$(ligne$,k% +1,LEN(ligne$)-k%)
 d7$=left$(ligne$,k%-1)
 print d7$
 if item_index$(100)=d$
 text 109,d$:text 110,d2$:text 111,d3$:text 112,d4$:text 113,d5$:text 114,d6$
 text 115,d7$
 end_if
 next ligne

dans le deuxième cas la variable "k%" bloque sur sa première valeur
ce qui me donne une erreur de type incorrect string call value 0 ou inferieure

Un truc qui me choque dans ton code

Code:

K%=instr(ligne$,k$)

K% n'est pas un string($), si je ne me trompe pas.

A+

Eh JC, normal, K% est un entier (on recherche la position de k$ dans ligne$)

Autant pour moi, c'est une instruction dont je ne me sert pas. J'ai surement tord. il me faudrait un exemple concret pour comprendre la finalité de cette commande. Mais pas ici.

Code:

K%=instr(ligne$,k$)

k% position dans la ligne "ligne$" de "k$" le separateur

en fait je demande à mon prog le nombre de caractere de la ligne
puis je lui demande de retrouver la position de mon separateur
puis de me renvoyer la donnée placée avant ce separateur.

ensuite, je lui demande de relire la même ligne en prenant pour point de depart le separateur avec la même suite pour extraire la deuxième donnée de cette ligne.

et ainsi de suite

Salut,

Je fais souvent ce genre d'analyse de strings, mais je n'hésite pas à modifier ma variable en entrée, comme ceci:

Code:

label fruit
dim i%,a$ b$,f$
a$ = "pommes,bananes,cerises,abricots,fraises"

b$ = a$
i% = instr(b$,",")
while i%>0
    f$ = left$(b$,i%-1)
    gosub fruit
    b$ = right$(b$,len(b$)-i%)
    i% = instr(b$,",")
end_while
f$ = b$
gosub fruit
end

fruit:
message "fruit trouvé: " + f$
return

De cette manière, tu peux facilement prendre un élément après l'autre pour le traiter, tout en gardant ta ligne initiale (a$) intacte.

Ca fait intervenir des variables supplémentaires, mais on ne peut pas faire autrement. Comme je dis ailleurs, c'est dommage qu'on n'ait pas un Instr avec en paramètre la position de départ, pour faire plus simplement des recherches successives dans la même chaîne.

Merci je regarde cela a tete reposé

j'utilise maintenant une autre façon (ce n'est valable que si le nombre d'éléments est limité)
par exemple :
nom,prénom,age,date de naissance
par programme je fais:

Code:

dim a$,age$
font_size 0,14
a$="nom"+chr$(1)+"prénom"+chr$(2)+"age"+chr$(3)+"date de naissance"
age$=mid$(a$, instr(a$,chr$(2))+1 , instr(a$,chr$(3)) - instr(a$,chr$(2))-1)
print age$

Cela fait un peu charabia, mais n'utilise qu'une ligne avec un minimum de code pour saisir une partie d'un string.
Là, je pense que je peux me cacher.

Pourquoi de cacher ? Toute astuce est bonne à prendre ! Et je dois dire que je n'avais pas pensé au coup des separteurs différents pour chaque partie du code.

Comme tu dis, ça devient vite galère sile nombre de parties augmente. Mais bien plus important: évite d'écrire ce genre de strings dans un fichier texte - tu risques d'avoir des surprises. Si tu l'écris dans un fichier, il fait le faire en binaire, et le relire en binaire - ce qui pose d'autres problèmes abev des strings par nature en longueur variable.

Si ces informations doivent être mémorisées dans un fichier texte, mieux vaut s'en tenir à un séparateur unique dans le domaine des catactères de valeur ASCII entre 32 et 127 (sans entrer en conflit avec les textes à mémoriser).

Sinon, une solution qui a déjà été mentionnée ailleurs (je ne me rappelle plus par qui, on me le pardonnera): écris chaque u=information sur une ligne séparée, SANS séparateur de texte, et termine un ensemble d'éléments par une ligne particulière, par exemple une ligne vide ou une ligne contenant "*** fin ensemble ***".

Le code pour gérer cela est ultra-simple.

C'est bien joli, mais ce n'est valable que si on est maître de la mise en forme, c'est à dire si on est le créateur ET l'utilisateur du fichier.
Pour étudier un fichier externe il faut bien passer par le instr.
Et comme dit Klaus, les caractères inférieurs à 32 peuvent réserver des surprises dans les fichiers textes.

Je reprends ta réponse. Les séparateurs peuvent être écris si tu évite le 0, le 10 et le 13 et le 9 aussi, mais ne pose pas de problèmes pour ceux que je propose, il sont sauvegardé normalement ou relu dans un mémo, seul l'affichage du caractère selon la fonte, est différent. Ce type de codage se fait par programme et n'est pas fait pour être écris directement à partir d'un éditeur, d'un mémo ou autre quelconque.
Tu remplis par exemple un 'tableur" (pour simplifier l'explication), tu relève chaque info, et tu les mets en chaine. C'est comme cela que je vois le truc.
A bientôt

Je reconnais bien volontiers que c'est une solution, mais pas très universelle.

Bon, sur ce, bonne nuit !