729500_fr-FR

liliconcom

Head évalue-t-il son argument ?

En utilisant JSL pour développer des applications efficaces et robustes (UE 2018 415) , j'ai appris qu'il existe certaines fonctions qui évaluent leur argument et d'autres qui ne le font pas :

Je me suis interrogé sur Head. Ici tout semble logique...

f= Expr(x=2);
Substitute(NameExpr(f),Expr(x), Expr(y));
Head(f);

Head n'est pas comme Substitute, je peux directement utiliser le nom de la fonction comme argument - et Head renvoie la tête de l'expression : Assign()

Après avoir vérifié quelques autres fonctions qui "n'évaluent pas leur argument":

Expr(x=2); // x=2
Name Expr(x=2); // x=2

vérifions le résultat pour

Head(x=2)

qui vaut "2" - c'est à dire le résultat après évaluation de l'argument ?!?! pourquoi n'est-ce pas assign() ?

Automatisation et scriptsRe : Head évalue-t-il son argument ?

Names Default To Here(1);
{a, b, c} = {1, 2, 3};

Head(Expr(Sum(a, b, c)));
HeadExpr(Sum(a, b, c)); // Deprecated

Head(Sum(a, b, c));

https://www.jmp.com/support/help/en/17.2/#page/jmp/advanced-expressions-macros-and-lists.shtml#

Re : Head évalue-t-il son argument ?

ah, ok, l'index des scripts est très clair.

Ainsi, le comportement actuel est différent de celui indiqué par la liste. Aucun secret caché derrière cela.

En général, cela pourrait rendre la création de scripts beaucoup plus facile si l'éditeur JSL utilisait une mise en évidence pour faire la distinction entre les arguments évalués et les arguments qui ne sont pas évalués avant l'exécution de la fonction :

Mise en évidence de la syntaxe avancée dans l'éditeur JSL

Re : Head évalue-t-il son argument ?

pareil pour Narg - l'argument est évalué (1x, comme avec Name Expr()
(adapté du guide de script)

aExpr = {a+b,c,d,e+f+g};<BR />
Show(NArg(aExpr)); //4
Show(NArg(Arg(aExpr,4))); // 3
Show(NArg(Add(1,2,3,4))); // 0
Show(NArg(Expr(Add(1,2,3,4)))); //4

Show(Head(aExpr)); //List()
Show(Head(Arg(aExpr,4))); // Add()
Show(Head(Add(1,2,3,4))); // 10
Show(Head(Expr(Add(1,2,3,4)))); //Add

Re : Head évalue-t-il son argument ?

ce comportement de type Name Expr est particulièrement utile pour les cas avec
- Comme colonne(...)

- référence de colonne via variable ( col )

comme argument.

dt = Open("$SAMPLE_DATA/Big Class.jmp");
col = Name Expr(As Column("age"));

Head(As Column("age"));
Head(col);

dt << Recode Column(AsColumn("age"),{1},Target Column(AsColumn("age")));
dt << Recode Column(col,{1},Target Column(col));

dt << Graph Builder(Variables( X( As Column ("age") ) ),Elements( Points( X ) ));
dt << Graph Builder(Variables( X( col) ),Elements( Points( X ) ));

par contre : des fonctions qui ne fonctionnent pas si une colonne est saisie via As Column() :

dt = Open("$SAMPLE_DATA/Big Class.jmp");
col = Name Expr(As Column("age"));
Distribution(Column(As Column("age")));

La solution simple : enveloppez As Column avec Name Expr :

Distribution(Column(Name Expr(As Column("age")))); 

... ou utilisez Column() au lieu de As column le cas échéant :

Distribution(Column(Column("age"))); 

Pour distinguer les deux cas, vous pouvez mettre un print(1); au début de l'argumentation :

dt << Graph Builder(Variables( X( Print(1);As Column ("age") ) ),Elements( Points( X ) )); // fails

Distribution(Column(Print(1);Column("age"))); // works

Re : Est-ce que Head évalue son argument ?

---

@hogi a écrit :

l'argument est évalué (1x, comme avec Name Expr() )

Désolé:

comme avec Name Expr()

Tête():

signifie : « l' expressionArg peut être

1) un nom contenant une expression - et Head utilisera l'expression,
2) une expression - et Head l'évaluera et utilisera le résultat comme entrée
3) ou une expression littérale citée par Expr() - et Head prendra l'expression littérale".

Nom Expr():

"the expressionArg can be

1) un nom contenant une expression - et Name Expr utilisera l'expression,
2) une expression - et Name Expr prendra l'expression".

Name Expr(1+2); // 1 + 2 
Head(1+2); // 3

Re : Est-ce que Head évalue son argument ?

Autres fonctions comme Head()[ID=7]

• Tête()
• NArg()
• Arg()
  
  
• Est vide()
  
  
• Imprimer()
• Montrer()
• Écrire()

Re : Est-ce que Head évalue son argument ?

Fonctions qui évaluent leurs arguments :
[ID=2]
presque toutes les fonctions...

la plupart des fonctions « est ... » :

• Est-ce que Expr()
• Est-ce que Matrix()
• Est-ce que List()
• Est le numéro()
• Est-ce que Namespace()
• L'espace de noms existe()
  

Bon à savoir :

• Égal() (==)
• Analyser()
• Tableau associatif()

évaluer les arguments > 1er :

• Remplacer par()
• Insérer dans()
• Supprimer de()
• Attribuer()
• Arg()

Re : Est-ce que Head évalue son argument ?

Fonctions qui se comportent comme Name Expr() :
[ID=3]

"le expressionArg peut être

1) un nom contenant une expression - et Name Expr utilisera l'expression,
2) une expression - et Name Expr prendra l'expression".

• Name Expr()
• NArg()
• Extraire Expr() [les deux arguments] *)

*) trop cool !

x= Expr(Print(1));
Extract Expr(x, x) // Print(1)

Re : Est-ce que Head évalue son argument ?

Autres fonctions comme Head()
[ID=7]

"le expressionArg peut être

1) un nom contenant une expression - et Head utilisera l'expression,
2) une expression - et le chef évaluera et utilisera le résultat comme entrée
3) ou une expression littérale citée par Expr() - et Head prendra l'expression littérale".

• Tête()
• NArg()
• Arg()
  
  
• Est vide()
  
  
• Imprimer()
• Montrer()
• Écrire()

Re : Est-ce que Head évalue son argument ?

#Inspecteur d'expression

Re : Est-ce que Head évalue son argument ?

Une autre question:

Pourquoi Type évalue-t-il son argument ?

Type(Char(1)) // String !!