Le langage de script de JMP, JSL, est construit à partir d'appels de fonction. Presque tout ce que vous pouvez écrire en JSL est un appel de fonction. Certaines choses ne ressemblent pas à des appels de fonction :
A = A + 3;
Il est assez évident que le côté droit de l'instruction d'affectation est une expression. Il est moins évident que l'instruction d'affectation elle-même est une expression.
E = expr ( A = A + 3 );
expr est un wrapper que vous pouvez utiliser autour d'une expression pour empêcher l'évaluation de l'expression. E est défini sur l'expression, et non sur le résultat évalué de l'expression. Pour jeter un coup d'œil à E, utilisez la fonction head. Head renverra le nom de la fonction à la racine de l'expression :
show( head(E) );
Tête(E) = Attribuer();
Vous voyez maintenant qu'il existe une fonction pour faire des affectations :
Assign( testing, 3+4 );
sept
show(testing)
test = 7 ;
Les expressions en JSL sont en fait des arbres. Voici une image de l'arbre a=a+3, racine en haut, feuilles en bas :
Semblable à la fonction Head, nous pouvons utiliser la fonction Arg pour accéder aux enfants de la fonction Assign :
show( arg(E,1) );
Arg(E, 1) = A ; le côté gauche
show( arg(E,2) );
Arg(E, 2) = A + 3 ; le côté droit
et creuser plus profondément,
show(head(arg(E,2)))
Tête(Arg(E, 2)) = Ajouter(); la tête du côté droit
show(arg(arg(E,2),1))
Arg(Arg(E, 2), 1) = A ; le côté gauche du plus
show(arg(arg(E,2),2))
Arg(Arg(E, 2), 2) = 3 ; le côté droit du plus
Remarquez comment l'imbrication des parenthèses décrit l'arbre. Cet arbre n'a que des divisions binaires. Il y a une fonction, narg , qui renvoie le nombre d'enfants. Il renvoie 0 pour les nœuds feuilles.
narg(E)
2 la fonction assign a deux arguments, le côté gauche et le côté droit
JMP pour instruction est un appel de fonction, prenant quatre arguments. Remarquez les virgules qui séparent les arguments, comme n'importe quelle autre fonction.
halfCats = 1;
for( iCat = 1, iCat <= 10, iCat++,
halfCats = halfCats / 2;
write( iCat, " ", halfCats , "\!n" )
);
1 0,5
2 0,25
3 0,125
4 0,0625
5 0,03125
6 0,015625
7 0,0078125
8 0,00390625
9 0.001953125
10 0.0009765625
Il faut trois virgules pour séparer quatre arguments. Dans ce pour instruction, le quatrième argument est composé de deux instructions, séparées par un point-virgule. Jetez un coup d'œil au quatrième argument pour voir s'il s'agit également d'une fonction :
Head(
Arg(
Expr(
For( iCat = 1, iCat <= 10, iCat++,
halfCats = halfCats / 2;
Write( iCat, " ", halfCats, "\!n" );
)
),
4 /* the fourth arg */
)
);
Colle()
Colle est le nom de la fonction qui contient une séquence d'instructions ensemble.Colle le premier argument de est la première déclaration, etc.
Arg(
Arg(
Expr(
For( iCat = 1, iCat <= 10, iCat++,
halfCats = halfCats / 2;
Write( iCat, " ", halfCats, "\!n" );
)
),
4 /* the fourth arg is two statements, glued together */
),
1 /* the first arg is the first of the two glued statements */
);
moitiéChats = moitiéChats / 2
Une liste JSL est le même type d'expression :
list={33,44,55};
show(head(list));
show(narg(list));
show(arg(list,3));
Tête(liste) = {} ; list affiche des accolades pour la tête, plutôt qu'un nom comme Attribuer
N Arg(liste) = 3 ;
Arg(liste, 3) = 55 ;
Si vous voulez juste le contenu de la liste, vous devez utiliser l'indice normal :
show(list[3]);
liste[3] = 55 ;
Mais parfois, vous voulez faire quelque chose comme transformer une liste en arguments d'une fonction.
Dans le Éléphant post, vous trouverez un exemple de transformation d'une liste en modèle (ligne 5). J'ai du mal à trouver un autre exemple aussi cool que celui-là, mais supposons que vous vouliez vérifier si la liste était dans l'ordre alphabétique. L'opérateur < de JMP peut le faire en un seul appel de fonction :
LT = expr("a"<"b"<"c"<"d");
show(head(LT));
show(narg(LT));
Tête(LT) = Moins(); l'opérateur inférieur à affiche un nom de fonction, Moins
NArg(LT) = 4;
La fonction Less peut prendre beaucoup d'arguments, mais vous n'avez pas à les taper. Dessous, NomExpr récupère l'expression stockée dans les mots, après la RemplacerDans modifié le { liste } être Moins (). JMP affiche ensuite la fonction Moins en utilisant < pour la rendre plus lisible.
words =
{"Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf", "Hotel", "India",
"Juliet", "Kilo", "Lima", "Mike", "November", "Oscar", "Papa", "Quebec", "Romeo",
"Sierra", "Tango", "Uniform", "Victor", "Whiskey", "Xray", "Yankee", "Zulu"};
Substitute Into( words, Expr( {} ), Expr( Less() ) );
nameExpr(words);
"Alpha" < "Bravo" < "Charlie" < "Delta" < "Echo" < "Foxtrot" < "Golf" < "Hôtel" <
"India" < "Juliet" < "Kilo" < "Lima" < "Mike" < "November" < "Oscar" < "Papa" <
"Québec" < "Roméo" < "Sierra" < "Tango" < "Uniforme" < "Victor" < "Whiskey" < "Xray" < "Yankee" < "Zoulou"
eval(words)
1 eval (mots) renvoie 1, indiquant que le résultat de Moins était vrai.
Un autre exemple.
Mise à jour du 28 février 2017 - formatage de réparation pour la nouvelle communauté
Craig, cet article m'a été très utile dans ma quête continue pour comprendre comment gérer les expressions.
J'avais en fait une bonne application pour votre dernière astuce, où vous avez transformé les éléments d'une liste en arguments de la fonction Less(). Je voulais générer une formule de colonne contenant la fonction Col Mean(), basée sur l'entrée de l'utilisateur à partir d'une fenêtre de dialogue. La fonction Col Means() prend un ou plusieurs arguments, et je n'ai jamais eu de moyen astucieux de substituer un nombre variable d'arguments (souvent des noms de variables) dans une fonction. Voici les lignes clés de mon script :
arglist = {"taille", "âge", "sexe"} ; // résultats d'une fenêtre de dialogue
statformula = Substitute ( arglist, Expr( {} ), Expr( Col Mean() ) ); // les éléments dans arglist deviennent des arguments dans la fonction Col Means()
newcol << Formula( Name Expr( statformula ) );
Le script réel est plus complexe car il doit traiter des noms de colonne désordonnés qui nécessitent Name(" "), mais vous voyez l'idée. Merci de m'avoir montré cette astuce.
Howard Rauch
