Changements récents - Rechercher:

Tutoriel Filemaker

  1. Structure
  2. Modèles
  3. Opérations diverses
  4. Calculs
  5. Scripts
  6. Privilèges d'accès

Filemaker avancé

  1. Partage des données
  2. Astuces et Exemples
  3. Développement

Règles de nommage

Versions de FileMaker Pro

Liens utiles Contact Commentaires

edit SideBar

Fonctions logiques : exemple

<==Fonctions statistiques : exemple ^ Calculs Fonctions texte : exemple==>

Les fonctions logiques sont extrêmement pratiques. Elles permettent en effet de modifier un résultat, par exemple, en fonction de conditions logiques. Amusons-nous un peu avec notre fichier

Cas()
ObtenirEnièmeEnreg()
Definir()




Cas()


On voudrait bien voir apparaître dans le modèle CLA_Fiche une rubrique qui changerait de contenu en fonction du nombre d’élèves faisant partie de la classe (donné par la rubrique z_NombreEleves). Par exemple, si on fixe comme but que le maximum d’élèves par classe doit être de 20, on pourrait, en fonction du nombre d'inscrits, afficher une phrase du style :

  • Si le nombre est inférieur à 20 : « il reste n places » ou n prend la valeur du nombre de places
  • Si le nombre est de 20 : « le nombre maximum est atteint »
  • Si le nombre est supérieur à 20 : « le nombre maximum est dépassé »

Tout ceci est n'est que divers résultats d'un calcul, ou différents cas à tester...

Toujours dans notre table CLA__, on crée la rubrique z_TestNbreEleves_c, calcul, résultat texte. Nous allons utiliser la fonction Cas() (puisque nous avons plusieurs cas à traiter…).

La structure de cette fonction se présente ainsi (ne pas oublier de spécifier le type de résultat, ici du texte) :

On va en profiter pour travailler un peu la présentation de notre calcul :

  • Chaque "cas" fera l'objet d'une ligne différente
  • On va ajouter des commentaires dans le calcul lui-même : s'il s'agit d'un commentaire sur une seule ligne (après une formule p.ex.), on démarre le commentaire par //, puis le commentaire. Si on place un commentaire complet sur plusieurs lignes, il doit être placé entre /* et */

Le calcul complet, avec commentaires se présente ainsi :

Cas(
//premier cas : inférieur à 20
z_NombreEleves_c < 20 ; "Il reste " & (20 - z_NombreEleves_c) & " places" ;
//deuxième cas : égal à 20
z_NombreEleves_c = 20 ; "Le nombre maximum est atteint" ;
//troisième cas : supérieur à 20
z_NombreEleves_c > 20 ; "le nombre maximum est dépassé"
)

Ca peut paraître touffu, mais à la lecture, c'est nettement plus compréhensible que si tous les cas étaient mis bout à bout, sans aucun commentaire...

Cas(z_NombreEleves < 20 ; "Il reste " & (20 - z_NombreEleves) & " places" ; z_NombreEleves = 20 ; "Le nombre maximum est atteint" ; z_NombreEleves > 20 ; "le nombre maximum est dépassé")

Une des lignes mérite que nous nous y attardions un peu : notre premier test et son résultat.

z_NombreEleves_c < 20 ; "Il reste " & (20 - z_NombreEleves_c) & " places" ;

Si le test est explicite, remarquons la façon dont nous pouvons associer du texte (entre ") avec une rubrique (z_NombreEleves_c) elle-même dans un calcul (20-z_NombreEleves_c).
Chaque partie est reliée à l'autre à l'aide du signe &. Par ailleurs, on comprend mieux notre nomenclature car si nous avions nommé notre rubrique z-NombreEleves-c, notre signe - au lieu de _ risquerait d'être interprété comme un signe de calcul, et z-NombreEleves interpréter comme "contenu de la rubrique Z moins contenu de la rubrique NombreEleves, qui n'existent ni l'une ni l'autre (et imaginez le résultat si, en plus, elles existaient !!).
Morale de l'histoire, '''tout ce qui est entre " " est considéré comme du texte et n'est pas interprété ou calculé, le reste est considéré comme une valeur (notre 20 est donc bien pris pour sa valeur) ou comme une rubrique.

Comme il s'agit d'une rubrique purement informative, on va la placer sur le modèle CLA_Fiche sous forme de rubrique de fusion, à côté du nombre d'élèves :

Pimentons un peu l'affaire : nous avons deux rubriques utiles :

  • NbeIns_s, qui nous donne le nombre d'élèves inscrits par classe à partir de la table des inscriptions
  • z_TestNbreEleves_c, qui apprécie ce nombre

On crée sur le modèle une zone de texte (a l'aide de l'icône "A" dans la zone d'état) avec comme texte : Il y a <<cla_INS__Eleve::NbeIns_s>> élève(s), <<z_TestNbreEleves_>>.

Placé judicieusement sur notre modèle CLA_Fiche, cela nous donne ceci :

Evaluation d'un test : changer sa façon de penser...

C'est l'occasion ou jamais d'introduire ici la notion de booléen, mot rigoureusement imprononçable (faites un test autour de vous !). Que se passe-t-il réellement dans la fonction cas ? On pose un premier test, Test1, et, s'il est respecté, on dit à la fonction Cas() de fournir un Résultat1. Il en est de même pour les autres tests.

En fait, l'évaluation du Test1 fournit soit 1 si le test est réussi, soit 0 si le test échoue. Si vous en voulez la preuve, rien de plus facile : faites-vous une rubrique calcul, en y mettant comme simple calcul uniquement le premier test z_NombreEleves < 20, et observez le résultat : il sera selon la classe égal à 0 ou à 1 ! La preuve est faite.
Donc, Résultat1 "attend" comme résultat du test la valeur 1 pour être produit comme résultat final de la fonction. Si, par contre, le résultat du test vaut 0, Résultat1 ne sera pas produit et on passe à l'étape suivante du calcul.

Le résultat d'une évaluation qui fournit soit 0 soit 1 est un résultat booléen. Il peut être apprécié comme tel et vous comprenez maintenant (et seulement maintenant, hélas...) pourquoi nous avons, dans nos rubriques obligatoires, les deux rubriques constantes 0 et 1 ! En effet, à partir d'un résultat booléen, on peut établir des liens vers des données liées ou non, selon qu'un test s'est avéré positif (1) ou négatif (0). Ca ouvre des perspectives, tout ça !

Ordre des tests.

La fonction CAS s'arrête dès quelle rencontre un test dont les conditions sont vraies. Quel que soit le nombre de "tests" inclus dans la fonction, si le premier est vérifié, aucun des suivants ne sera évalué. Il faut donc parfois bien réfléchir à l'ordre des tests, à leurs implications mutuelles et à l'existence ou non d'un "résultat par défaut", c'est à dire un résultat inscrit si aucun des tests successifs n'est vérifié.

On pourrait ainsi penser que le calcul illustré précédemment peut être raccourcit en utilisant un résultat par défaut.
En effet, notre premier test vérifie si le nombre d'élèves est inférieur à 20. S'il n'est pas inférieur à 20, on teste s'il est égal à 20. Si cette hypothèse n'est pas vérifiée, comme elle ne peut être atteinte qu'à condition que la précédente ne le soit pas non plus, il ne reste qu'une possibilité : il y a plus de vingt élèves. Notre troisième cas pourrait donc être un résultat par défaut, c'est-à-dire si aucun des précédents n'est vérifié. Ce résultat par défaut est également fort pratique lorsque tous les "cas" ne peuvent être listés, ou qu'ils ne sont pas exclusifs les uns des autres.

En l'occurrence, nous avons pourtant un quatrième cas...

Et oui, si notre nombre d'élèves est tout simplement vide. Nous pourrions donc rajouter comme résultat par défaut "il n'y a aucun élève inscrit", ou "cette classe est vide, on va la supprimer". Pourtant ceci ne fonctionnerait pas...

En regardant le fichier, vous vous dites que vide, c'est inférieur à 20, on devrait donc afficher "il reste 20 places"... Et vous n'avez pas tout à fait tort. Sauf que, revenons sur la définition de notre rubrique Z_TestNbreEleves_c...
Il y a en bas une petite case que nous vous avons dit de négliger jusqu'à présent :

Une classe sans élèves, donne non pas un nombre d'élèves égal à zéro, mais une rubrique vide (contrairement à notre Nombre d'inscrits, tiens tiens). Donc pas de calcul si cette rubrique est vide. Pas d'évaluation, pas de cas. Si vous décochez cette case, vous validez le test dans tous les cas.

Ahhh, la logique... Prenons en encore un peu en page 2 ===> ____

.

ObtenirEniemeEnreg()


Voilà une fonction qui parait bien obscure... Disons-le tout de suite : elle est principalement utilisée dans des script (ou dans des fonctions personnalisées récursives, mais passons...). De quoi s'agit-il ? Simplement d'aller "pêcher" dans une OT liée la valeur d'une rubrique du ènième enregistrement... La nomenclature de la fonction est finalement fort simple :

ObtenirEnièmeEnregistrement ( NomRubrique ; NuméroEnregistrement )

Il s'agit donc bien de définir la rubrique liée désirée, et de préciser le n° de l'enregistrement lié dont on veut obtenir la donnée contenue dans ladite rubrique.

Illustrons cela par un exemple : Partant de l’ancre CLA__, on veut obtenir le nom et prénom du 5e élève de la classe dans la table PER. Ces noms sont accessibles via le lien cla_ins_PER__Eleves. Comme on désire ici deux données (le nom ET le prénom), il faudra répéter le calcul deux fois :

Placé sur le modèle CLA_Fiche, le calcul donne bien le nom et le prénom du 5e élève. Vous me direz que ceci ne sert strictement à rien, et vous aurez raison. L'important ici est de comprendre le fonctionnement du calcul.

Voici d'ailleurs notre fichier

. Considérons cette courte page comme une petite pause, avant d'attaquer une fonction essentielle en page 3 : définir ===> ____

Definir()


Plus qu'une fonction, voilà une nouvelle manière de calculer en FileMaker Pro ! Usez et abusez de cette fonction ! Elle a ouvert à certains développeurs aguerris des perspectives nouvelles dont on ne voit pas encore la fin !

C'est peut-être également le moment opportun pour signaler quelque chose qui pourra paraître évident à plusieurs d'entre vous : bien sûr, une fonction de calcul peut contenir d'autres fonctions de calcul, qui, elles-mêmes, peuvent contenir, etc. Un exemple, qui fera sourire certains lecteurs non débutants :

Voyons la structure générale de la fonction Definir() :

En résumé très succinct (nous reviendrons sur le détail), il s'agit de définir en premier lieu les éléments nécessaires au calcul puis, en finale, d'effectuer ce calcul.

On y trouve donc un élément nouveau : la présence de "machins" entre crochets "[" et "]". Qu'est-ce ? Dans cette zone entre crochets, on déclare des variables, qui serviront au calcul final, défini après les crochets. Faisons une pause, et parlons des variables...

Les variables FileMaker Pro

Une variable est une donnée virtuelle au sein d'une application. Elle n'est donc pas présente dans une rubrique. Elle est locale et éphémère. Une variable possède un nom, tout aussi éphémère, et une valeur, encore plus éphémère que le nom, vu qu'on peut changer cette valeur à tout moment au sein d'une même variable (comme une donnée dans une rubrique)
En fait, une variable permet de stocker, le temps voulu, des données, sans pour autant faire appel à une rubrique.

Il existe trois types de variables dans FileMaker Pro.

  • Les variables de calcul, déclarées dans la fonction Definir(). Leur nom est totalement libre, mais en 1 seul mot. Par exemple, la célébrissime variable "toto", bien connue de tout développeur qui se respecte ! Mais autant donner des noms qui "parlent"...
    En première approche, leur existence dure le temps de l'évaluation du calcul. Leurs valeurs sont récupérables uniquement au sein de ce calcul.
  • Les variables de script, dont l'existence dure le temps du script et sont récupérables uniquement au sein du script dans lequel elles sont définies. Leur nom commence toujours par $, suivi d'un simple nom. Par exemple, $toto, tout aussi célèbre.
  • Les variables de session, qui durent le temps d'une session (jusqu'à ce que le fichier soit fermé par l'utilisateur, ou déconnecté), et qui sont récupérables au sein du fichier qui les a vu naître (attention donc aux applications multifichiers qui semblent donc de bien mauvaises idées...). Leur nom commence toujours par $$. Par exemple, $$toto, pas moins célèbre.

On résume :

toto calcul
$toto script
$$toto session d'un fichier

On répète ce petit tableau 10 fois, et on a compris. "Oui mais", se sont dit certains esprits tordus, "ne pourrait-on pas déclarer des variables de type $$ au sein d'un calcul ?". Eh bien, ça marche ! On peut très bien, par exemple, imbriquer une fonction Definir() au sein d'une fonction Cas(), dont le seul rôle est de définir une variable §§, qui prendra une valeur selon les tests de la fonction Cas(). Avantage : comme on est toujours dans notre session, la valeur de la variable $$ peut être récupérée à tout moment, alors qu'elle a été générée par calcul ! Mais ne nous embrouillons pas trop la tête ici... Contentons-nous des variables calcul, qui nous préoccupent pour le moment. Notons, afin d'être complet, que le nom d'une variable dans un calcul Definir() peut être déclaré tel quel, sans "", alors qu'aucune rubrique ne porte le même nom même si nous avions vu précédemment qu'un nom sans guillemet était interprété comme un nom de rubrique.

Fin de la pause sur les variables...

Exemple

Pour chaque personne, on aimerait définir un trigramme en majuscule, formé des deux premières lettres du nom et de la première lettre du prénom. On va donc définir ce calcul dans la table PER, à partir de l’ancre PER__, et utiliser la fonction Definir() (Les esprits chagrins diront qu'on peut très bien se passer de la fonction Definir() ici. Ils ont raison et restent des esprits chagrins !).

Dans notre fichier, nous allons nous placer sur la table PER_Tech pour créer cette nouvelle rubrique calcul nommée Trigramme_c. Sont résultat sera bien sur du texte. Reste à saisir le calcul qui nous donnera le résultat attendu...

Ci-dessous le calcul complet :

Commentaires :

  • Le calcul démarre en appelant "Definir" et par "(" pour ouvrir la fonction
  • Ensuite le "[" ouvre la zone de déclaration des variables. Comme si ce n'était pas assez compliqué comme ça, si une et une seule variable est déclarée, les crochets ne sont pas indispensables... Passons.
  • On nomme la première variable "a", et on lui met comme valeur les deux premières lettres du nom, via une fonction de texte extrêmement compliquée, nommée Debut() avec comme argument 2, pour, devinez quoi?, prendre les 2 premières lettres du début de la rubrique "Nom"... a = Debut ( Nom ; 2)
  • On nomme la deuxième variable "b" et on remet le couvert avec la rubrique "Prenom", dont on prend uniquement la 1ère lettre... b = Debut ( Prenom ; 1)
  • On nomme la troisième variable "c" et, comme à ce stade "a" et "b" sont déjà évaluées, on lui met comme valeur la concaténation de ces deux variables, via le signe de concaténation "&"... c = a & b
  • Comme "c" est la dernière variable déclarée, on ferme la zone de déclaration par "]", à placer AVANT ";" qui ferme la ligne de déclaration. C'est la seule difficulté réelle dans la nomenclature de la fonction Definir().
  • La zone de déclaration des variables est maintenant fermée et on passe au calcul proprement dit. On va le définir avec ce dont on a besoin dans les variables. En l'occurrence, nous avons déjà en quelque sorte effectué un pré-calcul (c = a & b). Ce qu'on veut, finalement, c'est avoir ce résultat c en majuscules, d'où ... Majuscule ( c ).

Récapitulons en partant de ce que l'on cherche pour voir comment nous devons faire notre calcul :

  • nous voulons EN MAJUSCULES, le trigramme composé des DEUX PREMIÈRES LETTRES de la rubrique nom et DE LA PREMIÈRE LETTRE de la rubrique prénom.

Il faut donc bien commencer par extraire les deux premières lettres du Nom (que l'on a mis dans la variable "a"), extraire la première lettre du Prénom (que l'on place dans la variable "b"), associer ces deux résultats (que l'on place dans la variable "c" qui vaut "a&b", sans espace). Reste à mettre ce dernier résultat (contenu dans "c") en majuscule.

Dès qu'un calcul s'avère un peu compliqué, il ne faut pas hésiter à utiliser la fonction Definir(), même si 99% des calculs qui l'utilisent peuvent s'écrire autrement. Mais un calcul complexe deviendra rapidement totalement illisible sans cette fonction miracle ! En effet, sa capacité à décomposer et marquer les étapes permet non seulement de ne pas se perdre en route, mais aussi de modifier facilement une étape ou une autre du calcul.

D'ailleurs, jouons un peu (pour les esprits chagrins ou curieux).

Nous aurions pu réduire notre définir () à deux variables. En effet, une fois a et b définis, notre calcul peut devenir Majuscule (a&b).

Definir ( [
a = Debut ( Nom ; 2) ;
b = Debut ( Prenom ; 1) ] ;
Majuscule ( a&b )
)

Et si nous n'avions pas utilisé la fonction définir, nous aurions en effet pu englober les différentes fonctions en écrivant directement :

Majuscule ( Debut ( Nom ; 2 ) & Debut ( Prenom ; 1 ))

D'où l'intérêt, bien souvent, pour définir un calcul de partir du résultat. En effet, ici, le calcul global part de la fin (nous voulons que ce soit en MAJUSCULES). Il faut donc commencer par la fonction "Majuscule ( Texte ). Puis il faut définir le contenu de ce "texte" qui devra passer en majuscule...

Bien. Ne nous embrouillons pas d'avantage, les occasions de faire des calculs ne manqueront pas.

Il reste maintenant à placer sur notre modèle PER_Fiche notre rubrique Trigramme_c pour voir le trigramme de chaque personne en majuscule dans notre fichier.

<==Fonctions statistiques : exemple ^ Calculs Fonctions texte : exemple==>
Éditer - Historique - Imprimer - Changements récents - Rechercher
Page mise à jour le 30 juin 2008 à 09h45