ExpressionScript - Presentazione
From LimeSurvey Manual
Introduzione
LimeSurvey utilizza il nuovo modulo ExpressionScript (EM) che consente a LimeSurvey di supportare branching, valutazioni, convalida e personalizzazione più complessi. Sostituisce il modo in cui LimeSurvey gestisce le sostituzioni, le Condizioni e le Valutazioni nel back-end. Inoltre, velocizza notevolmente l'elaborazione poiché elimina la maggior parte delle letture del database in fase di esecuzione. EM è stato sviluppato dal Dr. Thomas White (TMSWhite).
Definizioni chiave
- Espressione: qualsiasi cosa racchiusa tra parentesi graffe:
- Purché non vi siano spazi bianchi immediatamente dopo la parentesi graffa di apertura o prima della parentesi graffa di chiusura.
- Il contenuto dell'espressione viene valutato da EM, quindi può contenere formule matematiche, funzioni ed elaborazioni complesse di stringhe e date.
- Tailoring: A volte chiamato "piping". È il processo di modifica condizionale del testo:
- Hai accesso a tutti i "campi sostitutivi", ai dati dei partecipanti e ai dati delle risposte.
- Hai anche un accesso più facile a domande, risposte e alle loro proprietà.
- Equazione di pertinenza: un nuovo attributo della domanda che controlla la visibilità della domanda:
- Se esiste un'equazione di pertinenza, la domanda viene mostrata solo se la pertinenza è vera.
- *Internamente, tutti i comandi array_filter e array_filter_exclude diventano rilevanti a livello di sottodomanda.
- SGQA (come venivano denominate le variabili in passato) :
- Sta per Survey-Group-Question-Answer
- I nomi delle variabili SGQA hanno l'aspetto di 123X5X382X971 e possono avere suffissi di sottodomanda.
- Questi nomi di variabili sono specifici del sottostante S/Q/ Codici del database G/A, quindi spesso devono essere cambiati
- Equazione Tipo di domanda: Un nuovo tipo di domanda che salva calcoli o report nel database:! N!#*È come una domanda Boilerplate, ma il suo contenuto viene salvato nel database anche se imposti "Nascondi sempre questa domanda".
- Codice domanda: questo è il nome di variabile preferito per EM:
- Questo può essere un nome descrittivo che indica lo scopo della domanda, facilitando la lettura di logiche complesse.
- I codici domanda validi NON devono iniziare con un numero, quindi quando si utilizza il codice domanda per numerare le domande, utilizzare semplicemente "q1", o "q1a" o "g1q2".
- Questo è ciò che diventa il nome della variabile se si esportano dati in SPSS o R. Quindi, se si esegue un'analisi statistica, è necessario per creare solo codici domanda univoci.
Devo usare EM?
La risposta breve è "no". Tuttavia, questo dipende fortemente dalla complessità del sondaggio che si desidera creare.
Ad esempio, l'Editor delle condizioni copre alcune espressioni di base che possono essere applicate alle domande della tua indagine. Tuttavia, l'editor delle condizioni è limitato. Ecco perché viene utilizzato l'EM: espande il regno delle possibilità di personalizzazione.
Posso combinare equazioni di condizioni ed equazioni di rilevanza?
SÌ. Puoi utilizzare l'Editor delle condizioni per alcune domande e Equazioni di rilevanza per altre.
Non puoi avere sia condizioni che espressioni impostate nella stessa domanda! Una volta che una condizione è impostata, sostituisce qualunque espressione sia scritta nel campo dell'equazione di rilevanza. Inoltre, il campo Equazione di rilevanza non può più essere modificato manualmente.
Tuttavia, esiste un modo per utilizzare sia le espressioni che le condizioni all'interno di una domanda. Come accennato in precedenza, una condizione sostituisce il campo dell'equazione di rilevanza. Una volta fatto, controlla qual è l'equazione appena creata e copiala in un editor di testo. Elimina la condizione appena creata dall'Editor delle condizioni, quindi modifica la domanda aggiungendo le espressioni basate sulla condizione dal file dell'editor di testo insieme al resto delle espressioni che desideri utilizzare.
Come devo scegliere tra Condizioni e Rilevanza?
Ecco un elenco dei pro e dei contro di ogni stile:
| Stile | Pro | Svantaggi |
|---|---|---|
| Condizioni | 1. Bella GUI per la creazione di condizioni semplici. 2. GUI ben documentata e compresa dal team di supporto |
1. Supporta solo confronti semplici e non soddisfa le condizioni "AND" e "OR". 2. Le condizioni a cascata funzionano in modo irregolare 3. Lento - database intensivo - può rallentare lunghi sondaggi. 4. Alcuni problemi segnalati con le condizioni di ricarica. 5. La GUI non si adatta bene quando ci sono dozzine, centinaia o migliaia di domande. 6. Potrebbe essere lento convertire i sondaggi cartacei poiché devono utilizzare SGQA nomi. 7. Spesso è necessario un programmatore per la codifica personalizzata della logica necessaria per ramificazioni complesse. |
| Rilevanza | 1. Supporta logiche molto complesse, incluse oltre 80 funzioni e operatori matematici/stringa. 2. Supporto perfetto per logica a cascata. 3. Veloce: nessuna chiamata aggiuntiva al database, supporto di oltre 1000 sondaggi di domande. 4. Nessun problema con la logica di ricaricamento poiché non richiede codici SGQA. 5. L'evidenziazione della sintassi scala fino a oltre 1000 sondaggi di domande. 6. Facile e veloce da usare per i gruppi che desiderano informatizzare i sondaggi cartacei esistenti. 7. Supporta facilmente interviste semi-strutturate e indagini epidemiologiche senza bisogno di un programmatore. |
1. Nessuna GUI per condizioni semplici: utilizza invece evidenziazione della sintassi. |
{{Nota| Nota:
- Ti consigliamo di utilizzare ciò che meglio si adatta alle tue esigenze.
- Per una spiegazione più dettagliata delle funzionalità EM, fare clic sul seguente [[EM and its features|link] ]}}
Per iniziare
Il modo migliore per iniziare con EM è:
- Installare l'ultima versione stabile da https://www.limesurvey.org/en/download.
- Importa ed esplora alcuni sondaggi di esempio.
- Esplora gli casi d'uso e istruzioni e gli passaggi esempi passo-passo.
- Esplora la documentazione EM (questa pagina)
- Test unitari di espressioni isolate (avanzato)
- mostra esempi di utilizzo di tutte le funzioni e operatori EM e il Risultati PHP e JavaScript;
- nota che ci sono poche funzioni che generano risultati diversi nelle versioni PHP e JavaScript, quindi questa pagina ti consente di pianificare la tua logica EM di conseguenza.
- Test unitari di espressioni isolate (avanzato)
Terminologia
Queste parole sono comunemente usate per descrivere le capacità dell'EM:
- Branching basato sulla pertinenza - se una domanda è rilevante, allora ponila, altrimenti non farlo (ad esempio, rendila invisibile e contrassegna come NULL nel database). Puoi trovare i Campi di pertinenza nel pannello dell'editor delle domande e nel pannello dell'editor del gruppo di domande. Quest'ultimo viene utilizzato per applicare un insieme di condizioni a un intero gruppo senza dover copiare la stessa condizione a ciascuna domanda e/o combinare logica condizionale di gruppo e a livello di domanda).
- Adattamento - Una volta che sai quali domande dovrebbero essere poste, il tailoring (a volte chiamato piping) specifica come la domanda dovrebbe essere posta. Ciò ti consente di supportare non solo la semplice sostituzione (come {TOKEN:FIRSTNAME}), ma anche la coniugazione dei verbi e la declinazione dei sostantivi in base al genere o al numero dei tuoi soggetti. Ti consente inoltre di modificare il messaggio che invii a un partecipante al sondaggio in base alla risposta (o al modo in cui ha risposto) ad altre domande.
- Equazioni - EM aggiunge un nuovo tipo di domanda chiamato Equazione che memorizza il risultato di un'Espressione. I risultati dell'equazione vengono calcolati e scritti nel database, anche se li nascondi nella pagina. Pertanto, vengono utilizzati per calcoli di punteggio nascosti, navigazione basata su equazioni complesse, valutazioni e rapporti che verranno generati e archiviati all'interno del database.
Pertinenza e pertinenza a cascata
Ogni tipo di domanda ora ha una Relevance option che controlla se la domanda viene visualizzata o meno. L'EM elabora ciascuna equazione di rilevanza nell'ordine in cui appare nel sondaggio. Se l'espressione è vera (o mancante - per supportare i sondaggi precedenti), verrà visualizzata la domanda. Se non è rilevante, la domanda verrà nascosta e il valore verrà annullato nel database. Se non ci sono domande pertinenti in un gruppo, l'intero gruppo verrà saltato.
Inoltre, se una qualsiasi delle variabili all'interno di un'espressione è irrilevante, l'espressione restituisce sempre false. Questo abilita Rilevanza a cascata in modo da non dover scrivere equazioni di rilevanza molto lunghe per ogni domanda.
Supponiamo che tu abbia cinque domande Q1-Q5 e desideri solo mostrare Q2 se è stata data risposta a Q1 e Q3 se è stata data risposta a Q2, ecc. Le equazioni di rilevanza potrebbero essere:
| Codice domanda | Rilevanza | Domanda |
|---|---|---|
| Q1 | 1 | Come ti chiami? |
| Q2 | Q1 | {Q1}, quanti anni hai? |
| Q3 | Q2 | Allora, hai {Q2} anni. Sei sposato? |
| Q4 | Q3 == "Y" | {Q1}, da quanto tempo sei sposato? |
| Q5 | Q4 | Quanti figli hai, {Q1}? |
Pertinenza a livello di gruppo
ExpressionScript supporta anche la pertinenza a livello di gruppo. Ciò semplifica l'implementazione del looping. Supponiamo che tu voglia raccogliere informazioni da un massimo di 10 entità (come prodotti o persone di una famiglia), in cui prima determini quante entità necessitano di follow-up (ad esempio chiedendo quante persone vivono in una famiglia o chiedendo alle persone di controllare quale prodotti che gli piacciono da una lunga lista). Dopo aver saputo quante entità necessitano di follow-up, puoi utilizzare la pertinenza a livello di gruppo come {count >= 1}, {count >=2}, ... {count >= 10} per ciascuno dei 10 gruppi di follow- domande. All'interno di ogni gruppo, puoi avere una logica condizionale a livello di domanda (ad esempio, domande di follow-up specifiche per sesso o età per ogni materia). La domanda e le equazioni di rilevanza a livello di gruppo vengono combinate in AND insieme per determinare quale deve essere mostrato.
Per controllare un esempio di questo tipo, importa il seguente sondaggio: Census survey example.
Si può osservare nello screenshot sottostante che il gruppo Persona 1 è visualizzato (o pertinente) se l'intervistato vive con almeno un altro convivente:
Sartoria/Piping
Tutto ciò che si trova all'interno delle parentesi graffe viene ora trattato come un'espressione (con un'eccezione descritta di seguito). Le espressioni hanno accesso a tutti i LimeReplacementFields e alle variabili (tramite diversi alias), a tutti i tipici operatori di equazioni (matematici, logici e di confronto) ea dozzine di funzioni (che funzionano anche dinamicamente sul lato client).
Usando queste equazioni, puoi fare cose come:
- Mostrare in modo condizionale messaggi personalizzati agli intervistati in base alle risposte precedenti;
- Creare valutazioni e mostrare i risultati delle valutazioni (o diramare in modo condizionale o mostrare messaggi) in base a tali risultati , il tutto senza utilizzare il assessments module stesso;
- Coniuga i verbi e rifiuta i nomi all'interno di domande, risposte e rapporti;
- Mostra i riepiloghi delle risposte prima della pagina "Mostra le tue risposte" nella fine del sondaggio.
Equazioni
C'è un nuovo tipo di domanda chiamato Equazione. Pensalo come un Tipo di domanda visualizzazione testo, tranne per il fatto che memorizza il valore di ciò che viene visualizzato nel database. Pertanto, se il testo della domanda sull'equazione contiene un calcolo di valutazione, tale valore verrà archiviato nel database in una variabile che può essere visualizzata nelle statistiche pubbliche o private.
Sintassi
Tutto ciò che è contenuto all'interno delle parentesi graffe è ora considerato un'espressione (con un'eccezione: non devono esserci spazi bianchi iniziali o finali - questo è necessario per garantire che ExpressionScript non tenti di elaborare JavaScript incorporato).
Si noti che è OK che le espressioni si estendano su più righe, a condizione che non vi siano spazi bianchi dopo la parentesi graffa di apertura o prima della parentesi graffa di chiusura. Ciò è particolarmente utile per istruzioni "if()" nidificate come questa:
{if(is_empty(PFTotals),
'',
if(PFTotals >= -5 && PFTotals <= -4,
'Very Soft',
if(PFTotals >= -3 && PFTotals <= -2,
'Morbido',
if(PFTotals == -1,
'Un po' debole',
if(PFTotals == 0,
'Moderato',! N! if(PFTotals == 1,
'Un po' difficile',
if(PFTotals >= 2 && PFTotals <= 3,
'Difficile',
if(PFTotals >= 4 && PFTotals <= 5,
'Molto difficile',
''
)
)
)
)
)
)
)
)}
ExpressionScript supporta la seguente sintassi:
- Tutti gli operatori matematici standard (ad es. +,-,*,/,!);
- Tutti gli operatori di confronto standard (ad es. <,<=,==,!=,> ,>=, più i loro equivalenti: lt, le, eq, ne, gt, ge);
- Parentesi (per raggruppare le sottoespressioni);
- Operatori condizionali (es. &&,| | e i loro equivalenti: and, or);
- Stringhe con virgolette singole e doppie (ognuna delle quali può incorporare stringhe con l'altro tipo di virgolette);
- Operatore virgola (quindi può avere un elenco di espressioni e restituire solo il risultato finale );
- Operatore di assegnazione (=);
- Variabili predefinite (per fare riferimento a domande, attributi delle domande e risposte) - ad esempio, codici SGQA;
- Funzioni predefinite (ce ne sono già più di 80 ed è facile aggiungerne altre).
Operatori
La sintassi EM segue la normale precedenza degli operatori:
| Livello | Operatore(i) | Descrizione |
|---|---|---|
| 1 | () | parentesi per raggruppare o chiamare funzioni |
| 2 | ! - + | operatori unari: non, negazione, unario-più |
| 3 | * / | volte, dividere |
| 4 | + - | più , minus |
| 5 | < <= > >= lt le gt ge | confronti relativi |
| 6 | == != eq ne | confronti di uguaglianza |
| 7 | e | AND logico |
| 8 | o | OR logico |
| 9 | = | assegnazione operatore |
| 10 | , | operatore virgola |
Avviso con numero e stringa non corrispondenti e confronto alfabetico/numerico
Quando si desidera confrontare il valore con confronti relativi o di uguaglianza, prestare attenzione alle discrepanze. Un valore inserito dall'utente (o fornito tramite codice di risposta) può essere utilizzato come numero se è chiaramente un numero.
Se racchiudi uno dei valori tra " , verrà eseguito un confronto testo/stringa place. Se vuoi confrontare come numero, non racchiudere mai un numero tra " .
Ad esempio Q0.NAOK > "50" è vero se Q0.NAOK è una domanda numerica con 9 come valore. Questo perché l'operatore > presumerà che si tratti di un confronto alfabetico e non numerico .
Per assicurarti di confrontare i valori interi, puoi utilizzare intval(Q0.NAOK) > 50 . Ricorda solo che se Q0.NAOK non è un numero (vuoto o una stringa), allora intval(Q0.NAOK) === 0. Per confrontare i valori stringa ("A" < "B") usa strcmp direttamente : strcmp(Q0.NAOK,"B") o strcmp(Q0.NAOK,"A5") .
Attenzione sull'uso dell'operatore di assegnazione (=)
Dovresti evitare di utilizzare gli operatori di assegnazione a meno che non sia assolutamente necessario, poiché potrebbero causare effetti collaterali imprevisti. Ad esempio, se modifichi il valore di una risposta precedente, la pertinenza a cascata e la logica di convalida tra quella domanda e la domanda corrente non vengono ricalcolate, quindi potresti ritrovarti con dati internamente incoerenti (ad es. sono state annullate NULL o domande che sono state saltate ma avrebbero dovuto avere una risposta). In generale, se si desidera assegnare un valore a una variabile, è necessario creare un tipo di domanda Equazione e utilizzare un'espressione per impostarne il valore. Tuttavia, ci sono alcune rare volte in cui le persone hanno davvero bisogno di questo operatore, quindi l'abbiamo reso disponibile.
Per aiutarti a metterti in guardia su questo operatore, è mostrato in carattere rosso all'interno delle equazioni di sintassi (in modo da non confonderlo con "==").
Utilizzo dell'operatore di assegnazione
I motivi principali per cui potresti voler utilizzare l'operatore di assegnazione sono:
- Devi impostare il valore predefinito tramite equazione per una domanda che non accetta valori predefiniti (come list radio, dove l'interfaccia utente ti consente di scegliere uno dei le opzioni di risposta, ma non consente di inserire un'equazione). Tuttavia, fai attenzione, poiché LimeSurvey non sarà in grado di convalidare che la tua equazione generi una delle risposte consentite per quella domanda;
- Devi forzare la modifica della risposta a una domanda precedente basata su una risposta successiva;
* eccetera...
Attenzione : L'assegnazione viene eseguita solo in PHP. Ciò significa che il valore non viene aggiornato nella stessa pagina, ma solo quando l'utente passa alla pagina successiva. Pertanto, prestare attenzione quando l'operatore di assegnazione viene utilizzato nella stessa pagina con altre espressioni.
È possibile utilizzare tutto il sistema di gestione delle espressioni per questo scopo. È meglio usare una Equation per questo scopo.
Alcuni esempi:
- Imposta la risposta a una breve domanda di testo in minuscolo:
{QCODE=strtolower(QCODE.NAOK)}; - Imposta una risposta predefinita a una domanda di tipo array all'inizio di un sondaggio:
{Q1_SQ1=(is_empty(Q1_SQ1.NAOK),"A99",Q1_SQ1.NAOK)}; - Imposta una risposta predefinita a un tipo di domanda di tipo array all'inizio di un sondaggio:
{Q1_SQY1_SQX1 = (is_empty(Q1_SQY1_SQX1.NAOK),"Inserted answer", Q1_SQY1_SQX1.NAOK)}; - Imposta una risposta con condizione :
{QCODE=if(YesNo="Y","A1","")}.
Sicurezza XSS
Con XSS abilitato, alcune parti del sistema di gestione delle espressioni non possono essere utilizzate:
- inizia un tag HTML in expression ma termina con un'altra espressione;
- utilizza un'espressione complessa all'interno di un URL .
<html>Esempi e soluzioni alternative:
{if( 1 ,"","")}information{if( 1 ,"","")}funzionanti con la sicurezza XSS, qui puoi utilizzare{if(1," ;<a href="/script.php?value={if(QCODE == "Y","yes","no")}">next</a>, here you can use an equation question because using a complete question code is OK :<a href="/script.php?value={EQUATION.NAOK}">next</a>.{if(1," ;<a href="/script.php?value={if(QCODE == "Y","yes","no")}">next</a>, here you can use an equation question because using a complete question code is OK :<a href="/script.php?value={EQUATION.NAOK}">next</a>.
Accesso alle variabili
ExpressionScript fornisce l'accesso in sola lettura a qualsiasi variabile di cui potresti aver bisogno. Per compatibilità con le versioni precedenti, fornisce l'accesso a quanto segue:
- TOKEN:xxx - il valore di un TOKEN (ad es. TOKEN:FIRSTNAME, TOKEN:ATTRIBUTE_5) (solo per 'not ' sondaggio anonimo).
- INSERTANS:SGQA - il valore visualizzato di una risposta (ad es. "Sì") - simile all'utilizzo di {QCODE.shown }.
- Tutti i {XXX} valori utilizzati dai modelli.
- Nel testo della domanda, puoi utilizzare {QID} sostituito dall'id della domanda e {SGQ} sostituito dal SGQA della domanda.
Inoltre, ExpressionScript consente di fare riferimento alle variabili tramite il codice domanda (la colonna "titolo" nella tabella delle domande all'interno del database). Questa è anche l'etichetta della variabile utilizzata quando si esportano i dati in SPSS, R o SAS. Ad esempio, se hai domande su nome, età e sesso, puoi chiamare queste variabili nome, età e sesso invece di 12345X13X22, 12345X13X23' ', e 12345X13X24. Questo rende le equazioni più facili per tutti da leggere e convalidare la logica, oltre a rendere possibile mescolare le domande senza dover tenere traccia dei numeri di gruppo o delle domande.
Importante: È più sicuro fare riferimento a variabili che si verificano nelle pagine o domande precedenti.
Inoltre, ExpressionScript consente di accedere a molte proprietà della domanda:
| Sintassi | Significato | Esempio | Esempio Risultato | ||||
|---|---|---|---|---|---|---|---|
| Qcode | un alias per Qcode.code | {implode(',',name,gender )} | 'Tom','M' | ||||
| Qcode.code | il codice di risposta selezionato per la domanda se è rilevante (altrimenti vuoto), o il valore del testo se non è un domanda in codice | {implode(',',name.code,gender.code)} | 'Tom','M' | ||||
| Qcode.NAOK | uguale a Qcode - vedi discussione su NAOK | {gender.NAOK} | 'M' | ||||
| Qcode.value | il valore di valutazione per la domanda se è rilevante (altrimenti vuoto), o il valore del testo se non lo è una domanda in codice | {gender.value} | '1' | ||||
| Qcode.valueNAOK | uguale a Qcode.value - vedi discussione su NAOK | {gender.valueNAOK} | '1 ' | ||||
| Qcode.shown | il valore visualizzato per la domanda | {implode(',',name.shown,gender.shown)} | - | Qcode.question | il testo della domanda | {gender.question} | 'Qual è il tuo genere?' |
| Qcode.mandatory | se la domanda è obbligatorio (S/N) | {gender.mandatory} | 'N' | ||||
| Qcode.qid | il numero della domanda interna (non il numero progressivo) | {gender.qid} | 337 | ||||
| Qcode.type | il tipo di domanda | {gender.type} | 'G' | ||||
| Qcode.jsName | il nome javascript corretto per la domanda, indipendentemente dal fatto che sia dichiarato all'interno o all'esterno di questa pagina | {gender.jsName} | 'java1827X3X337' | ||||
| Qcode.gid | il numero di gruppo interno (non il numero sequenziale) | {gender.gid} | 3 | ||||
| Qcode.qseq | il numero progressivo della domanda, partendo da 0 | {gender.qseq} | 5 | ||||
| Qcode.gseq | il numero sequenziale del gruppo, a partire da 0 | {gender.gseq} | 1 | ||||
| Qcode.relevanceStatus | se la domanda è attualmente pertinente (0 o 1 ) | {gender.relevanceStatus} | 1 | ||||
| Qcode.relevance | l'equazione di rilevanza a livello di domanda | {gender.relevance} | '!is_empty(name)' | ||||
| Qcode.grelevance | l'equazione di rilevanza a livello di gruppo | {gender.grelevance} | 'num_children >= 5' | ||||
| Qcode.sgqa | il valore SGQA per questa domanda | {gender.sgqa} | '1827X3X337' |
Problema con l'editor HTML
Se utilizzi l'editor HTML, alcuni caratteri vengono sostituiti da entità HTML.
- & da &
- < da <
- > da >
Se usi un editor HTML devi usare :
- e for &
- lt for <
- le for <=
- gt for >
- ge per >=
Si consiglia di cancellare l'espressione dall'HTML che appare all'interno dell'espressione. Se utilizzi l'editor HTML di LimeSurvey, fai clic sul pulsante "Sorgente" (situato nella parte in alto a sinistra dell'editor) ed elimina tutti i caratteri che non sono correlati alla tua espressione (es.
,
, e così via).
Nominazione variabile Qcode
Ecco i dettagli su come costruire un Qcode (e accedere ad alcune proprietà) per tipo di domanda. In generale, i Qcode sono costruiti come:
DomandaCodice . '_'. ID domanda secondaria . '_'. ID scala
Per comment e other, i corrispondenti codici di domanda sono rispettivamente QuestionCode_comment e QuestionCode_other.
| Tipo | Descrizione | Codice | SubQs | Opzioni di risposta | Scale | Codice di risposta | Risposta mostrata | Pertinenza |
|---|---|---|---|---|---|---|---|---|
| 5 | 5 Pulsanti radio Point Choice | Q1 | 1-5 | {Q1} | {Q1.mostrato} | {Q1==3} | ||
| B | Array (10 punti di scelta) Pulsanti radio | Q2 | |1-10 | {Q2_L2} | {Q2_L2.mostrato} | {Q2_L2==7} | ||
| A | Array (scelta a 5 punti) Pulsanti radio | Q3 | |1-5 | {Q3_1} | {Q3_1.mostrato} | {Q3_1>=3} | ||
| 1 | Array (etichette flessibili) Doppia scala | Q4 | sq1-sq5 | 0 :a1-a3 | 1:b1-b3 | {Q4_sq1_0} | {Q4_sq1_1.mostrato} | {Q4_sq1_1=='b2'} |
| H | Array (flessibile) - Formato colonna | Q5 | 1-5 | s,m,t | {Q5_1} | {Q5_1.mostrato} | {Q5_1=='s'} | |
| F | Array (flessibile) - Formato riga | Q6 | |1-5 | {Q6_F3} | {Q6_F3.mostrato} | {Q6_F3==4} | ||
| E | Array (Aumenta/Uguale/Diminuisci) Pulsanti Radio | Q7 | 1- 7 | I,S,D | {Q7_4} | {Q7_4.mostrato} | {Q7_4=='D'} | |
| : | Array (Multi Flexi) da 1 a 10 | Q8 | ls1,todo ,ls2 | min,max,media | {Q8_ls1_max} | {Q8_ls2_avg.shown} | {Q8_ls2_min==7} | |
| ; | Array (Multi Flexi) Testo | Q9 | hp,st,sw | 1°,2°,3° | {Q9_hp_3rd} | {Q9_hp_3rd.shown} | {Q9_hp_3rd=='Peter'} | |
| C | Array (Sì/Incerto/No) Pulsanti radio | Q10 | 1-5 | Y,N,U | {Q10_1} | {Q10_1.mostrato} | {Q10_3=='Y'} | |
| X | Domanda standard | Q11 | {Q11.mostrato} | |||||
| G | Data | Q12 | {Q12} | {Q12.mostrato} | ||||
| * | Equazione | Q13 | {Q13} | {Q13.mostrato} | {Q13>5} | |||
| ~124~ | File Upload (registra il numero di file caricati) | Q14 | {Q14} | {Q14>0} | ||||
| G | Elenco a discesa Sesso | Q15 | M,F | {Q15} | {Q15.mostrato} | {Q15=='M'} | ||
| U | Testo libero enorme | Q16 | {Q16} | {Q16.mostrato} | {strlen(Q16)>100} | |||
| I | Domanda Lingua | Q17 | {Q17} | {Q17.mostrato} | {Q17=='it'} | |||
| ! | Lista - Dropdown | Q18 | 1-5 | {Q18} | {Q18.mostrato} | {Q18==3} | ||
| L | Elenco a discesa/Elenco pulsanti radio | Q19 | AZ | {Q19} | {Q19.mostrato} | {Q19=='X'} | ||
| O | Elenco con menu a tendina commenti/Elenco pulsanti radio + Area di testo | Q20 | AF | {Q20},{Q20comment} | {Q20.shown} | {Q20=='B'} | ||
| T | Testo libero lungo | Q21 | {Q21} | {Q21.mostrato} | {strstr(Q21,'hello')>0} | |||
| M | Casella di scelta multipla | Q22 | | | {Q22_E}, {Q22_other} | {Q22_E.shown}, {Q22_other.shown} | {Q22_E=='Y'} | ||
| P | Scelta multipla con commenti Casella di controllo + Testo | Q23 | AF | {Q23_D}, {Q23_Dcomment} | {Q23_D.mostrato} | {!is_empty(Q23)} | ||
| K | Domanda numerica multipla | Q24 | se stesso, mamma, papà | {Q24_self} | {Q24_self.mostrato} | {Q24_self>30} | ||
| Q | Testo breve multiplo | Q25 | AF | {Q25_B} | {Q25_B.mostrato} | {substr(Q25_B,1,1)=='Q'} | ||
| N | Tipo di domanda numerica | Q26 | {Q26} | {Q26.mostrato} | {Q26 > 30} | |||
| R | Stile classifica | Q27 | 1-4 | {Q27_1} | {Q27_1.mostrato} | {Q27_1==3} | ||
| S | Testo libero breve | Q28 | {Q28} | {Q28.mostrato} | {Q28=='mio'} | |||
| Y | Pulsanti radio Sì/No | Q29 | {Q29} | {Q29.mostrato} | {Q29=='S'} |
Uso di NAOK
NAOK --> "Non applicabile" (NA) va bene (OK)
L'uso di NAOK significa che tutte o alcune delle variabili sono irrilevanti (ad esempio "Non applicabile" (NA) va bene (OK)).
Ad esempio: count(Q1_SQ1,Q1_SQ2,Q1_SQ3,Q1_SQ4) restituisce sempre una stringa vuota se una sottodomanda di Q1 è filtrata. Per contare il numero di sottodomande verificate in tale domanda può essere count(Q1_SQ1.NAOK,Q1_SQ2.NAOK ,Q1_SQ3.NAOK,Q1_SQ4.NAOK). Se la sottodomanda è nascosta, l'EM restituisce una stringa vuota.
Senza NAOK, se una domanda o una sottodomanda è nascosta, l'EM restituisce sempre una stringa vuota (equivale a restituire false).
I .mostrati usano sempre il sistema NAOK (stringa vuota se nascosta) ma se hai bisogno del codice della risposta: è sempre una buona idea aggiungere .NAOK dopo il codice della domanda (tranne se ne hai bisogno e sai cosa fai).
Ulteriori informazioni sono fornite nella sottosezione Override delle condizioni a cascata.
Le variabili riservate "questo", "sé" e "quello"
Molto spesso si desidera valutare tutte le parti di una domanda, ad esempio contando quante sottodomande hanno ricevuto risposta o sommando i punteggi. Altre volte si desidera elaborare solo determinate righe o colonne di una domanda (come ottenere le somme di righe o colonne e memorizzarle nel database). Queste variabili riservate rendono tale processo relativamente indolore.
"Questa" variabile
La variabile "this" è utilizzata esclusivamente all'interno delle opzioni "Equazione di validazione dell'intera domanda" e "Equazione di validazione della sottodomanda" (l'ultima non è possibile dalla GUI). Si espande ai nomi delle variabili di ciascuna delle celle all'interno di tali domande. Quindi, se vuoi assicurarti che ogni voce sia maggiore di tre, devi impostare "Equazione di convalida della sottodomanda" su (this > 3).
"Self" variabile
Le variabili "self" e "that" sono più potenti e fungono da macro che vengono espanse prima dell'elaborazione delle equazioni. Le scelte di sintassi per la variabile "self" sono:
- self
- self.suffix
- self.sub-selector
- self.sub- selettore.suffisso
- suffisso è uno dei normali suffissi qcode (ad esempio, NAOK, valore, mostrato)
- sub-selector può essere uno dei seguenti:
- comments - solo sottodomande che sono commenti (es. scelta multipla con commento e lista con commento);
- nocomments - solo domande secondarie che non sono commenti;
- sq_X - dove X è un identificatore di riga o colonna. Vengono selezionate solo le sottodomande che corrispondono al modello X. Si noti che la ricerca viene eseguita sull'identificatore di codice completo, quindi sq_X corrisponde e include le sottodomande nX, X, Xn (ad esempio, se si utilizza sq_1, le sottodomande a1, 1a, 1, 11 o 001 sono state incluse). Prestare attenzione al tipo di domanda a doppia scala in cui il codice delle sottodomande è QCODE_SQCODE_1 e QCODE_SQCODE_1 e al tipo di domanda di classificazione in cui il codice delle sottodomande è QCODE_1,QCODE_2 ....
Esempi:
- È stata data risposta a qualche parte di una domanda? -> {count(self.NAOK)>0}
- Qual è il punteggio di valutazione per questa domanda? -> {somma(self.valore)}
Puoi anche usarli per ottenere i totali di righe e colonne. Supponi di avere un array di numeri con righe AE e colonne 1-5.
- Qual è il totale complessivo? -> {sum(self.NAOK)}
- Qual è il totale della riga B? -> {sum(self.sq_B.NAOK)}
- Qual è il totale della colonna 3? -> {somma(self.sq_3.NAOK)}
"Quella" variabile
La variabile "that" è come la variabile "self", ma ti permette di fare riferimento ad altre domande. La sua sintassi è:
- that.qname
- that.qname.suffix
- that.qname.sub-selector' '
- quello.qname.sottoselettore.suffisso
qname è il nome della domanda senza alcuna estensione della sottodomanda. Quindi, creiamo una domanda 'q1', 'q' che rappresenta anche il suo qname.
Esempi:
- È stata data risposta a qualche parte della domanda q1? -> {count(that.q1.NAOK)>0}
- Qual è il punteggio di valutazione per q2? -> {sum(that.q2.NAOK)}
- Qual è il totale complessivo di q3? -> {sum(that.q3.NAOK)}
- Qual è il totale della riga C in q4? -> {sum(that.q4.sq_C.NAOK)}
- Qual è il totale della colonna 2 in q4? -> {sum(that.q4.sq_2.NAOK)}
Le variabili "self" e "that" possono essere utilizzate in qualsiasi rilevanza, convalida o personalizzazione.
L'unica avvertenza è che quando usi la funzione Mostra file logico, ti mostrerà il valore espanso di "self" e "that". Ciò ti consente di vedere l'equazione effettiva che verrà generata in modo che tu (e l'EM) possiate convalidare se le variabili esistono o meno. Questo può sembrare confuso poiché potresti vedere equazioni piuttosto lunghe. Tuttavia, se modifichi la domanda, vedrai l'equazione originale usando "self" e/o "that".
Accesso alle funzioni
ExpressionScript fornisce l'accesso a funzioni matematiche, stringhe e definite dall'utente, come illustrato di seguito. Ha equivalenti PHP e JavaScript per queste funzioni in modo che funzionino in modo identico sul lato server (PHP) e sul lato client (JavaScript). È facile aggiungere nuove funzioni.
Funzioni implementate
Attualmente sono disponibili le seguenti funzioni:
| Function | Meaning | Syntax |
|---|---|---|
| abs | Absolute value | number abs(number) |
| acos | Arc cosine | number acos(number) |
| addslashes | Quote string with slashes | string addslashes(string) |
| asin | Arc sine | number asin(number) |
| atan | Arc tangent | number atan(number) |
| atan2 | Arc tangent of two variables | number atan2(number, number) |
| ceil | Round fractions up | number ceil(number) |
| checkdate | Returns true(1) if it is a valid date in gregorian calendar | bool checkdate(month,day,year) |
| convert_value | Convert a numerical value using a inputTable and outputTable of numerical values | number convert_value(fValue, iStrict, sTranslateFromList, sTranslateToList) |
| cos | Cosine | number cos(number) |
| count | count the number of answered (non-blank) questions in the list | number count(arg1, arg12, ..., argN) |
| countif | Count the number of answered questions in the list equal to the first argument | number countif(matches, arg1, arg2, ... argN) |
| countifop | Count the number of answered questions in the list which pass the criteria (arg op value) | number countifop(op, value, arg1, arg2, ... argN) |
| date | Format a local date/time | string date(format [, timestamp=time()]) |
| exp | Calculates the exponent of e | number exp(number) |
| fixnum | Display numbers with comma as radix separator, if needed | string fixnum(number) |
| floor | Round fractions down | number floor(number) |
| gmdate | Format a GMT date/time | string gmdate(format [, timestamp=time()]) |
| html_entity_decode | Convert all HTML entities to their applicable characters (always uses ENT_QUOTES and UTF-8) | string html_entity_decode(string) |
| htmlentities | Convert all applicable characters to HTML entities (always uses ENT_QUOTES and UTF-8) | string htmlentities(string) |
| expr_mgr_htmlspecialchars | Convert special characters to HTML entities (always uses ENT_QUOTES and UTF-8) | string htmlspecialchars(string) |
| expr_mgr_htmlspecialchars_decode | Convert special HTML entities back to characters (always uses ENT_QUOTES and UTF-8) | string htmlspecialchars_decode(string) |
| idate | Format a local time/date as integer | string idate(string [, timestamp=time()]) |
| if | Excel-style if(test,result_if_true,result_if_false) | if(test,result_if_true,result_if_false) |
| implode | Join array elements with a string | string implode(glue,arg1,arg2,...,argN) |
| intval | Get the integer value of a variable | int intval(number [, base=10]) |
| is_empty | Determine whether a variable is considered to be empty | bool is_empty(var) |
| is_float | Finds whether the type of a variable is float | bool is_float(var) |
| is_int | Find whether the type of a variable is integer | bool is_int(var) |
| is_nan | Finds whether a value is not a number | bool is_nan(var) |
| is_null | Finds whether a variable is NULL | bool is_null(var) |
| is_numeric | Finds whether a variable is a number or a numeric string | bool is_numeric(var) |
| is_string | Find whether the type of a variable is string | bool is_string(var) |
| join (New in 2.0 build 130129) | Join elements as a new string | join(arg1, arg2, ... argN) |
| list | Return comma-separated list of non-blank values | string list(arg1, arg2, ... argN) |
| listifop (New in 3.16.1 ) | Return a 'glue'-separated list of the specified question property (retProp) from questions in the list which pass the criteria (cmpProp op value) | string listifop(cmpProp, op, value, retProp, glue, sgqa1, sgqa2, ... sgqaN) |
| ltrim | Strip whitespace (or other characters) from the beginning of a string | string ltrim(string [, charlist]) |
| max | Find highest value | number max(arg1, arg2, ... argN) |
| min | Find lowest value | number min(arg1, arg2, ... argN) |
| mktime | Get UNIX timestamp for a date (each of the 6 arguments are optional) | number mktime([hour [, minute [, second [, month [, day [, year ]]]]]]) |
| modulo-function | The modulo function is not supported yet. You can use the floor() function instead | floor(x/y)==(x/y) |
| nl2br | Inserts HTML line breaks before all newlines in a string | string nl2br(string) |
| number_format | Format a number with grouped thousands | string number_format(number) |
| pi | Get value of pi | number pi() |
| pow | Exponential expression | number pow(base, exp) |
| quoted_printable_decode | Convert a quoted-printable string to an 8 bit string | string quoted_printable_decode(string) |
| quoted_printable_encode | Convert a 8 bit string to a quoted-printable string | string quoted_printable_encode(string) |
| quotemeta | Quote meta characters | string quotemeta(string) |
| rand | Generate a random integer, see this example | int rand() OR int rand(min, max) |
| regexMatch | compare a string to a regular expression | bool regexMatch(pattern,input) |
| round | Rounds a number to an optional precision | number round(val [, precision]) |
| rtrim | Strip whitespace (or other characters) from the end of a string | string rtrim(string [, charlist]) |
| sin | Sine | number sin(arg) |
| sprintf | Return a formatted string | string sprintf(format, arg1, arg2, ... argN) |
| sqrt | Square root | number sqrt(arg) |
| stddev | Calculate the Sample Standard Deviation for the list of numbers | number stddev(arg1, arg2, ... argN) |
| str_pad | Pad a string to a certain length with another string | string str_pad(input, pad_length [, pad_string]) |
| str_repeat | Repeat a string | string str_repeat(input, multiplier) |
| str_replace | Replace all occurrences of the search string with the replacement string | string str_replace(search, replace, subject) |
| strcasecmp | Binary safe case-insensitive string comparison | int strcasecmp(str1, str2) |
| strcmp | Binary safe string comparison | int strcmp(str1, str2) |
| strip_tags | Strip HTML and PHP tags from a string | string strip_tags(str, allowable_tags) |
| stripos | Find position of first occurrence of a case-insensitive unicode string (starting by 0, return false if not found) | int stripos(haystack, needle [, offset=0]) |
| stripslashes | Un-quotes a quoted string | string stripslashes(string) |
| stristr | Case-insensitive strstr | string stristr(haystack, needle [, before_needle=false]) |
| strlen | Get string length | int strlen(string) |
| strpos | Find position of first occurrence of an unicode string (starting by 0, return false if not found) | int strpos(haystack, needle [ offset=0]) |
| strrev | Reverse a string | string strrev(string) |
| strstr | Find first occurrence of a string | string strstr(haystack, needle[, before_needle=false]) |
| strtolower | Make a string lowercase | string strtolower(string) |
| strtotime | Parse about any English textual datetime description into a Unix timestamp | int strtotime(string) |
| strtoupper | Make a string uppercase | string strtoupper(string) |
| substr | Return part of an unicode string | string substr(string, start [, length]) |
| sum | Calculate the sum of values in an array | number sum(arg1, arg2, ... argN) |
| sumifop | Sum the values of answered questions in the list which pass the criteria (arg op value) | number sumifop(op, value, arg1, arg2, ... argN) |
| tan | Tangent | number tan(arg) |
| time | Return current UNIX timestamp | number time() |
| trim | Strip whitespace (or other characters) from the beginning and end of a string | string trim(string [, charlist]) |
| ucwords | Uppercase the first character of each word in a string | string ucwords(string) |
| unique | Returns true if all non-empty responses are unique | boolean unique(arg1, ..., argN) |
Crea nuove funzioni di espressione con il plugin (New in 4.0.0 )
Se hai bisogno di una nuova funzione che non esiste nel core, puoi crearne una con un plugin. Tale nuova funzione viene creata utilizzando l'evento expressionManagerStart.
ExpressionScript sa quali variabili sono local
Per creare correttamente il JavaScript per una pagina, EM deve sapere quali variabili sono impostate sulla pagina e qual è il loro ID JavaScript (ad esempio, per document.getElementById(x)). Deve anche sapere quali variabili sono impostate su altre pagine (in modo da poter garantire che i file necessari<input type='hidden' value='x'> i campi sono presenti e popolati).
Condizioni a cascata
Se una qualsiasi delle variabili è irrilevante, l'intera equazione sarà irrilevante (falso). Ad esempio, nella tabella seguente, N/A significa che una delle variabili non era rilevante:
| Operatore | Esempio | a | b | Risultato | |||||
|---|---|---|---|---|---|---|---|---|---|
| + (unario) | +a | N/D | falso | ||||||
| ! | !a | N/A | false | ||||||
| == (o eq) | a == b | N/A | 5 | false | |||||
| == (o eq) | a == b | N/A | 0 | false | |||||
| == (o eq) | a == b | N/A | N/A | false | |||||
| != (o ne) | a != b | N/A | 5 | false | |||||
| != (o ne) | a != b | N/A | N/A | false | |||||
| != (o ne) | a != b | N/A | 0 | false | |||||
| > (o gt) | a > b | N/A | 5 | false | |||||
| >= (o ge) | a >= b | N/A | 5 | false | |||||
| < (o lt) | a < b | N/A | 5 | false | |||||
| <= (o le) | a <= b | N/A | 5 | false | |||||
| e | a e b | N/A | 5 | falso | |||||
| e | a e b | N/A | N/A | - | o | a o b | N/A | N/A | falso |
| o | a o b | N/A | 5 | falso | |||||
| + | a + b | N/A | 5 | falso | |||||
| * | a * b | N/A | 5 | falso | |||||
| / | a / b | 5 | N/A | falso | |||||
| (exp) | (a && b) | N/A | 5 | false | |||||
| |(b + b) > (a && b) | N/A | 5 | false | ||||||
| funzione | sum(a,b,b) | N/A | 5 | falso | |||||
| funzione | max(a,b) | N/A | 5 | falso | |||||
| funzione | min(a,b ) | N/A | 5 | false | |||||
| funzione | implode(', ',a,b,a,b) | N/A | 5 | - | funzione | if(a,a,b) | N/A | 5 | false |
| funzione | è_vuoto(a) | N/ A | false | ||||||
| funzione | è_vuoto(a) | 0 (o vuoto) | vero | ||||||
| funzione | !è_vuoto(a) | N/A | falso |
Sovrascrivere le condizioni a cascata
Supponi di voler mostrare un totale parziale di tutte le risposte pertinenti. Potresti provare a usare l'equazione {sum(q1,q2,q3,...,qN)}. Tuttavia, questo viene tradotto internamente in LEMif(LEManyNA("q1","q2","q3",...,"qN"),"",sum(LEMval("q1"),LEMval("q2") ,LEMval("q3"),...,LEMval("qN"))). Quindi, se uno qualsiasi dei valori q1-qN è irrilevante, l'equazione restituirà sempre false. In questo caso, sum() mostrerà "0" fino a quando non verrà data risposta a tutte le domande.
To get around this, each variable can have a ".NAOK" suffix (meaning that Not Applicable is OK) added to it. In such cases, the following behavior occurs. Say you have a variable q1.NAOK:
- q1 is not added to the LEManyNA() clause
- LEMval('q1') will continue to check whether the response is relevant and will return "" if it is not (so individual irrelevant responses will be ignored, but they will not void the entire expression).
So, the solution to the running total problem is to use the equation sum(q1.NAOK,q2.NAOK,q3.NAOK,...,qN.NAOK).
The use of the .NAOK suffix also lets authors design surveys that have several possible paths but then converge on common paths later. For example, say subjects answer a survey in a way that is outside the normal range of responses. The author could alert the subjects that they may not get valid results, and ask them whether they really want to continue with the survey. If they say "Yes", then the rest of the questions will be shown. The condition for the "rest of the questions" would check whether the initial responses were answered within the normal range OR whether the subject said "Yes" to the question that is only relevant if they answered outside the normal range.
How does ExpressionScript support conditional micro-tailoring?
Here is an example of micro-tailoring (where Question Type=='expr' means an Equation):
| Question Code | Relevance | Question Type | Question |
|---|---|---|---|
| name | 1 | text | What is your name? |
| age | 1 | text | How old are you? |
| badage | !is_empty(age) | expr | {(age<16) or (age>80)} |
| agestop | badage | message | Sorry, {name}, you are too {if( (age<16),'young',if( (age>80),'old','middle-aged') ) } for this test. |
| kids | !badage | yesno | Do you have children? |
| parents | 1 | expr | {!badage && kids=='Y'} |
| numKids | parents | text | How many children do you have? |
| kid1 | parents && numKids >= 1 | text | How old is your first child? |
| kid2 | parents && numKids >= 2 | text | How old is your second child? |
| kid3 | parents && numKids >= 3 | text | How old is your third child? |
| kid4 | parents && numKids >= 4 | text | How old is your fourth child? |
| kid5 | parents && numKids >= 5 | text | How old is your fifth child? |
| sumage | 1 | expr | {sum(kid1.NAOK,kid2.NAOK,kid3.NAOK,kid4.NAOK,kid5.NAOK)} |
| report | parents | text | {name}, you said you are {age} and that you have {numKids}. The sum of ages of your first {min(numKids,5)} kids is {sumage} |
To download the above survey example, click on the following link: Number of kids survey example.
All of these questions can be on a single page (e.g., in the same group), and only the relevant questions will be displayed. Moreover, as you enter the ages of children, the sum() expression in the last question will dynamically get updated.
ExpressionScript provides this functionality by surrounding each expression with a named <span> element. Every time a value changes, it recomputes the expression that should appear in that <span> element and regenerates the display. You can have dozens or even hundreds of such tailored expressions on the same page.
Syntax highlighting
To help with entering and validating expressions, the EM provides syntax highlighting with the following features:
Types and Meanings of Syntax Highlighting
| Color | Sample | Meaning | Tooltip | Comments |
|---|---|---|---|---|
| tan background | Sample | the whole equation | none | Anything within curly braces that is recognized as an equation (e.g., there is no leading or trailing whitepace) will be color-coded with a tan background to help distinguish it from surrounding text |
| bold red text | Sample | An error | Some explanation on error | Can be an unknow variable or an error in function. Survey is broken and the questions that rely on the respective expression will not be shown to the respondents. |
| blue text | Sample | function name | meaning and allowable syntax | It refers to function names or things that should be functions since they are followed by an open parenthesis. They are displayed in bold blue text. Tooltips show the meaning and allowable syntax for the function. |
| grey text | Sample | string | none | Single and double-quoted strings are shown in grey text. |
| cyan text | Sample | variable set on the same page, | [name or SGQA code]: question; value; answerList showing codes for each value | Any variable that is set on the same page as the question you are currently editing is shown in cyan text (it can be updated in javascript). The tooltip shows its name (if you used INSERTANS:xxx) or its SGQA code (if you used the new naming system), the actual question, and its current value (or blank if not set). If the question type expects responses from an enumerated value set, the mapping of the codes to display values is shown. |
| green text | Sample | variable set on a prior page | [name or SGQA code]: question; value; answerList showing codes for each value | Any variable that is set on a prior page is shown in bold green text. The tooltip shows its name (if you used INSERTANS:xxx) or SGQA code (if you used the new naming system), the actual question, and its current value (or blank if not set). If the question type expects responses from an enumerated value set, the mapping of the codes to display values is shown. |
| bold pink text | Sample | variable set on a later page in general : empty at survey start, but can be filled with index or move previous | [name or SGQA code]: question; value; answerList showing codes for each value | Any variable that is set on a prior page is shown in bold pink text. The tooltip shows its name (if you used INSERTANS:xxx) or SGQA code (if you used the new naming system), the actual question, and its current value (or blank if not set). If the question type expects responses from an enumerated value set, the mapping of the codes to display values is show. |
| bold tan text | Sample | a lime replacement value | the value | Lime Replacement Strings (like {TOKEN:xxx}, {PRIVACY_MESSAGE}) are shown in bold tan text. |
| red text | Sample | assignment operator (=) | warning message | If you use one of the assignment operator (=), that operator will be displayed in red text. This is meant to help prevent accidental re-assignment of values when you really meant to check whether a == b instead of setting the value of a = b. |
| normal black text | Sample | punctuation | none | All other punctuation signs within the expression are shown as normal black text. |
| red-boxed text | a bold red line surrounds the error | syntax error | description of the error | Any detected syntax errors are shown within red boxes. The tooltip shows the error. Examples include unmatched parentheses, use of undefined functions, passing the wrong number of arguments to functions, poorly structured expressions (e.g., missing operators between variables), trying to assign a new value to a read-only variable, trying to assign values to non-variables, or using unsupported syntax. Note that the syntax error dectection system may only report one error in an expression even if there are multiple errors; however, if any errors are detected, at least one error will be shown. |
By tooltips, we refer to the popup message that is displayed when you hover over certain functions and variables.