for to next

C'est un truc tout simple, mais ce n'est pas normal :
quand on fait :
for i=1 to x : instruction : next i
si x>1, il exécute l'instruction x fois, ce qui est normal,
si x=1, il exécute l'instruction 1 fois, ce qui est encore normal, mais
si x=0, il exécute l'instruction 1 fois, alors qu'il devrait le faire zéro fois.

J'avais déjà constaté celà, et je ne savais pas si c'était normal ou non, en pensant qu'il fallait arriver à next pour faire le teste.
Comme je ne sais pas si il existe une norme sur une instruction, j'en suis resté là. Lorsqu'on connait le problème, alors je mets un teste: if x=0 then exit_next. Ce qui est normal ou non, je ne le connait pas. Le mieux est je pense est de le préciser dans le manuel, pour le cas où pour l'auteur ceci est son fonctionnement.

Je rajoute: je pensais la chose normal, parce que on pourrait penser que for et to, le programme prend ses informations, et c'est une fois qu'il arrive à next qu'il teste. Où est le vrai?

Effectivement, le test de rebouclage est effectué au NEXT, et c'est là qu'il se rend compte que x est inférieur à i.
Je modifierai la documentation.

Dans ce cas, si x est inférieur à i, on utilise STEP -1:
FOR i=1 TO x STEP -1

J'aurai bien aimé qu'il existe une norme BASIC.
Pourquoi ne la ferions nous pas, à l'image de la norme ADA ?

Mais je pense qu'il n'y aura pas beaucoup de volontaires...

Jack, je ne suis pas d'accord avec toi. Lorsque l'on met STEP-1, c'est pour décompter, et non compter. Là il s'agit de ne pas faire la boucle lorsque la valeur de TO est inférieur à celle de FOR. On peut considérer qu'il puisse il avoir un problème de programmation dans l'utilisation de FOR NEXT.
@+
Pour ce qui est de faire ou ne pas faire la boucle, c'est un peu le cahier des charges qu'on se donne. Il y a des basics qui font pas la boucle, et d'autre qui le font.

Pour ma part ,je met :
if x>0 "Boucle for next" end_if de façon à sauter la boucle si x=0

Citation :

J'aurai bien aimé qu'il existe une norme BASIC.
Pourquoi ne la ferions nous pas, à l'image de la norme ADA ?

Je ne vois pas de quoi il s''agit.


Ce que je peux dire, c'est que j'ai des problèmes assez souvent avec des boucles for/next, dans le cas ou FOR est < à TO. En cela, je rejoins COSMOS70. Mais peut-être s'agit-il d'une méconnaissance de cette fonction dans le cas de programmation avec objet. Une chose est certainne je n'ai jamais eu de souci, avec QB, pour cette instruction.

Je ne vois pas trop où est le problème avec les boucles, dans un sens ou dans l'autre:
FOR x = 1 TO 10
ou bien:
FOR x = 10 TO 1 STEP -1
dans le 1er cas, le step est implicitement 1 mais on peut mettre ce qu'on veut (positif)
dans le second, le step est obligatoire avec une valeur négative.

Et on peut très bien passer par la valeur 0:
FOR x = 10 TO -10 STEP -1

L'exemple de Jack est un peu ambigü (ou bien c'est un lapsus)
si x<i : FOR i = 1 TO x STEP -1
J'aurais écrit si x<y: FOR i = y TO x STEP -1 (ou -2, ou -0.5 etc)

Supposons qu'on ait une liste de 20 éléments dans des fichiers texte.
On veut changer un de ces éléments,
on recopie les éléments qui précèdent, on change l'élément et on recopie ceux qui suivent :
for i=1 to k-1 (k=position de l'élément) : on recopie
file_writeln... on change l'élément k
for i=k+1 to 20 : on recopie

Très bien si k=3 (par exemple)
for i=1 to 2 (3-1=2):...
file_writeln...
for i=4 (3+1=4) to 20:...

Mais si c'est le premier élément qu'on veut changer (k=1), cela donne :
for i=1 to 0 (1-1=0) :...
file_writeln...
for i=2 (1+1=2) to 20 :...
(et on ne peut pas mettre step -1 puisqu'on est, en principe, dans une croissance positive)

Oh, il y a des solutions !
On peut mettre :
for i=1 to k-1
if k-1>1 then...
On peut aussi faire :
if k-1>1
j=1
else
j=-1
end_if
for i=1 to k-1 step j
...
Mais c'est quand même un peu scabreux
que ça ne boucle pas dans le cas de : for i=1 to 0, ce serait quand même mieux.

Non, le seul problème avec FOR/NEXT est celui que souligne jjn4 dans le cas où dès le départ de boucle, pour être logique, celle-ci ne devrait pas se faire, vu que la variable à atteindre est dès le début inférieur à celle de départ. Dans la conception d'un programme, le cas de figure peut se produire lorsqu'on utilise des variables comme référence, et non des nombres.

Je connais des basics qui ne font pas la boucle. Mais rien ne précise quelque part que ce principe d'éviter la boucle dans ce cas, est obligatoire. Jack a le droit de dire que c'est NEXT qui va faire le tri ou le teste comme tu veux. Jack que ne m'en déplaise est très stricte dans ce genre d'instruction et n'aime pas laisser de marge comme c'est le cas avec MID$(, où il n'accepte pas que le 3ème paramètre soit absent.

Certaines instructions comme FOR/NEXT n'est pas trop génant, il suffit de mettre un simple teste juste après la 1ère ligne, par contre le désavantage qu'on a comme MID$() oblige une complication importante du code, et dans les boucles ralentient l'exécution du programme, et c'est bien dommage.

Il ne faut pas oublier que plus il y a d'instructions dans un code pour faire par exemple une boucle, plus il y a perte de temps, alors que si les possibilités sont données d'éviter ses suppléments de code, on gagne du temps.

Certes un/deux ou trois testes supplémentaires dans la conception d'une instruction, augmentent l'exécution de cette instruction, mais gagne au combien en temps sur l'emploie des instructions complémentaires dans nos propres sources.

Je comprends vu le travail, qu'il faut aller vite et avancer pour que le basic est le maximum de commandes afin que Panoramique puisse être au rang des autres basics. A part quelques trous comme dans les fichiers et l'impression (pour ne citer que cela), on y arrive presque. Peut-être qu'ensuite Jack reverra les instructions qu'on aimerait voir corrigées.

Je viens de voir ton post, mais il n'y a rien à rajouter.

@JJN4, et....

Je précise que justement c'est avec la gestion de fichier que je m'enmêle les pinceaux. Alors maintenant, le plus souvent, je balance le fichier dans un DLIST et je travaille le fichier avec COUNT.

Code:

dlist 10
n10=count(10)
for n=1 to n10
' ...........
next n

Et il arrive de temps en temps d'être obligé d'écrire for n=1 to (n10-1) pour que çà passe

A+