Agnès

De L'importance De L'imbrication

70 messages dans ce sujet

Hello,

Dans la série ça me plait grave ;)
Juste pour éclairer l'ordre d'évaluation de fonction imbriquée

donc :
Une fonction personnalisée, appelons la _EvalCf
1 attribut "a", ce qui donne la cf _EvalCf ( a ) avec son calcul :

Evaluate ( a )

et dans le DataViewer, on s'amuse, on y pose :
Let ( $n = 0 ; _TestEvalCf ( "let( $n = $n + 1 ; $n )" ))
Résultat : 1

puis, on test
Let ( $n = 0 ; _TestEvalCf ( "let( $n = $n + 1 ; $n )" ) &_TestEvalCf ( "let( $n = $n + 1 ; $n )" ))
Résultat : 12

maintenant, on imbrique
Let ( $n = 0 ; _EvalCf ( "let ( $n = $n +1 ; $n ) & " & _EvalCf ( "let ( $n = $n +1 ; $n )" )))

Résultat : 21
Vous me suivez ? ok, on continue d'imbriquer ;)

Let ( $n = 0 ;
_EvalCf ( "let ( $n = $n +1 ; $n ) & "
& _EvalCf ( "let ( $n = $n +1 ; $n )" )
& _EvalCf ( "let ( $n = $n +1 ; $n )" )
& _EvalCf ( "let ( $n = $n +1 ; $n ) & " & _EvalCf ( "let ( $n = $n +1 ; $n )" ) )))

Résultat : 51243, J'aime beaucoup :)
Bien évidement, il s'agit ici de la même cf imbriquée, mais cela vaut pour différentes cf imbriquées
cela permet de cascader des variables en les promenant d'une chaines à l'autre :ninja::w00t::rolleyes:B)

Bon :)
j'y retourne ;)
Agnès

Partager ce message


Lien à poster
Partager sur d’autres sites

Tu devais être forte, en lego.

Partager ce message


Lien à poster
Partager sur d’autres sites

C'est effectivement beau comme exercise, mais j'aimerais bien voir un example pratique pour qu'on comprenne comment tu utilises ça en pratique?

Partager ce message


Lien à poster
Partager sur d’autres sites

Juste en enlevant le Evaluate de la cf et en enlevant les guillemets du dernier calcul, on obtient 12345 ( au lieu du 51243 )

[Le comportement est identique de la v9 à la v14]

 

Concrètement, humm, comment dire,  je passe des infos à ma variable de gauche par mes variables de droite :rolleyes:

 

C'est en faisant mon fichier test ( 1 seule  cf qui me drive mes 35 cf ) que je trouvais "normal" mais bizarre que l'info de droite soit bien passé à gauche et que ça marche même très bien

 

Je suis partie de

> Cfs ( "CustomList" ; 1 ; Get ( FoundCount ) ; "GetNthRecord ( Field::Name ; [n] )" ; "" ) [ déjà en prod, mais pas rapide ]

 

puis je suis arrivée à

> Cfs ( $$_CustomList ; 1 ; Get ( FoundCount ) ; "GetNthRecord ( Field::Name ; [n] )" ; "" ) [ assez rapide pas testé à fond ]

 

et là, j'en suis là :

> Cfs ( $$_CustomList & Cfs ( 1 ) & Cfs ( Get ( Foundcount ) ) & Cfs ( "GetNthRecord ( Field::Name ; [n] )" ) ) [ assez rapide mais pas testé ]

 

C'est cette version qui me plait et que je regarde "en profondeur" en ce moment, mais je ne comprenais pas comment, techniquement, la variable $$_CustomList recevait les bonnes info ( start / End / function qui sont donc passés après )

 

 

Et sinon, c'est juste bien que de savoir l'ordre d'évaluation des choses non ?

ça permet de poser des briques ;)

 

J'y retourne ;)

 

Agnès

Partager ce message


Lien à poster
Partager sur d’autres sites

Je suis sûr que tu vas tomber sur l'utilité à un moment ou un autre, mais si pour l'instant c'est de la "recherche fondamentale". Honnêtement, jusqu'ici je trouve le résultat assez banale/attendu, mais c'est vrai que je n'ai pas vraiment approfondi la question. Il m'a fallu pas mal de temps déjà pour apprécier CustomList (que j'utilise maintenant dans chaque solution), et j'espère que tes expériences vont donner un résultat aussi fructueux. Sinon, on apprend toujours qqch en route!

Partager ce message


Lien à poster
Partager sur d’autres sites

Alors là, je digresse me direz-vous, mais quel est l'intérêt de "driver" tes cf avec 1 seule cf ?

 

Et d'ailleurs qu'entends-tu par "driver" ? Elle contient tout le code des 35 cf ? ou elle ne fait que les appeler ?

Partager ce message


Lien à poster
Partager sur d’autres sites

coucou
c'est un peu comme une récursive, la fonction s'évalue d'abord elle même jusqu'au bout puis, comme tu le démontres, remonte la hiérarchie des variables à l'envers (ou tout du moins en fonction de l'ordre des imbrications).

Partager ce message


Lien à poster
Partager sur d’autres sites

Bon,

 

A moins que ce soit pour une question de lisibilité, que mon ophtalmo gère pour moi désormais, je ne vois pas l’utilité ici, de la fonction _EvalCf (), dans cet exercice en tout cas.
Le résultat me semble tout à fait identique avec la fonction Evaluation ( ) ou alors j’ai raté quelque chose ?

 

Ce que tu sembles observer, c’est la manière dont FileMaker résoud les dépendances au sein d’un calcul. Dans ton cas,  pour résoudre ces dépendances, on provoque la modification d'une variable lors de l'évaluation. Donc c'est en effet attendu.

 

Une question cependant : Si je me souviens bien, toute nouvelle variable déclarée au sein de la fonction Evaluation ( ) reste locale à cette fonction où elle est déclarée, n'est ce pas ?

Partager ce message


Lien à poster
Partager sur d’autres sites

Alors là, je digresse me direz-vous, mais quel est l'intérêt de "driver" tes cf avec 1 seule cf ?

 

Et d'ailleurs qu'entends-tu par "driver" ? Elle contient tout le code des 35 cf ? ou elle ne fait que les appeler ?

De l'intérêt de continuer à trouver de l'intérêt à développer, peut être ;)

C'est toujours dans mon souci de jouer avec FM et d'externaliser au max ( tout à commencé à Poitiers vec les paramètres externes ;) )

 

J'ai un fichier qui contient entre autres les cf / 1 enreg par cf, et dans les GestionDeFonction, il n'y a qu'1 seule cf qui "lit" les autres

Pour simplifier, en écriture cela donne ça Cfs ( $$_CustomList / Start / End / Function ) ou Cfs ( $$_PrimaryKey / Prefix ) ou

Cfs ( $$_FM_Name_ID / Name_ID / TLFSV / _fileName /_layoutName ) en bref, 1 Cfs pour x cf

 

l'avantage ( les en fait ) que j'y trouve

- une mise à jour simple, puisque je ne tiens et n'écris les cf que dans 1 seul fichier 

- les fonctions / calculs sont disponibles pour un ensemble de Fichiers

- je préfère ça plutôt qu'ouvrir et fermer la fenêtre de gestion de fonction, une mise à jour ou une vérification de code y est laborieux

- facilité des mises à jour des codes, en masse via des pomme = ou substitute ou.

- une mise en évidence du code, recherche des variables, rubriques et fonctions etc.

- un ou des exemples pour chaque fonction

- un code vide préparé genre : Cfs ( $$_CustomList ; /*Start*/ "" ; /*End*/ "" ; /*Function*/ "" ; /**/ "" )

- j'aime bien tester de nouvelles pistes ;)

 

le seul point négatif, c'est la lenteur d’exécution pour des - très gros - traitements en masse, d'où la recherche de tester de nouveaux codes

 

C'est en faisant mon fichier Technique que je voulais mettre sur mon site que je viens de voir la possibilité de passer la variable de gauche à droite mais le problème maintenant que j'ai, c'est qu'il est impossible de passer l'info de droite à gauche.... à moins que ça ne soit le contraire ;)

Partager ce message


Lien à poster
Partager sur d’autres sites

Coucou,

Le résultat me semble tout à fait identique avec la fonction Evaluation ( ) ou alors j’ai raté quelque chose ?

Clair, elle n'en a aucun, Definir (
$n = 0 ;
Evaluate ( "let ( $n = $n +1 ; $n ) & "

& Evaluate ( "let ( $n = $n +1 ; $n )" )
& Evaluate ( "let ( $n = $n +1 ; $n )" )
& Evaluate ( "let ( $n = $n +1 ; $n ) & " & Evaluate ( "let ( $n = $n +1 ; $n )" ) )
)) donne également 51243

mais je suis dans les cf en ce moment :rolleyes:

 

effet attendu, oui tu as raison, c'est logique que ça commence par 5, c'est une histoire de parenthèse et d'ordre, trop le nez dedans :rolleyes:

mais ça me plait encore ;)

Une question cependant : Si je me souviens bien, toute nouvelle variable déclarée au sein de la fonction Evaluation ( ) reste locale à cette fonction où elle est déclarée, n'est ce pas ?

non, la variable, $ ou $$ dépasse les parenthèses d'Evaluate et s'échappe du calcul

Partager ce message


Lien à poster
Partager sur d’autres sites

Alors, pendant qu'on y est, j'ai testé différentes choses : écritures et calcul
s

1/


Cfs ( "CustomList" ; Start ; End ; Function ; "" )
Cfs ( "PrimaryKey" ; Prefix ; "" ; "" ; "" )
Cfs ( "GlobalList" ; KeepTable ; ExcludeTable ; KeepGlobal ; ExcludeGlobal  & "|#_rc_#|" & Attribute & "|#_rc_#|" & Option  & "|#_rc_#|" & View )

 

Cfs() à 5 paramètres, le premier pour le nom de la Cf cible, 4 paramètres pour gérer 90% des cf et le 4eme est "extensible", avec un tag de séparation de paramètre, ici "|#_rc_#|"
les calculs sont dans une globale[multivaluée] Cfs () doit calculer dans quelle répétition elle doit aller chercher le bon calcul
- c'est la version la plus lente mais tout est bien rangé, pas 35 variables dans le DV

2/

Cfs ( $$_CustomList ; Start ; End ; Function ; "" )
Cfs ( $$_PrimaryKey ; Prefix ; "" ; "" ; "" )
Cfs ( $$_GlobalList ; KeepTable ; ExcludeTable ; KeepGlobal ; ExcludeGlobal  & "|#_rc_#|" & Attribute  & "|#_rc_#|" & Option  & "|#_rc_#|" & View )
Cfs() à toujours 5 paramètres, le premier le nom de la $$_Cf cible, les autres, idem v1
les calculs sont chargés dans une variable avec le nom de la fonction cible
- c'est une version assez rapide, mais on a 35 $$_Variables dans le DV ( qui finalement est assez pratique pour changer le code et voir en direct le résultat

Dans ces versions 1 et 2, seul 4 paramètres peuvent détecter et utiliser la fonction GetFieldName () qui se trouverait dans le code original de la fonction - a priori, les fonctions que j'ai regardé n'ont dans l'ensemble, qu'un seul paramètre qui utilise GetFieldName () et rarement plus de 4 paramètres

Et la, je regarde la v3/ ( même timing que la v2 )
Cfs ( $$_CustomList & Cfs ( Start ) & Cfs ( End ) & Cfs ( Function) )
Cfs ( $$_PrimaryKey & Cfs ( Prefix ) )
Cfs ( $$_GlobalList & Cfs ( KeepTable ) & Cfs ( ExcludeTable ) & Cfs ( KeepGlobal ) & Cfs ( ExcludeGlobal ) & Cfs ( Attribute) & Cfs ( Option) & Cfs ( View ) )

Mais, si j'arrive à passer Start à $$CustomList, je n'arrive pas a dire à Start qu'il joue pour CustomList, et ça me complique la vie pour GetFieldName() dans le code d'une Cf

Bref, si vous avez une idée sur le "mieux" comme écriture, lisibilité, rangement et des arguments, pour et/ou contre, je prends ;)

je pense que j'opte quand même pour la v2, plus lisible me semble

 

en fait, Cfs () c'est ma HoldingCf ;)

Agnès

 

Partager ce message


Lien à poster
Partager sur d’autres sites

Bon,

 

Je ne sais pas du tout comment tout ceci fonctionne, mais si je devais reproduire ce type de fonctionnalité, j'ai l'intuition que la voie serait un bon Json bien structuré.

 

http://www.modularfilemaker.org/module/json/

couplé à

http://www.modularfilemaker.org/module/parameters/

 

Mise en pratique ici, c'est peut-être plus compréhensible, même sans le son :

 

Sinon, j'ai l'impression que pour obtenir ce type de résultat - et peut-être solutionner ton problème de "Start" quoique j'ai relu quinze fois avant de penser comprendre ;) - je séparerai les arguments des paramètres.

 

Une fonction comprend un nom, des paramètres, un code a exécuter, mais est évaluée sur la base des arguments.

 

Pourquoi par quelque chose à décliner du genre :

 

Déclaration des fonctions

$$functionName[code(« CustomList »)] = « CustomList »

 

Déclaration des syntaxes et paramètres

$$functionSyntax[code(« CustomList »)] = «Start,End,Formula»

 

On pourra décompter les paramètres nécessaires ainsi

$$functionParamsCount[code(« CustomList »)]= PatternCount($$functionSyntax[code(« CustomList »)]; «,» )

 

Puis les charger dans des variables à leur tour dans une boucle

$$functionParams[code(« CustomList »& «1»] = « Start »
$$functionParams[code(« CustomList »& «2»] = « End»
$$functionParams[code(« CustomList »& «3»] = « Formula»

 

Assembler le code dans une autre variable

$$functionCode[code(« CustomList »)] = « le code de ma fonction où les paramètres seront transformés en arguments via l’évaluation»
 

Dans ce cas il convient de définir les variables locales :

$functionArgs[code(« CustomList »& «1»] = 1
$functionArgs[code(« CustomList »& «2»] = Get(FoundCount )
$functionArgs[code(« CustomList »& «3»] = «GetNthRecord ( Field ; [n] )»

 

Si la variable $$functionCode comprend une chaîne du type $start, je la changerai donc en une chaîne du type $$functionParams[code(« CustomList »& «1»] qui sera alors remplacé par sa correspondance $functionArgs[code(« CustomList »& «1»]

 

Tout serait plus lisible en utilisant par exemple un $functionId = code(« CustomList »)

$start serait alors écrit ainsi $$functionParams[$functionId &"1"] et le résultat récupéré depuis $functionArgs[$functionId &"1"].

 

Peu de chance donc que le $Start puisse alors être associé à une autre fonction que CustomList, sauf si $functionId doit être unique encore...

 

Encore une fois, un fichier Json serait bien plus exploitable et surtout lisible

 

Mais je doute d'avoir tout compris à l'histoire, tout de même, mais au moins ça fait de la lecture aux petits nouveaux ;)

Partager ce message


Lien à poster
Partager sur d’autres sites

:)

 

tu as du mérite ;)

Je viens de retomber sur un de mes posts de 2007, ou manifestement j’essayais un truc sur les fp, et j'avais a priori trouvé une solution .... personne n'avais compris ce que je demandais, et je ne le comprends effectivement pas du tout non plus maintenant B)

j'espère qu'il n'y avait qu'un seul post comme ça :rolleyes:

 

Donc, pour mon histoire d'ici,

 

Imaginons la cf Repeat ( End ; Value )

le code en serait

Substitute ( ( 10 ^ End ) - 1 ; 9 ; Value )

 

un calcul  AdaptCode va rajouter les variables nécessaires

Grosso modo, cela donne

 

Let ([

End = $z_Par[1] ;

Value = $z_Par[2]

];

// code intégral de la cf

Substitute ( ( 10 ^ End ) - 1 ; 9 ; Value )

)

 

dans ce "jeu" je ne touche pas au code original, ni aux paramètres des fonctions, j'ajoute simplement mon let

 

Donc, pour donner un cas concret d'utilisation :

La variable $$_Repeat est déclarée à l'ouverture du fichier et contient ce dernier code.

 

La fonction Cfs () pour ma v3 est très simple (  je ne traite pas les GetFieldName pour l'exemple ;) ) :

 

Cfs (

Case ( Position ( Fonction ; "$z_Par" ; 1 ; 1 ) ;

Evaluate ( Fonction ) ;

Let ( [

$Count = $Count + 1 ;

$_Par[$Count] = Fonction

]; "" )

)

 

l'appel ensuite de cette cf ce fait comme ceci

Cfs ( $$_Repeat & Cfs ( 15 ) & Cfs ( "_" ) )

et ça marche

 

Cfs ( 15 ) & Cfs ( "_" ) sont forcément évalués en premier, ce qui permet de déclarer d'abord les 2 variables $z_Par[x] et de les passer à l'évaluation de la variable $$_repeat

 

Mais avec ce système, si $$_Repeat récupère bien le End et le Value, je n'arrive pas à transmettre simplement que End et Value sont  utilisés là dans $$_Repeat

 

Et j'aimerais bien me débarrasser du fichier Demo en le postant, je pourrais passer à aut'chose et je crois que certains calculs dedans peuvent être intéressant :);)

Voire éventuellement la méthode... mais ça j'y crois pas trop...

 

Le fichier est modulaire, l'ensemble est exploitable en copiant juste 1 pas de script et Cfs()

Je vais  te relire et regarder tes liens, j'ai la lumière qui se fera plus tard ;)

Je veux passer sur le cas des listes de valeurs ensuite :ninja:

 

Merci !

 

Agnès

Partager ce message


Lien à poster
Partager sur d’autres sites

Coucou,

 

Je comprends que tu cherches à minimiser les fonctions. Cependant, si tu charges le code de ta fonction dans une variable globale, la seule chose qu'il te manque c'est d'alimenter les arguments.

 

Puisque ce qui t'importe au final de ce que je comprends c'est d'alimenter une variable multivaluée, où la répétition correspond à l'ordre de tes paramètre, personnellement, je constituerai une fonction

loadArgs(Value; n )Definir($z_Par[n] = Value; "")

Si ta variable $$_Repeat est chargée avec le code suivant

Let ([End = $z_Par[1] ;Value = $z_Par[2]];// code intégral de la cfSubstitute ( ( 10 ^ End ) - 1 ; 9 ; Value ))

Le résultat pourrait être obtenu simplement comme suit

Evaluation ( $$_Repeat  & loadArgs ( 1 ; 15 ) & loadArgs ( 2 ; "_" ) )

Je préfère en tout cas distinguer la fonction destinée à charger les variables de celle chargée de l'évaluation finale, quand bien même tout peut être réalisé en effet au sein de la même fonction, d'autant que cela permet également de bien marquer l'ordre de chargement. Il m'est déjà arrivé d'avoir besoin d'une fonction dans laquelle la valeur d'un paramètre était dépendante de la valeur d'un autre, par ailleurs. En utilisant cette structure, tu peux y parvenir puisque les chargements sont faits dans l'ordre où ils sont déclarés.

 

Ex : La chaîne de substitution dépend d'une autre variable

Evaluation ( $$_Repeat  & loadArgsInVars ( 1 ; 8 ) & loadArgsInVars ( 3 ; "Agnès") & loadArgsInVars ( 4 ; "B") & loadArgsInVars ( 2 ; $z_Par[3] & $z_Par[4]) )

ou alors

 

Ex : Le nombre de répétition définie dans l'argument 1 dépend de la longueur de la chaîne de substitution définie dans l'argument 2

Evaluation ( $$_Repeat  &  loadArgsInVars ( 3 ; "Agnès") & loadArgsInVars ( 4 ; "B") & loadArgsInVars ( 2 ; $z_Par[3] & $z_Par[4])  & loadArgsInVars ( 1 ; Longueur( $z_Par[2])))

Ou alors changer la fonction loadArgs de sorte que tous les arguments soient déclarés séquentiellement par cette fonction, ce qui donnerait alors

Evaluation ( $$_Repeat  & loadArgsInVars (15 ; "_" ) )

Le problème étant l'impossibilité de gérer des paramètres facultatif, ce qui t'impose de définir en amont un nombre de paramètre max pour cette fonction malheureusement

Partager ce message


Lien à poster
Partager sur d’autres sites

Mais avec ce système, si $$_Repeat récupère bien le End et le Value, je n'arrive pas à transmettre simplement que End et Value sont  utilisés là dans $$_Repeat

 

La fonction AdaptCode devrait se charger de personnaliser le code en lui fournissant des paramètres distinctifs, et la fonction de chargement pourrait se charger alors je pense du reste

Partager ce message


Lien à poster
Partager sur d’autres sites

Hello,

 

AdaptCode prépare le chargement et la répartition de parametres et oui, je me suis tournée ( en test ) vers 2 Fonction, Cfs () et x()

je n'ai pas besoin de passer 1, 2 ou n, les numéros de paramètres se calculant seul, et doivent être mis dans l'ordre, comme dans une fonction normale

cela donne donc

Cfs ( $$_Repeat & x ( 15 ) & x ( "_" ) )

 

il ne faut pas mettre Evaluation ( $$_Repeat & x ( 15 ) & x ( "_" )  ) direct dans les script ou calcul,  si un jour on veut changer ou ajouter, on serait obligé de se cogner tous les scripts et calculs, Si Cfs est simplement Evaluate ( param ) cela  permet en 1 fois / 1 endroit de modifier le calcul pour le répercuter "Partout" immédiatement.

 

et effectivement, mon souci d'écriture et de présentation vient du fait que l'on ne peut pas mettre des {} dans une CF

or le nombre de paramètres est inconnu et je ne veux pas limiter la CF a X parametres qui serait une décision arbitraire


En mixant mes v2 et v3 et en allant dans ce que tu proposes, cela donnerait peut etre ça :

2 Cf dans la gestion de fonctions personnalisées : Cfs () et x()

 


Cfs ( Fonction ; ParamA ; ParamB ; ParamC ; ParamS )
 Fonction, on indique la $$_NomFonctionCible
ParamA - B et C les parametres lambda

ParamS, 1 parametre lambda ou plusieurs parametres, séparé par & x()

 

 

bon, mais c'est plus compliqué derrière :

J'ai 2 variables en réel, $z_Atr[x] et $z_Gfn[x], la Gfn existe uniquement si dans le code il y a un GetFieldName () et c'est l'info que je n'arrive pas à passer pour le moment, je déclare donc $z_Atr[x] et xz_Gfn[x] systématiquement alors que je n'ai réellement besoin que de l'une ou l'autre ( et je n'aime pas charger une variable inutile et les vider me bouffe le timing dans une boucle )

 

dans le cas :

Cfs ( $$_Repeat & x ( 15 ) & x ( "_" ) )

15 et "_" passe vers $$_Repeat mais, $$_Repeat étant évaluée après x() (ou LoadArgs()), fait que xLoadArgs() ne sait pas pour quelle variable elle joue

(....reflexion1...)

il faudrait faire xLoadArgs ( fonctionCible ; param ) béh j'aime pas du tout.

(....reflexion2...)

vais me tenter sur un truc du style Cfs ( $$_Repeat & x ( $$_Repeat ) & x ( 15 ) & x ( "_" ) ) ou x ( $$_Repeat ) serait en sous-marin ....

Partager ce message


Lien à poster
Partager sur d’autres sites

Vraiment, à mon avis, c'est principalement dans la fonction "AdaptCode()" de préparation que se trouve la solution. Sauf qu'on doit donc fournir à "AdaptCode()" les éléments nécessaires, et que ceci passe nécessairement par une documentation précise. D'où mon idée d'un Json ou d'un xml, mais il est à mes yeux bien plus simple et lisible d'utiliser le premier.

 

Par exemple...

{    "mynewcustomfunction": {            "name": "MyNewCustomFunction",        "type": "recursion",            "source": {            "params" : ["i","Number","StartValue", {"OptionalParams": ["Param1","Param2"]}],            "paramsTypeCast" : ["Number", "Number", "Number", ["Number", "String"]],            "storedPosition" : 1,            "functionCode": {                "with_tail": {                    "code": "Case (i>1 ; MyNewCustomFunction(number; i-1; startValue & number ) ; startValue & number )",                    "code_url": "http://myPathToTheWithTailCode..."                },                "no_tail": {                    "code": "Cas (i>1 ; MyNewCustomFunction(number; it-1; startValue) & number ; startValue & number )",                    "code_url": "http://myPathToTheNoTailCode..."                }            },            "localVarNames": ["$MNCF_Par"]        },        "transform":{            "storedPosition" : 5,            "params" : ["MNCF_i","MNCF_Number","MNCF_StartValue",{"OptionalParams": ["MNCF_Param1","MNCF_Param2"]} ],            "localVarNames": ["$MNCF_Par"]        }    },    "myothercustomfunction": {            "name": "MyOtherCustomFunction",        "type": "standard",        ....        }}

Avec un fichier de config servant tout autant de documentation à l'appui, tu peux faire en sorte qu'AdaptCode ( ou un script au lancement de l'application ) génère la bonne structure à évaluer plus tard je pense. Tu pourras définir dans quelle multivaluée le code initial est stocké, dans quelle multivaluée il sera injecté après transformation, tu peux éventuellement charger ton code depuis un fichier texte, déterminer combien de paramètre seront utilisés, les transformations qui doivent être exécutées, etc

 

Et effectivement, comme je le proposais, loadVars doit savoir pour quelle fonction elle est lancée, et donc l'un de ses arguments pourrait être un prefixe qui permettrait ensuite de transformer par exemple la variable $z_Par en $MNVF_Par, trouvant alors une correspondance avec la variable $MNVF_Par qui aura remplacé $z_Par dans le code de la fonction $$_function, au travers la fonction AdpatCode ou le script.

 

Cela fait tout de même une sacré gymnastique...

 

 

 

je n'ai pas besoin de passer 1, 2 ou n, les numéros de paramètres se calculant seul, et doivent être mis dans l'ordre, comme dans une fonction normale

 

Je trouve que ça manque de souplesse ainsi. L'ordre de déclaration c'est une chose, l'ordre d'évaluation une autre, et dans la mesure où au final c'est le "n" que tu exploites pour déterminer l'argument qui devra être exploité, il me semble logique que ce "n" soit bien défini. Peu importe d'ailleurs que l'argument 1 soit défini avant le 2, comme je le disais plus haut, ça peut même être un avantage qu'il n'en soit pas nécessairement ainsi. Tu te moques des paramètres, ce sont les arguments qui comptent, puisque ceux-ci sont clairement identifiables par le numéro de répétition de la variable que tu as chargé.

 

 

il ne faut pas mettre Evaluation ( $_Repeat & x ( 15 ) & x ( "_" ) ) direct dans les script ou calcul, si un jour on veut changer ou ajouter, on serait obligé de se cogner tous les scripts et calculs, Si Cfs est simplement Evaluate ( param ) cela permet en 1 fois / 1 endroit de modifier le calcul pour le répercuter "Partout" immédiatement.

 

Si Cf fait autre chose que Evaluate (), ce qui ne semblait pas être le cas si on isole le chargement des variables, ou alors j'ai rien compris. Par contre, changer la fonction personnalisé à posteriori n'apportera aucun changement à un calcul utilisant cette fonction perso, alors que la modification du calcul exploitant evaluate() forcera le recalcul, c'est aussi à prendre en considération en effet.

Modifié par Ugo

Partager ce message


Lien à poster
Partager sur d’autres sites

je suis une gaufre doublée d'une gourde ;)

dans Cfs, il suffit juste de passer un let ( $var = fonction ; "" )  avant le Evaluate ( fonction ) pour confirmer à x ( param) qu'il travaille pour telle ou telle fonction

 

FM dans l'ordre va d'abord déclarer la variable, jouer mes x(param) puis revenir à Evaluate

Non. ça ne fonctionne pas

 

Bon, Ugo, si je peux me permettre, là.... tu vas trop loin :arg:

c'est quoi le langage ? le JSon c'est ça ?

Si l'idée est plaisante, le mettre en oeuvre dans FM me parait difficile non ?

 

AdaptCode contenait une bonne partie de ses infos, mais pour l'Evaluation finale, il fallait de toute façon extraire les renseignements, et le timing s'envolait, 22 secondes pour une boucle de 25000 ( contre 3, la fonction originale et 11 maintenant )

jusqu'a 5000, j'ai 0 seconde d'écart entre PrimaryKey ( "ABC" ) et Cfs ( $$_PrimaryKey & x( "ABC" ) ) pour 10000 j'ai 2 secs vs 5 secs ce qui pour moi reste correct

d'ou le fait que je revisite un peu ( a priori, je ne peux de toute façon pas descendre en dessous de 9 sec pour 25000 mais je tente de m'y rapprocher )

 

Le calcul que tu me montres, même s'il est très attrayant, penses tu qu'il soit approprié ?

Sérieusement, qui a part moi va utiliser 1 cfs pour n cf ??

 

je vais essayer de comprendre déjà les 2 fichiers que tu cites plus haut, et ça ne va pas être mince comme affaire !

 

Merci à toi

 

Agnès

Partager ce message


Lien à poster
Partager sur d’autres sites

Bon,

 

Sérieusement, qui a part moi va utiliser 1 cfs pour n cf ??

 

Déjà il faudrait que tu nous confies ton dictionnaire. Sinon, sérieusement...ben...Joker :diable:

 

 

Le calcul que tu me montres, même s'il est très attrayant, penses tu qu'il soit approprié ?

 

Ce n'est pas un calcul. Le JSON permet de stocker des informations d'une manière organisée, moins extensible que le XML, mais facile à traiter et plus lisible dans bien des cas. Ici, une fois construit dans un editeur de texte, il pourrait être stocké quelque part pour servir de fichier de configuration. Après, on peut me stocker où on veut, et bien entendu même dans une chaîne de texte dans une table ou une globale...

 

http://www.json.org/json-fr.html

 

 

 

AdaptCode contenait une bonne partie de ses infos, mais pour l'Evaluation finale, il fallait de toute façon extraire les renseignements

 

Je suis parti du postulat que la fonction était chargée en variable après que son code ait été totalement adapté, et prêt à être évalué, en fonction des différentes propriétés de la fonction ciblée ( extraites dans ce fichier Json par exemple ) . Si d'autres appels aux propriétés de la fonction sont nécessaires pour son évaluation définitive, je ne vois vraiment pas l'intérêt. Mais je ne vois pas non plus ce qui devrait être encore évalué...

 

 

 

Si l'idée est plaisante, le mettre en oeuvre dans FM me parait difficile non ?

 

Le Json est désormais tout autant utilisé que le XML, la plupart des langages de programmation le prennent en charge...

FileMaker propose nativement l'intégration de fichiers XML, mais rien de natif pour le Json. Vouloir en parser le contenu avec les fonction texte n'est pas pertinent, on peut utiliser un plug-in pour ça ou simplement le module qui a été construit et que j'ai mentionné plus haut, simple à intégrer et parfaitement fonctionnel.

 

Dans ce cas précis, c'est difficile car je n'ai pas le recul et il semblerait bien qu'on nous ai abandonné tous les deux sur cette île en plus :hello:

 

 

 

là.... tu vas trop loin

 

Moi ? Sérieusement.... :w00t:

Partager ce message


Lien à poster
Partager sur d’autres sites

Ton postulat est bon

 

Et dans ce cas précis, il me semble aussi que tu n'as pas tenté une seule fois de me dissuader :rolleyes:

 

Je réponds pas sur l'ile :)

 

 

( et c'est encore Laurent qui à commencé !! )

Partager ce message


Lien à poster
Partager sur d’autres sites

Ben,

 

il me semble aussi que tu n'as pas tenté une seule fois de me dissuader :rolleyes:

 

 

Notons tout de même que je ne t'y ais pas encouragé non plus ;)

Partager ce message


Lien à poster
Partager sur d’autres sites

il semblerait bien qu'on nous ai abandonné tous les deux sur cette île en plus :hello:

 

 

Je réponds pas sur l'ile :)

 

 

( et c'est encore Laurent qui à commencé !! )

Non, je suis là, au large, dans mon canot de sauvetage, et je vous surveille de loin aux jumelles, prêt à intervenir (pour quoi, je ne sais pas).

Partager ce message


Lien à poster
Partager sur d’autres sites

C'est effectivement beau comme exercise, mais j'aimerais bien voir un example pratique pour qu'on comprenne comment tu utilises ça en pratique?

 

Ce que tu peux être terre à terre… ;)

Partager ce message


Lien à poster
Partager sur d’autres sites

« Je suis là, au large, dans mon canot de sauvetage, et je vous surveille de loin aux jumelles, prêt à intervenir (pour quoi, je ne sais pas)...»

 

alertemalibu.jpg

post-233-0-17130100-1444383765_thumb.jpg

Partager ce message


Lien à poster
Partager sur d’autres sites

Il n'y a malheureusement plus rien à faire, Julien. Ils sont trop loin là...

Partager ce message


Lien à poster
Partager sur d’autres sites

Créer un compte ou se connecter pour commenter

Vous devez être membre afin de pouvoir déposer un commentaire

Créer un compte

Créez un compte sur notre communauté. C’est facile !


Créer un nouveau compte

Se connecter

Vous avez déjà un compte ? Connectez-vous ici.


Connectez-vous maintenant

  • En ligne récemment   0 membre est en ligne

    Aucun utilisateur enregistré regarde cette page.