Comportement surprenant avec Continue et Repeat Until #True

[Naheulf]

Bonjour,

Je viens de rencontrer un comportement qui me parait étrange avec le code (simplifié) suivant :

Code : Tout sélectionner

i = 0
Repeat ;
	If i < 10
		i+1         
		Continue
	EndIf
Until #True
Debug i ; Affiche 1

L'instruction "Continue" n'est-elle pas sensé passer à l'itération suivante en retournant au début de la boucle ?

[Marc56]

À mon avis, c'est normal:
Dans le cas d'une boucle Repeat/Until, l'instruction qui calcule la prochaine itération est à la fin.

i + 1 donc i = 1
Continue sort donc vers Until #True
et comme #True = 1 Terminé

[Ollivier]

Je pense que While... Wend réagit pareillement, donc :

Code : Tout sélectionner

Repeat
   ZapCc = 0
   ...
Until Cc And Not ZapCc

Cc = Code de condition de sortie
ZapCc = "zappe" la condition de sortie Cc
... = code multiligne activant ZapCc si besoin.

[Naheulf]

J'ai réglé ça avec un

Code : Tout sélectionner

i = 0
Repeat ;
   If i < 10
      i+1         
      Continue
   EndIf
   Break ; C'es con mais si je met un `Until #True` le `Continue` quitte aussi la boucle...
ForEver
Debug i ; Affiche 10

[Marc56]

C'est un peu compliqué
La "logique" consiste à dire "Laisser faire la boucle et quitter au besoin" avec Break

Code : Tout sélectionner

i = 0
Repeat 
    i + 1
    If i >= 10
        Break
    EndIf
ForEver

Debug i ; Affiche 10

Continue sert uniquement à sauter une partie de code et passer à l’itération suivante.
C'est ce qui est mis dans l'exemple.

Code : Tout sélectionner

For k=1 To 10
    If k=5
        Debug "- " + k
        Continue  ; N'affichera pas 5
    EndIf
    Debug k
Next

[Micoute]

J'aurais plutôt choisi une boucle While … Wend

[Naheulf]

Continue sert uniquement à sauter une partie de code et passer à l’itération suivante.

C'est ce que je fait dans mon code. (Le vrai, pas l'exemple bidon simplifié que j'ai mis plus haut.)

Code : Tout sélectionner

Procedure$ FichierSortie(Fichier$) ; Recherche d'un nom pour le fichier de sortie
	Protected Chemin$, Extention$, Suffixe$ = ""
	Protected LC_Ext$
	Chemin$ = GetPathPart(Fichier$)
	Fichier$ = GetFilePart(Fichier$)
	Repeat
		Extention$ = GetExtensionPart(Fichier$)
		Fichier$   = GetFilePart(Fichier$, #PB_FileSystem_NoExtension)
		LC_Ext$ = LCase(Extention$)
		If (LC_Ext$ = "gz") Or (LC_Ext$ = "zip") Or
		   (StrU(Val(Extention$)) = Extention$)
			Suffixe$ = "."+Extention$+Suffixe$
			Continue ; On n'as pas encore séparé toutes les extentions
		EndIf
		Break ; C'es con mais si je met un `Until #True` le `Continue` quitte aussi la boucle...
	ForEver
	
	If Extention$ <> ""
		Extention$ = "."+Extention$
	EndIf

	ProcedureReturn Chemin$+Fichier$+".clean"+Extention$+Suffixe$
EndProcedure

L'idée étant de rajouter une autre extention avant les extentions du fichier
"Fichier"-> "Fichier.clean"
"Fichier.log"->"Fichier.clean.log"
"Fichier.log.10" -> "Fichier.clean.log.10"
"Unfichier.avecdes.pointsdanslenom.log.gz" --> "Unfichier.avecdes.pointsdanslenom.clean.log.gz"

[MLD]

Bonjour Naheulf
Pour reprendre ton exemple j'aurais fait comme ceci:

Code : Tout sélectionner

i = 0
Repeat ;
   If i < 10
      i+1         
    Else
      Break
   EndIf
ForEver
Debug i ; Affiche 10

Mais chacun son truc

[Zorro]

@Nalleuf

excuse moi, je ne comprends pas le but de ta procedure
tu peux expliquer exactement ce que fait cette Procedure ??

je vois qu'elle prends un fichier... (un chemin de fichier ?) mais apres, je nage ton code me parait bien compliqué
pour peut etre pas grand chose ... ?

je ne comprends pas pourquoi il y a une boucle la dedans .....

ce serai bien d'informer un ignare .. Merci

[Mindphazer]

Il essaie d'ajouter un ".clean" juste avant l'extension du fichier....
Sauf que pour des extensions "doubles", du style .tar.gz, l'extension renvoyée par PB est .gz, alors que lui veut mettre son .clean avant .tar.gz

Enfin, c'est ce que j'ai cru comprendre.....

[Zorro]

ha ok , ... donc en fait il voulait faire ceci

Code : Tout sélectionner

Declare.s FichierSortie(Fichier$)

Fichier$="c:\toto\tutu\riri.tar.gz"
;Fichier$="c:\toto\tutu\riri.txt"
;Fichier$="toto"
Fichier$="Unfichier.avecdes.pointsdanslenom.log.gz"

debug FichierSortie(Fichier$)

; 
Procedure.s FichierSortie(Fichier$)		
		count.i=countstring(Fichier$,".")		
		if count.i=0
				ProcedureReturn fichier$+".clean"
		ElseIf count.i>0 and count.i<3 ; il y a au moins 1 point ou 2 ....
				Pos.i=findstring(Fichier$,".",1)
				extrait1.s=mid(Fichier$,1,pos.i)+"clean"
				extrait2.s=mid(Fichier$,pos.i,len(Fichier$))
				ProcedureReturn extrait1.s+extrait2.s
		ElseIf count.i>2 ;il y a plus de 2 points .. c'est quasi surement un nom avec des points dedans
				; ici prevoir les autres cas possible je me sert des extentions que tu as donné .. je ne sais pas si il peut y en avoir d'autres
				exten.s=".log,.tar" ; ici ajouter les extentions eventuelles séparées par une virgule
				For i=1 to countstring(exten.s,",")+1
						if FindString(Fichier$,StringField(exten.s,i,","),#PB_String_NoCase )
								pos.i=FindString(Fichier$,StringField(exten.s,i,","),#PB_String_NoCase)
								extrait1.s=mid(Fichier$,1,pos.i)+"clean"
								extrait2.s=mid(Fichier$,pos.i,len(Fichier$))
								Fichier$=extrait1.s+extrait2.s
						Endif
				Next i							
				ProcedureReturn Fichier$			
		Endif
EndProcedure

donc c'etait bien compliqué , comme je le pensais
mais je comprends ta boucle maintenant (je viens d'en ajouter une pour les extensions possibles)
les extensions de la variable chaine

Code : Tout sélectionner

exten.s=".log,.tar"

si trouvées auront "clean" d'ajouté avant)


[reedit]
je pense avoir couvert tout tes cas de figure maintenant

je crois qu'avec les REGEx on doit pouvoir faire nettement plus court

[Naheulf]

Il essaie d'ajouter un ".clean" juste avant l'extension du fichier....
Sauf que pour des extensions "doubles", du style .tar.gz, l'extension renvoyée par PB est .gz, alors que lui veut mettre son .clean avant .tar.gz

Enfin, c'est ce que j'ai cru comprendre.....

C'est exactement ça. Mais je préfère aussi m'attendre à des extension triples ou plus.

je crois qu'avec les REGEx on doit pouvoir faire nettement plus court

Oui à condition, si j'ai bien compris le fonctionnement des fonctions liées aux regex, de disposer des groupes de remplacement. Mais pour cela il faudrait mettre à jour PCRE vers PCRE2.

donc c'etait bien compliqué , comme je le pensais

Au début, je sépare l'emplacement et le nom du fichier pour soulager les traitements suivants. (Histoire de travailler avec des chaines plus petites).
Ensuite j'ai fait comme si le nom du fichier c'était une pile de cartes/d’extensions qua j'avais dans une main (Fichier$). Je regarde la dernière carte/extension. Si c'est bien une extension valide, je la mets dans l'autre main (Suffixe$). Et je recommence (d'ou le "continue" dans mon idée de départ) tant que j'ai des extensions.
Quand je n'en ai plus, je mets ma nouvelle carte/extension (".clean") au milieu et je rassemble le paquet.

Après, si c'est tordu de penser à un jeu de cartes et de vouloir coder les actions que l'on ferait à la main…

Remarque 1 : Le raisonnement fonctionne aussi avec des livres sur une étagère.
Remarque 2 : J'aurais aussi pu coder cette logique avec une boucle While, mais je n'aime pas avoir du code dupliqué entre l'extérieur et l'intérieur d'une boucle. Et j'avais prévu, au départ, de regrouper les extensions par "type" (texte, archive, morceau de fichier) dans différentes conditions ce qui rendait impossible l’utilisation de l'unique condition du while sans dupliquer la quasi-totalité de la boucle à l'extérieur de celle-ci…

[El Papounet]

Et pourquoi pas un truc du genre

Code : Tout sélectionner

Procedure.s FichierSortie(fichier.s)
    
    Protected.s extension
    Protected.s nouvelle_extension
    Protected.s path = GetPathPart(fichier)
    
    Repeat
        extension = GetExtensionPart(fichier)
        fichier = GetFilePart(fichier, #PB_FileSystem_NoExtension)
        If extension
            nouvelle_extension = "." + extension + nouvelle_extension
            
        EndIf
        Select LCase(nouvelle_extension)
            Case ".tar.gz", ".log.zip", ".log.txt"; ...
                Break
                
        EndSelect
        
    Until extension = ""
    ProcedureReturn path + fichier + ".clean" + nouvelle_extension
    
EndProcedure


Debug FichierSortie("Fichier")
Debug FichierSortie("C:\Test\Fichier.log")
Debug FichierSortie("Fichier.log.10")
Debug FichierSortie("Fichier.log.gz")
Debug FichierSortie("Fichier.tar.gz")
Debug FichierSortie("Unfichier.avecdes.pointsdanslenom.log.gz")
Debug FichierSortie("Unfichier.avecdes.pointsdanslenom.log.zip")
Debug FichierSortie("Unfichier.avec.des.points.dans.le.nom.log.txt")

[Naheulf]

Et pourquoi pas un truc du genre

Vendu !

Je n'avais pas pensé à vérifier que l’extension était une chaîne vide pour quitter la boucle. Du coup ça donne :

Code : Tout sélectionner

Procedure$ FichierSortie(Fichier$) ; Recherche d'un nom pour le fichier de sortie
	Protected Chemin$, Extention$, Suffixe$ = ""
	
	Chemin$ = GetPathPart(Fichier$) ; On sépare l'emplacement pour soulager les traitements qui suivent
	Fichier$ = GetFilePart(Fichier$)
	
	Repeat
		Extention$ = GetExtensionPart(Fichier$)
		Fichier$   = GetFilePart(Fichier$, #PB_FileSystem_NoExtension)
		
		Select LCase(Extention$)
			Case "log", "txt" ; Logs textuels
				Suffixe$ = "." + Extention$ + Suffixe$
				
			Case "tar", "gz", "zip", "7z" ; Logs compressés
				Suffixe$ = "." + Extention$ + Suffixe$
				
			Default
				If (StrU(Val(Extention$)) = Extention$); N-ième fichier du même nom (entier base dix)
					Suffixe$ = "." + Extention$ + Suffixe$
					
				ElseIf Extention$ <> "" ; Extention non reconnue : Fait partie du nom du fichier
					Fichier$ = Fichier$ + "." + Extention$
					Extention$ = ""
				EndIf
		EndSelect
	Until Extention$ = ""

	ProcedureReturn Chemin$+Fichier$+".clean"+Suffixe$
EndProcedure

[Zorro]

note quand meme que ma version fonctionne aussi tres bien