TantQue

Répète la logique tant que la condition est vraie, puis renvoie le résultat.

Format 

TantQue ( [ variableInitiale ] ; condition ; [ logique ] ; résultat )

Paramètres 

variableInitiale : définitions de variables qui pourront être utilisées dans les paramètres suivants.

condition : une expression booléenne évaluée avant chaque itération de boucle. Tant que la condition est vraie, la boucle se répète. Lorsqu'elle est fausse, la boucle s'arrête.

logique : définitions de variables qui sont évaluées chaque fois que la boucle est répétée.

résultat : une expression qui est renvoyée lorsque la boucle s'arrête.

Résultat 

Texte, nombre, date, heure, horodatage, conteneur

Provient de la version 

18.0

Description 

La fonction TantQue effectue les étapes ci-après :

  1. Evalue le paramètre variableInitiale.

  2. Evalue le paramètre condition.

  3. Si condition est :

    • Vrai (résultat numérique différent de zéro), évalue la logique, puis répète l'étape 2.

    • Faux (0) arrête la boucle et renvoie le résultat.

Vous pouvez spécifier plusieurs définitions de variables pour les paramètres variableInitiale et logique en les plaçant entre crochets [ ] et en les séparant chacune par un point-virgule. Par exemple :

Copier 
TantQue ( 
    [ varInit1 = valeur1 ; varInit2 = valeur2 ; ...] ; 
    condition ; 
    [ varlogique1 = expression1 ; varlogique2 = expression2 ; ...] ; 
    résultat 
)

Les variables spécifiées dans les paramètres variableInitiale et logique sont évaluées de gauche à droite. Ces variables ont la même portée et peuvent être utilisées dans les paramètres condition et résultat. Consultez la section Utilisation de variables.

Les variables qui doivent conserver les informations d'une itération de boucle à l'autre doivent être initialisées avant d'être utilisées dans le paramètre logique. Sinon, leurs valeurs sont supprimées.

Remarques 

  • Pour éviter les boucles infinies qui empêcheraient les clients FileMaker Pro de répondre, cette fonction envoie « ? » lorsque le nombre d'itérations de boucle dépasse la limite spécifiée. Pour définir cette limite, utilisez la fonction DefinirRecursion.

Exemple 1 

Renvoie le résultat de 5 à la puissance 3. L'instruction Definir établit la valeur initiale de 5 et la puissance sur 3. Le calcul effectue plusieurs boucles jusqu'à obtenir le résultat 5 * 5 * 5 = 125.

Copier 
Definir ( 
    [
        valeur = 5 ;
        puissance = 3
    ] ;
    TantQue (
        [ résultat = valeur ; i = 1 ] ;
        i < puissance ;
        [ i = i + 1 ; résultat = résultat * valeur ] ;
        résultat
    )
)

Exemple 2 

Totalise les valeurs de répétition de la variable $a. Chaque itération de boucle incrémente le Decompte, l'utilise pour spécifier la répétition de la variable $a et ajoute la valeur au Total cumulé. Cet exemple renvoie 150.

Copier 
TantQue ( 
    [ 
        Decompte = 0 ; 
        Total = 0 ; 
        $a[1] = 25 ; 
        $a[2] = 50 ; 
        $a[3] = 75 
    ] ; 
    Decompte < 3 ; 
    [
        Decompte = Decompte + 1 ; 
        Total = Total + $a[Decompte]
    ] ;
    Total
)

Exemple 3 

Ajoute cinq points entre deux valeurs de texte. La portée de la variable de fonction Ville dans la fonction TantQue est séparée de celle dans la fonction Definir. Cet exemple renvoie San Francisco.....Paris.

Copier 
Definir (
    Ville = "Paris";
    TantQue ( 
        [ Ville = "San Francisco"; i = 0 ] ; 
        i < 5 ;
        [
            i = i + 1 ;
            Ville = Ville & "."
        ] ; 
        Ville
    )
& Ville )

Si chaque instance de la variable de fonction Ville a été remplacée par la variable locale $Ville, cet exemple renvoie San Francisco.....San Francisco....., car $Ville a la même portée dans le calcul.

Exemple 4 

Illustre comment la portée des variables de fonction diffère lorsqu'elles sont définies avant une boucle TantQue par rapport à celle des variables définies dans les paramètres variableInitiale et logique de la boucle TantQue.

Les valeurs de it1 et it2 définies avant la boucle TantQue sont disponibles dans la boucle, mais les modifications apportées à it1 et it2 dans la boucle n'affectent pas les valeurs de ces variables après la boucle. Cet exemple indique également comment la valeur 2 de la variable it2 définie dans le paramètre logique est perdue après chaque itération de boucle, car la variable it2 n'est pas initialisée dans le paramètre variableInitiale.

Copier 
Definir (
    [ // Avant la boucle TantQue; définit la ligne 1.0 du résultat
        it1 = "a"; // Définie dans la portée de la fonction Definir
        it2 = 1; // Définie dans la portée de la fonction Definir
        résultat = "1.0 " & it1 & " " & it2 & ¶
    ];
    TantQue
    (
        [ // variablesInitiales; définit les lignes 2.0 et 3.0 du résultat
            i = 0;
            résultat = résultat & "2.0 " & it1 & " " & it2 & ¶;
            it1 = "b"; // Définie dans la portée de la fonction TantQue
            résultat = résultat & "3.0 " & it1 & " " & it2 & ¶
        ];
        // Condition
        i < 2;
        [ // logique; définit les lignes 4.x et 5.x du résultat
          // Les variables définies dans le paramètre logique lors des exécutions précédentes 
          // dans la boucle sont supprimées à ce stade
            i = i + 1;
            résultat = résultat & "4." & i & " " & it1 & " " & it2 & ¶;
            it1 = "c"; // Réutilisée dans la portée de la fonction TantQue
            it2 = 2; // Redéfinie dans la portée de la fonction TantQue
            résultat = résultat & "5." & i & " " & it1 & " " & it2 & ¶
        ];
        // résultat; définit la ligne 6.0 du résultat
        résultat & "6.0 " & it1 & " " & it2 & ¶
    )
    // Après la boucle TantQue; définit la ligne 7.0 du résultat
    & "7.0 " & it1 & " " & it2 & ¶
)

Résultat obtenu :

1.0 a 1
2.0 a 1
3.0 b 1
4.1 b 1
5.1 c 2
4.2 c 1
5.2 c 2
6.0 c 2
7.0 a 1

Rubriques connexes