Il linguaggio di scripting di JMP, JSL, è costituito da chiamate di funzione. Praticamente tutto ciò che puoi scrivere in JSL è una chiamata di funzione. Alcune cose non sembrano chiamate di funzione:
A = A + 3;
È abbastanza ovvio che il lato destro dell'istruzione di assegnazione è un'espressione. È meno ovvio che l'istruzione di assegnazione stessa sia un'espressione.
E = expr ( A = A + 3 );
expr è un wrapper che è possibile utilizzare intorno a un'espressione per impedire la valutazione dell'espressione. E è impostato sull'espressione, non sul risultato valutato dell'espressione. Per dare un'occhiata a E, usa la funzione head. Head restituirà il nome della funzione alla radice dell'espressione:
show( head(E) );
Testa(E) = Assegna();
Ora vedi che c'è una funzione per fare incarichi:
Assign( testing, 3+4 );
7
show(testing)
prova = 7;
Le espressioni in JSL sono in realtà alberi. Ecco un'immagine dell'albero a=a+3, radice in alto, foglie in basso:
Simile alla funzione Head, possiamo utilizzare la funzione Arg per accedere ai figli della funzione Assign:
show( arg(E,1) );
Arg(E, 1) = A; il lato sinistro
show( arg(E,2) );
Arg(E, 2) = A + 3; il lato destro
e scavare più a fondo,
show(head(arg(E,2)))
Testa(Arg(E, 2)) = Aggiungi(); la testa del lato destro
show(arg(arg(E,2),1))
Arg(Arg(E, 2), 1) = A; il lato sinistro del segno più
show(arg(arg(E,2),2))
Arg(Arg(E, 2), 2) = 3; il lato destro del segno più
Si noti come l'annidamento delle parentesi descriva l'albero. Questo albero ha solo divisioni binarie. C'è una funzione, narg , che restituisce il numero di figli. Restituisce 0 per i nodi foglia.
narg(E)
2 la funzione di assegnazione ha due argomenti, il lato sinistro e il lato destro
di JMP per statement è una chiamata di funzione, che accetta quattro argomenti. Notare le virgole che separano gli argomenti, proprio come qualsiasi altra funzione.
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
Sono necessarie tre virgole per separare quattro argomenti. In questo per istruzione, il quarto argomento è costituito da due istruzioni, separate da un punto e virgola. Dai un'occhiata al quarto argomento per vedere se in realtà è anche una funzione:
Head(
Arg(
Expr(
For( iCat = 1, iCat <= 10, iCat++,
halfCats = halfCats / 2;
Write( iCat, " ", halfCats, "\!n" );
)
),
4 /* the fourth arg */
)
);
Colla()
Colla è il nome della funzione che tiene insieme una sequenza di istruzioni.Colla il primo argomento di è la prima affermazione, ecc.
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 */
);
metàGatti = metàGatti / 2
Un elenco JSL è lo stesso tipo di espressione:
list={33,44,55};
show(head(list));
show(narg(list));
show(arg(list,3));
Testa(lista) = {}; list mostra parentesi graffe per la testa, piuttosto che un nome come Assegnare
N Arg(lista) = 3;
Arg(lista, 3) = 55;
Se vuoi solo il contenuto dell'elenco, dovresti usare il normale abbonamento:
show(list[3]);
lista[3] = 55;
Ma a volte vuoi fare qualcosa come trasformare un elenco in argomenti per una funzione.
Nel Elefante post troverai un esempio di trasformazione di un elenco in uno schema (riga 5). Ho difficoltà a trovare un altro esempio interessante come quello, ma supponiamo che tu voglia controllare se l'elenco è in ordine alfabetico. L'operatore < di JMP può farlo in una singola chiamata di funzione:
LT = expr("a"<"b"<"c"<"d");
show(head(LT));
show(narg(LT));
Testa(LT) = Meno(); l'operatore minore di visualizza un nome di funzione, Meno
NArg(LT) = 4;
La funzione Less può accettare molti argomenti, ma non è necessario digitarli. Sotto, NomeEspr sta recuperando l'espressione memorizzata in parole, dopo il SostituisciInto modificato il { elenco } essere Meno (). JMP quindi visualizza la funzione Less utilizzando < per renderla più leggibile.
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" < "Hotel" <
"India" < "Juliet" < "Kilo" < "Lima" < "Mike" < "Novembre" < "Oscar" < "Papa" <
"Quebec" < "Romeo" < "Sierra" < "Tango" < "Uniform" < "Victor" < "Whisky" < "Xray" < "Yankee" < "Zulù"
eval(words)
1 eval (parole) restituisce 1, indicando che il risultato di Less era vero.
Un altro esempio.
Aggiornamento 28 febbraio 2017: riparazione della formattazione per la nuova community
Craig, questo articolo mi è stato molto utile nella mia continua ricerca per capire come gestire le espressioni.
In realtà avevo una buona applicazione per il tuo trucco finale, in cui hai trasformato gli elementi in un elenco in argomenti della funzione Less(). Volevo generare una formula di colonna contenente la funzione Col Mean(), basata sull'input dell'utente da una finestra di dialogo. La funzione Col Means() accetta uno o più argomenti e non ho mai avuto modo di sostituire un numero variabile di argomenti (spesso nomi di variabili) in una funzione. Ecco le linee chiave della mia sceneggiatura:
arglist = {"altezza", "età", "sesso"}; // risulta da una finestra di dialogo
statformula = Sostituisci ( arglist, Expr( {} ), Expr( Col Mean() ) ); // gli elementi in arglist diventano argomenti nella funzione Col Means()
newcol << Formula( Nome Expr( statformula ) );
Lo script vero e proprio è più complesso perché deve gestire nomi di colonna disordinati che richiedono Name(" "), ma si ottiene l'idea. Grazie per avermi mostrato questo trucchetto.
Howard Rauch
