ExpressionScript - Presentation

Introduktion

LimeSurvey använder Uttrycksskript (Expression Script), vilket gör att LimeSurvey kan stödja mer komplex förgrening, bedömningar, validering och anpassning. Det ersätter hur LimeSurvey hanterar ersättningar, beroenden och bedömningar i bakgrunden. Det snabbar också upp bearbetningen avsevärt eftersom nästan alla databasläsningar vid körning elimineras. Expression Script utvecklades av Dr. Thomas White (TMSWhite).

Viktiga definitioner

1. Uttryck: Allt som omges av klammerparenteser:
   • Så länge det inte finns något blanksteg direkt efter den inledande klammerparentesen eller före den avslutande klammerparentesen.
   • Innehållet i uttrycket utvärderas av EM, så det kan innehålla matematiska formler, funktioner samt avancerad text- och datumbearbetning.
2. Anpassning: Kallas ibland "piping". Det är processen att villkorligt ändra text:
   • Du har tillgång till alla ersättningsfält, deltagardata och svarsdata.
   • Du har också enklare tillgång till frågor, svar och deras egenskaper.
3. Relevansekvation: Ett nytt frågeattribut som styr om en fråga visas:
   • Om det finns en relevansekvation visas frågan bara om relevansen utvärderas som sann.
   • Internt blir alla kommandon för array_filter och array_filter_exclude relevans på delfrågenivå.
4. SGQA (hur variabler namngavs tidigare):
   • Står för Survey-Group-Question-Answer (enkät-grupp-fråga-svar)
   • SGQA-variabelnamn ser ut som 123X5X382X971 och kan ha suffix för delfrågor.
   • Dessa variabelnamn är specifika för de underliggande databaskoderna för S/Q/G/A, så de behöver ofta ändras
5. Ekvation-frågetyp: En ny frågetyp som sparar beräkningar eller rapporter i databasen:
   • Den är som en Boilerplate-fråga, men dess innehåll sparas i databasen även om du har valt "Dölj alltid denna fråga".
6. Frågekod: Detta är det föredragna variabelnamnet för EM:
   • Det kan vara ett beskrivande namn som anger frågans syfte, vilket gör komplex logik lättare att läsa.
   • Giltiga frågekoder får INTE börja med en siffra, så om du använder frågekoden för att numrera dina frågor kan du helt enkelt använda "q1", "q1a" eller "g1q2".
   • Detta blir variabelnamnet om du exporterar data till SPSS eller R. Om du gör statistiska analyser behöver du alltså endast skapa unika frågekoder.

Måste jag använda Uttrycksskript?

Det korta svaret är "nej". Det beror dock i hög grad på hur komplex enkät du vill skapa.

Till exempel täcker beroenderedigeraren några grundläggande uttryck som kan tillämpas på frågorna i din enkät. Beroenderedigeraren är dock begränsad. Därför används Uttrycksskript - det utökar anpassningsmöjligheterna.

Kan jag blanda beroenden och relevansekvationer?

Ja. Du kan använda beroenderedigeraren för vissa frågor och relevansekvationer för andra.

Du kan inte ha både beroenden och uttryck inställda i samma fråga! När ett beroende har ställts in ersätter det vilket uttryck som än står i fältet för relevansekvation. Dessutom kan fältet Relevansekvation inte längre redigeras manuellt.

Det finns dock ett sätt att använda både uttryck och beroenden i en fråga. Som nämnts ovan ersätter ett beroende fältet för relevansekvation. När det är gjort, kontrollera vilken ekvation som skapats och kopiera den till en textredigerare. Radera det nyskapade beroendet i beroenderedigeraren och redigera sedan frågan genom att lägga till de beroendebaserade uttrycken från din textfil tillsammans med de övriga uttryck du vill använda.

Hur ska jag välja mellan beroenden och relevans?

Här är en lista över för- och nackdelar med respektive metod:

Metod	Fördelar	Nackdelar
Beroenden	1. Ett trevligt gränssnitt för att skapa enkla villkor. 2. Gränssnittet är väl dokumenterat och förstås av supportteamet	1. Stöder endast enkla jämförelser och hanterar inte villkor med "OCH" och "ELLER" särskilt bra. 2. Kaskadvillkor fungerar oregelbundet 3. Långsamt - databasintensivt - kan göra långa enkäter långsamma. 4. Vissa rapporterade problem med att ladda om villkor. 5. Gränssnittet skalar dåligt när det finns dussintals, hundratals eller tusentals frågor. 6. Det kan gå långsamt att konvertera pappersbaserade enkäter eftersom SGQA-namn måste användas. 7. Ofta behövs en programmerare för att koda den logik som krävs för komplex förgrening.
Relevans	1. Stöder mycket komplex logik, inklusive över 80 funktioner samt matematiska operatorer och strängoperatorer. 2. Perfekt stöd för kaskadlogik. 3. Snabbt - inga extra databasanrop, stöder enkäter med över 1000 frågor. 4. Inga problem med att ladda om logik eftersom SGQA-koder inte krävs. 5. Syntaxmarkering skalar till enkäter med över 1000 frågor. 6. Enkelt och snabbt att använda för grupper som vill datorisera befintliga pappersbaserade enkäter. 7. Stöder enkelt semistrukturerade intervjuer och epidemiologiska enkäter utan att en programmerare behövs.	1. Inget gränssnitt för enkla villkor - i stället används syntaxmarkering.

Observera:

• Vi rekommenderar att du använder det som passar dina behov bäst.
• För en mer detaljerad förklaring av EM:s funktioner, klicka på följande länk.

Komma igång

Det bästa sättet att komma igång med EM är att:

• Installera den senaste stabila versionen från https://www.limesurvey.org/en/download.
• Importera och utforska några exempelenkäter.
• Utforska användningsfall och instruktioner samt steg-för-steg-exemplen.
• Utforska EM-dokumentationen (denna sida)
  • Enhetstester av isolerade uttryck (avancerat)
    • visar exempel på användning av alla EM-funktioner och operatorer samt resultaten i PHP och JavaScript;
    • observera att det finns några få funktioner som ger olika resultat i PHP- och JavaScript-versionerna, så på den sidan kan du planera din EM-logik i enlighet med detta.

Terminologi

Dessa ord används ofta för att beskriva EM:s möjligheter:

• Relevansbaserad förgrening - om en fråga är relevant ställs den, annars inte (t.ex. görs den osynlig och markeras som NULL i databasen). Du hittar relevansfälten i frågeredigerarens panel samt i frågegruppsredigerarens panel. Det senare används för att tillämpa en uppsättning villkor på en hel grupp utan att behöva kopiera samma villkor till varje fråga, och/eller för att kombinera villkorlig logik på grupp- och frågenivå.
• Anpassning - När du vet vilka frågor som ska ställas anger anpassning (ibland kallad piping) hur frågan ska ställas. Det gör att du inte bara kan stödja enkel ersättning (som {TOKEN:FIRSTNAME}), utan också böjning av verb och substantiv baserat på dina ämnens kön eller antal. Du kan också ändra det meddelande du ger en enkätdeltagare beroende på om (eller hur) de besvarade andra frågor.
• Ekvationer - EM lägger till en ny frågetyp som kallas Ekvation och som lagrar resultatet av ett uttryck. Ekvationsresultaten beräknas och skrivs till databasen, även om du döljer dem på sidan. De används därför för dolda poängberäkningar, navigering baserad på komplexa ekvationer, bedömningar och rapporter som genereras och lagras i databasen.

Relevans och kaskadrelevans

Varje frågetyp har nu ett relevansalternativ som styr om frågan visas eller inte. EM bearbetar varje relevansekvation i den ordning de förekommer i enkäten. Om uttrycket är sant (eller saknas - för att stödja äldre enkäter) visas frågan. Om den inte är relevant döljs frågan och värdet sätts till NULL i databasen. Om det inte finns några relevanta frågor i en grupp hoppas hela gruppen över.

Dessutom gäller att om någon av variablerna i ett uttryck är irrelevant utvärderas uttrycket alltid som falskt. Detta möjliggör kaskadrelevans så att du slipper skriva mycket långa relevansekvationer för varje fråga.

Säg att du har fem frågor, Q1-Q5, och att du bara vill visa Q2 om Q1 besvarades, Q3 om Q2 besvarades, osv. Relevansekvationerna kan då vara:

Frågekod	Relevans	Fråga
Q1	1	Vad heter du?
Q2	Q1	{Q1}, hur gammal är du?
Q3	Q2	Så du är {Q2} år gammal. Är du gift?
Q4	Q3 == "Y"	{Q1}, hur länge har du varit gift?
Q5	Q4	Hur många barn har du, {Q1}?

Relevans på gruppnivå

ExpressionScript stöder också relevans på gruppnivå. Det gör det enklare att implementera loopar. Säg att du vill samla in information om upp till 10 enheter (till exempel produkter eller personer i ett hushåll), där du först avgör hur många enheter som behöver följdfrågor (till exempel genom att fråga hur många personer som bor i hushållet eller låta deltagare markera vilka produkter de gillar i en lång lista). När du vet hur många enheter som behöver följdfrågor kan du använda relevans på gruppnivå som {count >= 1}, {count >=2}, ... {count >= 10} för var och en av de 10 grupperna med följdfrågor. Inom varje grupp kan du ha villkorlig logik på frågenivå (t.ex. köns- eller åldersspecifika följdfrågor för varje ämne). Relevansekvationerna på fråge- och gruppnivå kombineras med OCH för att avgöra vad som ska visas.

För att titta på ett sådant exempel, importera följande enkät: Exempel på folkräkningsenkät.

På skärmbilden nedan kan man se att gruppen Person 1 visas (eller är relevant) om respondenten bor tillsammans med minst en annan person:

Skräddarsydd text/Piping

Allt inom klammerparenteser behandlas nu som ett uttryck (med ett undantag som beskrivs nedan). Uttryck har tillgång till alla LimeReplacementFields och variabler (via flera alias), alla vanliga ekvationsoperatorer (matematiska, logiska och jämförelseoperatorer) samt dussintals funktioner (som till och med fungerar dynamiskt på klientsidan).

Med hjälp av dessa ekvationer kan du till exempel:

1. Villkorligt visa skräddarsydda meddelanden för respondenterna baserat på tidigare svar;
2. Skapa utvärderingar och visa utvärderingsresultat (eller villkorligt förgrena eller visa meddelanden) baserat på dessa resultat, helt utan att använda själva utvärderingsmodulen;
3. Böja verb och substantiv i frågor, svar och rapporter;
4. Visa sammanfattningar av svar före sidan "Visa dina svar" i slutet av enkäten.

Ekvationer

Det finns en ny frågetyp som heter Ekvation. Se den som en frågetypen Textvisning, förutom att den lagrar värdet av det som visas i databasen. Om ekvationsfrågans frågetext innehåller en utvärderingsberäkning lagras alltså det värdet i databasen i en variabel som kan visas i offentlig eller privat statistik.

Syntax

Allt som står inom klammerparenteser betraktas nu som ett uttryck (med ett undantag: det får inte finnas inledande eller avslutande blanksteg - detta krävs för att ExpressionScript inte ska försöka bearbeta inbäddad JavaScript).

Observera att uttryck gärna får sträcka sig över flera rader, så länge det inte finns något blanksteg efter den inledande klammerparentesen eller före den avslutande. Detta är särskilt användbart för nästlade "if()"-satser som denna:

{if(is_empty(PFTotals),
 '',
 if(PFTotals >= -5 && PFTotals <= -4,
   'Very Soft',
   if(PFTotals >= -3 && PFTotals <= -2,
     'Soft',
     if(PFTotals == -1,
       'Somewhat Soft',
       if(PFTotals == 0,
         'Moderate',
         if(PFTotals == 1,
           'Somewhat Hard',
           if(PFTotals >= 2 && PFTotals <= 3,
             'Hard',
             if(PFTotals >= 4 && PFTotals <= 5,
               'Very Hard',
               ''
             )
           )
         )
       )
     )
   )
 )
)}

ExpressionScript stöder följande syntax:

• Alla vanliga matematiska operatorer (t.ex. +,-,*,/,!);
• Alla vanliga jämförelseoperatorer (t.ex. <,<=,==,!=,>,>=, samt deras motsvarigheter: lt, le, eq, ne, gt, ge);
• Parenteser (så att du kan gruppera deluttryck);
• Villkorsoperatorer (t.ex. &&,| | och deras motsvarigheter: and, or);
• Strängar inom enkla och dubbla citattecken (som vardera kan innehålla strängar med den andra citattecknetypen);
• Kommaoperator (så att du kan ha en lista med uttryck och bara returnera det sista resultatet);
• Tilldelningsoperator (=);
• Fördefinierade variabler (för att referera till frågor, frågeattribut och svar) - t.ex. SGQA-koderna;
• Fördefinierade funktioner (det finns redan över 80, och det är enkelt att lägga till fler).

Operatorer

EM-syntaxen följer vanlig operatorprioritet:

Nivå	Operator(er)	Beskrivning
1	()	parenteser för gruppering eller anrop av funktioner
2	! - +	unära operatorer: not, negation, unärt plus
3	* /	multiplikation, division
4	+ -	addition, subtraktion
5	< <= > >= lt le gt ge	relativa jämförelser
6	== != eq ne	likhetsjämförelser
7	and	logiskt OCH
8	or	logiskt ELLER
9	=	tilldelningsoperator
10	,	kommaoperator

För att JavaScript och PHP ska bete sig likadant utför plusoperatorn (+) addition om båda operanderna är numeriska, men sammanfogning om båda delarna är icke-numeriska strängar. Vi rekommenderar dock att du använder funktionen "join()" för sammanfogning, eftersom det gör din avsikt tydligare. Det undviker också oväntade resultat om du förväntade dig strängar men fick tal i stället (eller tvärtom).

Varning för blandning av tal och strängar samt alfabetisk/numerisk jämförelse

När du vill jämföra värden med relativa jämförelser eller likhetsjämförelser bör du vara uppmärksam på felaktiga typblandningar. Ett värde som en användare har angett (eller som anges via en svarskod) kan användas som tal om det tydligt är ett tal. Om du omger ett av värdena med " sker en text-/strängjämförelse. Om du vill jämföra som tal ska du aldrig omge ett tal med ".

Till exempel är Q0.NAOK > "50" sant om Q0.NAOK är en numerisk fråga med värdet 9. Det beror på att operatorn > då antar att det är en alfabetisk jämförelse och inte en numerisk.

För att säkerställa att du jämför heltalsvärden kan du använda intval(Q0.NAOK) > 50. Kom bara ihåg att om Q0.NAOK inte är ett tal (tomt eller en sträng) så är intval(Q0.NAOK) === 0. För att jämföra strängvärden ("A" < "B") använder du strcmp direkt: strcmp(Q0.NAOK,"B") eller strcmp(Q0.NAOK,"A5").

Var försiktig med tilldelningsoperatorn (=)

Du bör undvika tilldelningsoperatorer om det inte är absolut nödvändigt, eftersom de kan ge oväntade sidoeffekter. Om du till exempel ändrar värdet på ett tidigare svar beräknas den kaskadande relevansen och valideringslogiken mellan den frågan och den aktuella frågan inte om, så du kan få internt inkonsekventa data (t.ex. frågor som förblir besvarade men borde ha satts till NULL, eller frågor som hoppas över men borde ha besvarats). Om du vill tilldela ett värde till en variabel bör du generellt skapa en fråga av frågetypen Ekvation och använda ett uttryck för att ange dess värde. Det finns dock sällsynta tillfällen då man verkligen behöver den här operatorn, så vi har gjort den tillgänglig.

För att uppmärksamma dig på den här operatorn visas den med röd text i syntaxekvationerna (så att du inte förväxlar den med "==").

Använda tilldelningsoperatorn

De främsta orsakerna till att du kan vilja använda tilldelningsoperatorn är:

• Du behöver ange standardvärdet via en ekvation för en fråga som inte accepterar standardvärden (till exempel lista med radioknappar, där användargränssnittet låter dig välja ett av svarsalternativen men inte låter dig ange en ekvation). Var dock försiktig, eftersom LimeSurvey inte kan validera att din ekvation genererar ett av de tillåtna svaren för den frågan;
• Du behöver tvinga fram en ändring av svaret på en tidigare fråga baserat på ett senare svar;
• osv...

  Tilldelningen görs endast i PHP. Det innebär att värdet inte uppdateras på samma sida, utan först när användaren går vidare till nästa sida. Var därför uppmärksam när tilldelningsoperatorn används på samma sida som andra uttryck.

Du kan använda hela expression manager-systemet för detta ändamål. Det är bättre att använda en Ekvation för detta.

Några exempel:

• Ange svaret på en fråga med kort text med gemener : {QCODE=strtolower(QCODE.NAOK)};
• Ange ett standardsvar för en frågetyp med samling i början av en enkät : {Q1_SQ1=(is_empty(Q1_SQ1.NAOK),"A99",Q1_SQ1.NAOK)};
• Ange ett standardsvar för en frågetyp med samling av texter i början av en enkät : {Q1_SQY1_SQX1 = (is_empty(Q1_SQY1_SQX1.NAOK),"Inserted answer", Q1_SQY1_SQX1.NAOK)};
• Ange ett svar med villkor : {QCODE=if(YesNo="Y","A1","")}.

XSS-säkerhet

När XSS är aktiverat kan vissa delar av expression manager-systemet inte användas:

• att starta en HTML-tagg i ett uttryck men avsluta den i ett annat uttryck;
• att använda ett komplext uttryck i en URL.

Observera att XSS är aktiverat som standard i alla LimeSurvey-installationer.

Exempel och lösningar:

• {if( 1 ,"<strong>","")}information{if( 1 ,"</strong>","")} fungerar inte med XSS-säkerhet. Här kan du i stället använda {if(1,"<strong>information</strong>","information")};
• <a href="/script.php?value={if(QCODE == "Y","yes","no")}">next</a>, här kan du använda en ekvationsfråga eftersom det är tillåtet att använda en fullständig frågekod: <a href="/script.php?value={EQUATION.NAOK}">next</a>.

Åtkomst till variabler

ExpressionScript ger skrivskyddad åtkomst till de variabler du kan behöva. För bakåtkompatibilitet ger det åtkomst till följande:

• TOKEN:xxx - värdet för en TOKEN (t.ex. TOKEN:FIRSTNAME, TOKEN:ATTRIBUTE_5) (endast för enkäter som inte är anonyma).
• Alla {XXX}-värden som används av teman.
• I frågetext kan du använda {QID}, som ersätts av fråge-ID:t, och {SGQ}, som ersätts av frågans SGQA.
• {SAVEDID} för det aktuella svars-ID:t

Dessutom låter ExpressionScript dig hänvisa till variabler med frågekoden (kolumnen 'title' i frågetabellen i databasen). Detta är även den variabeletikett som används när du exporterar dina data till SPSS, R eller SAS. Om du till exempel har frågor om namn, ålder och kön kan du kalla variablerna name, age och gender i stället för 12345X13X22, 12345X13X23 och 12345X13X24. Det gör ekvationerna lättare för alla att läsa och logiken lättare att validera, och det blir dessutom möjligt att flytta runt frågor utan att behöva hålla reda på grupp- eller frågenummer.

Viktigt: Det är säkrare att hänvisa till variabler som förekommer på föregående sidor eller i föregående frågor.

Dessutom ger ExpressionScript åtkomst till många av frågans egenskaper:

Syntax	Betydelse	Exempel	Exempelresultat
Qcode	ett alias för Qcode.code	{implode(',',name,gender)}	'Tom','M'
Qcode.code	den valda svarskoden för frågan om den är relevant (annars tom), eller textvärdet om det inte är en kodad fråga	{implode(',',name.code,gender.code)}	'Tom','M'
Qcode.NAOK	samma som Qcode - se beskrivningen av NAOK	{gender.NAOK}	'M'
Qcode.value	utvärderingsvärdet för frågan om den är relevant (annars tomt), eller textvärdet om det inte är en kodad fråga	{gender.value}	'1'
Qcode.valueNAOK	samma som Qcode.value - se beskrivningen av NAOK	{gender.valueNAOK}	'1'
Qcode.shown	visningsvärdet för frågan	{implode(',',name.shown,gender.shown)}	'Tom','Male'
Qcode.question	frågans text	{gender.question}	'What is your gender?'
Qcode.mandatory	om frågan är obligatorisk (Y/N)	{gender.mandatory}	'N'
Qcode.qid	det interna frågenumret (inte det löpande numret)	{gender.qid}	337
Qcode.type	frågetypen	{gender.type}	'G'
Qcode.jsName	det korrekta JavaScript-namnet för frågan, oavsett om den deklareras på denna sida eller inte	{gender.jsName}	'java1827X3X337'
Qcode.gid	det interna gruppnumret (inte det löpande numret)	{gender.gid}	3
Qcode.qseq	frågans löpande nummer, med början från 0	{gender.qseq}	5
Qcode.gseq	gruppens löpande nummer, med början från 0	{gender.gseq}	1
Qcode.relevanceStatus	om frågan för närvarande är relevant (0 eller 1)	{gender.relevanceStatus}	1
Qcode.relevance	relevansekvationen på frågenivå	{gender.relevance}	'!is_empty(name)'
Qcode.grelevance	relevansekvationen på gruppnivå	{gender.grelevance}	'num_children >= 5'
Qcode.sgqa	SGQA-värdet för denna fråga	{gender.sgqa}	'1827X3X337'

Problem med HTML-redigeraren

Om du använder HTML-redigeraren ersätts vissa tecken av HTML-entiteter.

• & blir &amp;
• < blir &lt;
• > blir &gt;

Om du använder HTML-redigeraren måste du använda:

• and för &
• lt för <
• le för <=
• gt för >
• ge för >=

Vi rekommenderar att du rensar bort HTML som förekommer i dina uttryck. Om du använder LimeSurveys HTML-redigerare klickar du på knappen "Källa" (uppe till vänster i redigeraren) och raderar alla tecken som inte hör till ditt uttryck (t.ex.

,
och så vidare).

Namngivning av Qcode-variabler

Här beskrivs hur en Qcode byggs upp (och hur du kommer åt vissa egenskaper) för varje frågetyp. I allmänhet byggs Qcodes upp så här:

 QuestionCode . '_' . SubQuestionID . '_' . ScaleId

För kommentar och annat är motsvarande frågekoder QuestionCode_comment respektive QuestionCode_other.

Typ	Beskrivning	Kod	Delfrågor	Alternativ för svar	Skalor	Svarskod	Visat svar	Relevans
5	5-punktsval, radioknappar	Q1		1-5		{Q1}	{Q1.shown}	{Q1==3}
B	Samling (10-punktsval), radioknappar	Q2	L1-L6	1-10		{Q2_L2}	{Q2_L2.shown}	{Q2_L2==7}
A	Samling (5-punktsval), radioknappar	Q3	1-5	1-5		{Q3_1}	{Q3_1.shown}	{Q3_1>=3}
1	Samling (flexibla etiketter), dubbel skala	Q4	sq1-sq5	0:a1-a3	1:b1-b3	{Q4_sq1_0}	{Q4_sq1_1.shown}	{Q4_sq1_1=='b2'}
H	Samling (flexibel) - kolumnformat	Q5	1-5	s,m,t		{Q5_1}	{Q5_1.shown}	{Q5_1=='s'}
F	Samling (flexibel) - radformat	Q6	F1-F5	1-5		{Q6_F3}	{Q6_F3.shown}	{Q6_F3==4}
E	Samling (öka, samma, minska), radioknappar	Q7	1-7	I,S,D		{Q7_4}	{Q7_4.shown}	{Q7_4=='D'}
:	Samling (flera flexibla) 1 till 10	Q8	ls1,todo,ls2	min,max,avg		{Q8_ls1_max}	{Q8_ls2_avg.shown}	{Q8_ls2_min==7}
;	Samling (flera flexibla) text	Q9	hp,st,sw	1st,2nd,3rd		{Q9_hp_3rd}	{Q9_hp_3rd.shown}	{Q9_hp_3rd=='Peter'}
C	Samling (ja/osäker/nej), radioknappar	Q10	1-5	Y,N,U		{Q10_1}	{Q10_1.shown}	{Q10_3=='Y'}
X	Textvisningsfråga	Q11					{Q11.shown}
D	Datum	Q12				{Q12}	{Q12.shown}
*	Ekvation	Q13				{Q13}	{Q13.shown}	{Q13>5}
~124~	Filuppladdning (registrerar antalet uppladdade filer)	Q14				{Q14}		{Q14>0}
G	Rullgardinsmeny för kön	Q15		M,F		{Q15}	{Q15.shown}	{Q15=='M'}
U	Mycket lång fritext	Q16				{Q16}	{Q16.shown}	{strlen(Q16)>100}
I	Språkfråga	Q17				{Q17}	{Q17.shown}	{Q17=='en'}
!	Lista - rullgardinsmeny	Q18		1-5		{Q18}	{Q18.shown}	{Q18==3}
L	Lista, rullgardinsmeny/radioknappar	Q19		A-Z		{Q19}	{Q19.shown}	{Q19=='X'}
O	Lista med kommentarer, rullgardinsmeny/radioknappar + textområde	Q20		A-F		{Q20},{Q20comment}	{Q20.shown}	{Q20=='B'}
T	Lång fritext	Q21				{Q21}	{Q21.shown}	{strstr(Q21,'hello')>0}
M	Flervalsfråga, kryssrutor	Q22	A-F, other			{Q22_E}, {Q22_other}	{Q22_E.shown}, {Q22_other.shown}	{Q22_E=='Y'}
P	Flervalsfråga med kommentarer, kryssrutor + text	Q23	A-F			{Q23_D}, {Q23_Dcomment}	{Q23_D.shown}	{!is_empty(Q23)}
K	Flera numeriska frågor	Q24	self,mom,dad			{Q24_self}	{Q24_self.shown}	{Q24_self>30}
Q	Flera korta textsvar	Q25	A-F			{Q25_B}	{Q25_B.shown}	{substr(Q25_B,1,1)=='Q'}
N	Numerisk fråga	Q26				{Q26}	{Q26.shown}	{Q26 > 30}
R	Rangordning	Q27	1-4			{Q27_1}	{Q27_1.shown}	{Q27_1==3}
S	Kort fritext	Q28				{Q28}	{Q28.shown}	{Q28=='mine'}
Y	Ja/nej, radioknappar	Q29				{Q29}	{Q29.shown}	{Q29=='Y'}

Användning av NAOK

NAOK --> "Not Applicable" (NA) is alright (OK), dvs. "Ej tillämpligt" är OK

Att använda NAOK innebär att alla eller vissa av variablerna är irrelevanta (t.ex. "Not Applicable" (NA) is alright (OK), dvs. "Ej tillämpligt" är OK).

Exempel: count(Q1_SQ1,Q1_SQ2,Q1_SQ3,Q1_SQ4) ger alltid en tom sträng om en delfråga i Q1 är filtrerad. För att räkna antalet markerade delfrågor i en sådan fråga kan du använda count(Q1_SQ1.NAOK,Q1_SQ2.NAOK,Q1_SQ3.NAOK,Q1_SQ4.NAOK). Om delfrågan är dold returnerar EM en tom sträng.

Utan NAOK returnerar EM alltid en tom sträng (samma som att returnera false) om en fråga eller delfråga är dold.

.shown använder alltid NAOK-systemet (tom sträng om den är dold), men om du behöver svarskoden är det alltid en bra idé att lägga till .NAOK efter frågekoden (om du inte behöver något annat och vet vad du gör).

Mer information finns i avsnittet om att åsidosätta kaskadvillkor.

De reserverade variablerna "this", "self" och "that"

Ofta vill du utvärdera alla delar av en fråga, till exempel räkna hur många delfrågor som har besvarats eller summera poängen. Andra gånger vill du bara behandla vissa rader eller kolumner i en fråga (till exempel hämta rad- eller kolumnsummor och spara dem i databasen). Dessa reserverade variabler gör den processen relativt enkel.

Variabeln "this"

Variabeln "this" används uteslutande i alternativen "Valideringsuttryck för frågan" och "Valideringsuttryck för deltfrågor" (det senare är inte möjligt via det grafiska gränssnittet). Den expanderas till variabelnamnen för var och en av cellerna i dessa frågor. Om du vill se till att varje inmatning är större än tre ställer du alltså in "Valideringsuttryck för deltfrågor" på (this > 3).

Variabeln "self"

Variablerna "self" och "that" är kraftfullare och fungerar som makron som expanderas innan ekvationerna bearbetas. Syntaxalternativen för variabeln "self" är:

• self
• self.suffix
• self.sub-selector
• self.sub-selector.suffix

1. suffix är något av de vanliga qcode-suffixen (t.ex. NAOK, value, shown)

1. sub-selector kan vara något av följande:

• comments - endast delfrågor som är kommentarer (t.ex. flervalsfråga med kommentarer och lista med kommentarer);
• nocomments - endast delfrågor som inte är kommentarer;
• sq_X - där X är en rad- eller kolumnidentifierare. Endast delfrågor som matchar mönstret X väljs. Observera att sökningen görs på hela kodidentifieraren, och sedan inkluderas delfrågor som matchar sq_X, nX, X och Xn (t.ex. om du använder sq_1 inkluderas delfrågorna a1, 1a, 1, 11 eller 001). Var uppmärksam på frågetypen med dubbla skalor, där delfrågornas koder är QCODE_SQCODE_1 och QCODE_SQCODE_1, samt på rangordningsfrågor där delfrågornas koder är QCODE_1, QCODE_2 ....

Exempel:

• Har någon del av en fråga besvarats? -> {count(self.NAOK)>0}
• Vad är utvärderingspoängen för den här frågan? -> {sum(self.value)}

Du kan också använda dessa för att få rad- och kolumnsummor. Anta att du har en samling med tal med raderna A-E och kolumnerna 1-5.

• Vad är totalsumman? -> {sum(self.NAOK)}
• Vad är summan för rad B? -> {sum(self.sq_B.NAOK)}
• Vad är summan för kolumn 3? -> {sum(self.sq_3.NAOK)}

Variabeln "that"

Variabeln "that" liknar variabeln "self", men låter dig referera till andra frågor. Syntaxen är:

• that.qname
• that.qname.suffix
• that.qname.sub-selector
• that.qname.sub-selector.suffix

qname är frågenamnet utan några delfrågeändelser. Låt oss alltså skapa en fråga 'q1', där 'q1' också utgör dess qname.

Exempel:

• Har någon del av fråga q1 besvarats? -> {count(that.q1.NAOK)>0}
• Vad är utvärderingspoängen för q2? -> {sum(that.q2.NAOK)}
• Vad är totalsumman för q3? -> {sum(that.q3.NAOK)}
• Vad är summan för rad C i q4? -> {sum(that.q4.sq_C.NAOK)}
• Vad är summan för kolumn 2 i q4? -> {sum(that.q4.sq_2.NAOK)}

Variablerna "self" och "that" kan användas i all relevans, validering eller anpassning.

Det enda förbehållet är att när du använder funktionen Show logic file visas det expanderade värdet av "self" och "that". Då kan du se den faktiska ekvationen som kommer att genereras, så att du (och EM) kan validera om variablerna finns eller inte. Det kan verka förvirrande eftersom du kan se ganska långa ekvationer. Om du redigerar frågan ser du dock den ursprungliga ekvationen med "self" och/eller "that".

Du bör inte använda dessa variabler om du

• uttryckligen vill namnge varje variabel som används i en ekvation, eller
• använder variabler som inte har delfrågor (t.ex. frågor med ett enda svar). I sådana fall är det överflödigt att prefixa en variabel med "that", och du riskerar att få oväntade resultat.

Tillgång till funktioner

ExpressionScript ger tillgång till matematiska funktioner, strängfunktioner och användardefinierade funktioner, enligt nedan. Det finns motsvarigheter i PHP och JavaScript för dessa funktioner, så att de fungerar identiskt på serversidan (PHP) och klientsidan (JavaScript). Det är enkelt att lägga till nya funktioner.

Implementerade funktioner

Följande funktioner är för närvarande tillgängliga:

Funktion	Betydelse	Syntax
abs	Absolutvärde	number abs(number)
acos	Arcus cosinus	number acos(number)
addslashes	Sätt snedstreck framför specialtecken i en sträng	string addslashes(string)
asin	Arcus sinus	number asin(number)
atan	Arcus tangens	number atan(number)
atan2	arcus tangens med två variabler	number atan2(number, number)
ceil	Avrunda decimaler uppåt	number ceil(number)
checkdate	Returnerar sant (1) om det är ett giltigt datum i den gregorianska kalendern	bool checkdate(month,day,year)
convert_value	Konvertera ett numeriskt värde med hjälp av en inputTable och en outputTable med numeriska värden	number convert_value(fValue, iStrict, sTranslateFromList, sTranslateToList)
cos	Cosinus	number cos(number)
count	Räkna antalet besvarade (icke-tomma) frågor i listan	number count(arg1, arg12, ..., argN)
countif	Räkna antalet besvarade frågor i listan som är lika med det första argumentet	number countif(matches, arg1, arg2, ... argN)
countifop	Räkna antalet besvarade frågor i listan som uppfyller kriteriet (arg op value)	number countifop(op, value, arg1, arg2, ... argN)
date	Ange format för lokalt datum/tid	string date(format [, timestamp=time()])
exp	Beräkna exponenten av e	number exp(number)
fixnum	Visa tal med decimalkomma som decimaltecken, om det behövs	string fixnum(number)
floor	Avrunda decimaler nedåt	number floor(number)
gmdate	Formatera en tidsangivelse (datum/tid) angiven i GMT	string gmdate(format [, timestamp=time()])
html_entity_decode	Konvertera alla HTML-entiteter till motsvarande tecken (använder alltid ENT_QUOTES och UTF-8)	string html_entity_decode(string)
htmlentities	Konvertera alla tillämpliga tecken till HTML-entiteter (använder alltid ENT_QUOTES och UTF-8)	string htmlentities(string)
expr_mgr_htmlspecialchars	Konvertera specialtecken till HTML-entiteter (använder alltid ENT_QUOTES och UTF-8)	string htmlspecialchars(string)
expr_mgr_htmlspecialchars_decode	Konvertera speciella HTML-entiteter tillbaka till tecken (använder alltid ENT_QUOTES och UTF-8)	string htmlspecialchars_decode(string)
idate	Formatera en lokal tidsangivelse (tid/datum) som ett heltal	string idate(string [, timestamp=time()])
if	if i Excel-stil: if(test,result_if_true,result_if_false)	if(test,result_if_true,result_if_false)
implode	Slå samman element i en lista med en sträng som avskiljare	string implode(glue,arg1,arg2,...,argN)
intval	Returnera heltalsvärdet från en variabel	int intval(number [, base=10])
is_empty	Avgör om en variabel betraktas som tom	bool is_empty(var)
is_float	Avgör om en variabels typ är flyttal	bool is_float(var)
is_int	Avgör om en variabels typ är heltal	bool is_int(var)
is_nan	Avgör om ett värde är ett tal eller ej	bool is_nan(var)
is_null	Avgör om en variabel är NULL eller ej	bool is_null(var)
is_numeric	Avgör om en variabel är ett tal eller en numerisk sträng	bool is_numeric(var)
is_string	Avgör om en variabels typ är sträng	bool is_string(var)
join (New in 2.0 build 130129)	Slå samman element till en ny sträng	join(arg1, arg2, ... argN)
list	Returnera en kommaseparerad lista med icke-tomma värden	string list(arg1, arg2, ... argN)
listifop (New in 3.16.1 )	Returnera en lista, avskild med 'glue', av den angivna frågeegenskapen (retProp) från frågor i listan som uppfyller kriteriet (cmpProp op value)	string listifop(cmpProp, op, value, retProp, glue, sgqa1, sgqa2, ... sgqaN)
ltrim	Ta bort blanksteg (eller andra tecken) från början av en sträng	string ltrim(string [, charlist])
max	Hitta det högsta värdet	number max(arg1, arg2, ... argN)
min	Hitta det minsta värdet	number min(arg1, arg2, ... argN)
mktime	Hämta UNIX-tidsstämpel för ett datum (vart och ett av de 6 argumenten är valfritt)	number mktime([hour [, minute [, second [, month [, day [, year ]]]]]])
modulo-function	Modulofunktionen stöds inte ännu. Du kan använda funktionen floor() istället	floor(x/y)==(x/y)
nl2br	Infogar HTML-radbrytningar före alla nyradstecken i en sträng	string nl2br(string)
number_format	Formatera ett tal med gruppering i tusental	string number_format(number)
pi	Värde för pi	number pi()
pow	Exponent	number pow(base, exp)
quoted_printable_decode	Konvertera en quoted-printable-sträng till en 8-bitarssträng	string quoted_printable_decode(string)
quoted_printable_encode	Konvertera en 8-bitarssträng till en quoted-printable-sträng	string quoted_printable_encode(string)
quotemeta	Sätt citattecken kring speciella tecken	string quotemeta(string)
rand	Generera ett slumpmässigt heltal, se detta exempel	int rand() OR int rand(min, max)
regexMatch	jämför en sträng med ett reguljärt uttryck	bool regexMatch(pattern,input)
round	Avrunda ett decimaltal (med valfri precision om sådan angivits)	number round(val [, precision])
rtrim	Ta bort blanksteg (eller andra tecken) från slutet av en sträng	string rtrim(string [, charlist])
sin	Sinus	number sin(arg)
sprintf	Returnera en formaterad sträng	string sprintf(format, arg1, arg2, ... argN)
sqrt	Kvadratrot	number sqrt(arg)
stddev	Beräkna stickprovets standardavvikelse för listan med tal	number stddev(arg1, arg2, ... argN)
str_pad	Fyll ut en sträng till en viss längd med en annan sträng	string str_pad(input, pad_length [, pad_string])
str_repeat	Upprepa en sträng	string str_repeat(input, multiplier)
str_replace	Ersätt alla förekomster av söksträngen med ersättningssträngen	string str_replace(search, replace, subject)
strcasecmp	Skiftlägesokänslig strängjämförelse (binary safe)	int strcasecmp(str1, str2)
strcmp	Strängjämförelse (binary safe)	int strcmp(str1, str2)
strip_tags	Ta bort HTML- och PHP-taggar från en sträng	string strip_tags(str, allowable_tags)
stripos	Hitta positionen för första förekomsten av en unicode-sträng, skiftlägesokänsligt (börjar på 0, returnerar false om den inte hittas)	int stripos(haystack, needle [, offset=0])
stripslashes	Tar bort citattecken från en sträng (un-quote)	string stripslashes(string)
stristr	Skiftlägesokänslig strstr	string stristr(haystack, needle [, before_needle=false])
strlen	Beräkna längden på en sträng	int strlen(string)
strpos	Hitta positionen för första förekomsten av en unicode-sträng (börjar på 0, returnerar false om den inte hittas)	int strpos(haystack, needle [ offset=0])
strrev	Vänd på en sträng	string strrev(string)
strstr	Hitta första förekomsten av en sträng	string strstr(haystack, needle[, before_needle=false])
strtolower	Gör om en sträng till gemener	string strtolower(string)
strtotime	Tolka nästan vilken engelsk textbeskrivning av datum och tid som helst till en Unix-tidsstämpel	int strtotime(string)
strtoupper	Gör om en sträng till versaler	string strtoupper(string)
substr	Returnera en del av en unicode-sträng	string substr(string, start [, length])
sum	Beräkna summan av värdena i en lista/array	number sum(arg1, arg2, ... argN)
sumifop	Summera värdena för besvarade frågor i listan som uppfyller kriteriet (arg op value)	number sumifop(op, value, arg1, arg2, ... argN)
tan	Tangens	number tan(arg)
time	Returnera nuvarande tidsstämpel (UNIX timestamp)	number time()
trim	Ta bort blanksteg (eller andra tecken) från början och slutet av en sträng	string trim(string [, charlist])
ucwords	Gör första tecknet i varje ord i en sträng till versal	string ucwords(string)
unique	Returnera sant om alla icke-tomma svar är unika	boolean unique(arg1, ..., argN)

Klicka här om du vill veta mer om planerade (eller övervägda) funktioner.

<span id="Create_new_expression_functions_with_plugin_ ^{(New in 4.0.0 )}">

Skapa nya uttrycksfunktioner med plugin ^{(New in 4.0.0 )}

Om du behöver en ny funktion som inte finns i kärnan kan du skapa en med ett plugin. En sådan ny funktion skapas med händelsen expressionManagerStart.

ExpressionScript vet vilka variabler som är lokala

För att kunna bygga JavaScript för en sida på rätt sätt måste EM veta vilka variabler som sätts på sidan och vilket JavaScript-ID de har (t.ex. för document.getElementById(x)). EM måste också veta vilka variabler som sätts på andra sidor (så att de nödvändiga fälten <input type='hidden' value='x'> finns och är ifyllda).

Kaskadvillkor

Om någon av variablerna är irrelevant blir hela ekvationen irrelevant (false). I följande tabell betyder N/A till exempel att en av variablerna inte var relevant:

Operator	Exempel	a	b	Resultat
+ (unary)	+a	N/A		false
!	!a	N/A		false
== (or eq)	a == b	N/A	5	false
== (or eq)	a == b	N/A	0	false
== (or eq)	a == b	N/A	N/A	false
!= (or ne)	a != b	N/A	5	false
!= (or ne)	a != b	N/A	N/A	false
!= (or ne)	a != b	N/A	0	false
> (or gt)	a > b	N/A	5	false
>= (or ge)	a >= b	N/A	5	false
< (or lt)	a < b	N/A	5	false
<= (or le)	a <= b	N/A	5	false
and	a and b	N/A	5	false
and	a and b	N/A	N/A	false
or	a or b	N/A	N/A	false
or	a or b	N/A	5	false
+	a + b	N/A	5	false
*	a * b	N/A	5	false
/	a / b	5	N/A	false
()	(a)	N/A		false
(exp)	(a && b)	N/A	5	false
(exp) op (exp)	(b + b) > (a && b)	N/A	5	false
function	sum(a,b,b)	N/A	5	false
function	max(a,b)	N/A	5	false
function	min(a,b)	N/A	5	false
function	implode(', ',a,b,a,b)	N/A	5	false
function	if(a,a,b)	N/A	5	false
function	is_empty(a)	N/A		false
function	is_empty(a)	0 (or blank)		true
function	!is_empty(a)	N/A		false

Åsidosätta kaskadvillkor

Säg att du vill visa en löpande summa av alla relevanta svar. Du kanske försöker använda ekvationen {sum(q1,q2,q3,...,qN)}. Den översätts dock internt till LEMif(LEManyNA("q1","q2","q3",...,"qN"),"",sum(LEMval("q1"),LEMval("q2"),LEMval("q3"),...,LEMval("qN"))). Om något av värdena q1-qN är irrelevant returnerar ekvationen därför alltid false. I det här fallet visar sum() "0" tills alla frågor har besvarats.

För att komma runt detta kan varje variabel få suffixet ".NAOK" (som betyder att Not Applicable är OK). I så fall gäller följande beteende. Säg att du har en variabel q1.NAOK:

1. q1 läggs inte till i LEManyNA()-satsen
2. LEMval('q1') fortsätter att kontrollera om svaret är relevant och returnerar "" om det inte är det (så enskilda irrelevanta svar ignoreras, men de gör inte hela uttrycket ogiltigt).

Lösningen på problemet med den löpande summan är alltså att använda ekvationen sum(q1.NAOK,q2.NAOK,q3.NAOK,...,qN.NAOK).

Suffixet .NAOK gör det också möjligt för enkätskapare att utforma enkäter som har flera möjliga vägar men som senare går samman i gemensamma vägar. Säg till exempel att deltagare besvarar en enkät på ett sätt som ligger utanför det normala intervallet för svar. Enkätskaparen kan då varna deltagarna för att de kanske inte får giltiga resultat och fråga om de verkligen vill fortsätta med enkäten. Om de svarar "Ja" visas resten av frågorna. Villkoret för "resten av frågorna" skulle kontrollera om de första svaren låg inom det normala intervallet ELLER om deltagaren svarade "Ja" på den fråga som bara är relevant om svaren låg utanför det normala intervallet.

Hur stöder ExpressionScript villkorsstyrd mikroanpassning?

Här är ett exempel på mikroanpassning (där Frågetyp=='expr' betyder en ekvation):

Frågekod	Relevans	Frågetyp	Fråga
name	1	text	Vad heter du?
age	1	text	Hur gammal är du?
badage	!is_empty(age)	expr	{(age<16) or (age>80)}
agestop	badage	message	Tyvärr, {name}, du är för {if( (age<16),'ung',if( (age>80),'gammal','medelålders') ) } för det här testet.
kids	!badage	yesno	Har du barn?
parents	1	expr	{!badage && kids=='Y'}
numKids	parents	text	Hur många barn har du?
kid1	parents && numKids >= 1	text	Hur gammalt är ditt första barn?
kid2	parents && numKids >= 2	text	Hur gammalt är ditt andra barn?
kid3	parents && numKids >= 3	text	Hur gammalt är ditt tredje barn?
kid4	parents && numKids >= 4	text	Hur gammalt är ditt fjärde barn?
kid5	parents && numKids >= 5	text	Hur gammalt är ditt femte barn?
sumage	1	expr	{sum(kid1.NAOK,kid2.NAOK,kid3.NAOK,kid4.NAOK,kid5.NAOK)}
report	parents	text	{name}, du sa att du är {age} år och att du har {numKids} barn. Summan av åldrarna för dina första {min(numKids,5)} barn är {sumage}

Om du vill ladda ned enkätexemplet ovan klickar du på följande länk: Exempelenkät om antal barn.

Alla dessa frågor kan finnas på en enda sida (t.ex. i samma grupp), och endast de relevanta frågorna visas. När du dessutom anger barnens åldrar uppdateras uttrycket sum() i den sista frågan dynamiskt.

ExpressionScript tillhandahåller den här funktionen genom att omge varje uttryck med ett namngivet <span>-element. Varje gång ett värde ändras beräknas uttrycket som ska visas i det <span>-elementet om, och visningen genereras på nytt. Du kan ha dussintals eller till och med hundratals sådana anpassade uttryck på samma sida.

Syntaxmarkering

För att underlätta inmatning och validering av uttryck erbjuder EM syntaxmarkering med följande funktioner:

Typer och betydelser av syntaxmarkering

Färg	Exempel	Betydelse	Verktygstips	Kommentarer
beige bakgrund	Exempel	hela ekvationen	inget	Allt inom klammerparenteser som känns igen som en ekvation (t.ex. utan inledande eller avslutande blanksteg) färgkodas med beige bakgrund för att skilja det från omgivande text
fet röd text	Exempel	Ett fel	Viss förklaring av felet	Kan vara en okänd variabel eller ett fel i en funktion. Enkäten är trasig och de frågor som är beroende av det aktuella uttrycket visas inte för respondenterna.
blå text	Exempel	funktionsnamn	betydelse och tillåten syntax	Avser funktionsnamn eller sådant som borde vara funktioner eftersom de följs av en inledande parentes. De visas i fet blå text. Verktygstips visar betydelsen och den tillåtna syntaxen för funktionen.
grå text	Exempel	sträng	inget	Strängar med enkla och dubbla citattecken visas i grå text.
cyanblå text	Exempel	variabel som sätts på samma sida,	[namn]: fråga; värde; svarslista som visar koderna för varje värde	Varje variabel som sätts på samma sida som den fråga du redigerar just nu visas i cyanblå text (den kan uppdateras i JavaScript). Verktygstipset visar variabelns namn, själva frågan och dess nuvarande värde (eller tomt om det inte är satt). Om frågetypen förväntar sig svar från en uppräknad värdemängd visas mappningen mellan koderna och visningsvärdena.
grön text	Exempel	variabel som sätts på en tidigare sida	[namn]: fråga; värde; svarslista som visar koderna för varje värde	Varje variabel som sätts på en tidigare sida visas i fet grön text. Verktygstipset visar variabelns namn, själva frågan och dess nuvarande värde (eller tomt om det inte är satt). Om frågetypen förväntar sig svar från en uppräknad värdemängd visas mappningen mellan koderna och visningsvärdena.
fet rosa text	Exempel	variabel som sätts på en senare sida i allmänhet: tom vid enkätens start, men kan fyllas i via index eller föregående	[namn eller SGQA-kod]: fråga; värde; svarslista som visar koderna för varje värde	Varje variabel som sätts på en senare sida visas i fet rosa text. Verktygstipset visar variabelns namn, själva frågan och dess nuvarande värde (eller tomt om det inte är satt). Om frågetypen förväntar sig svar från en uppräknad värdemängd visas mappningen mellan koderna och visningsvärdena.
fet beige text	Exempel	ett Lime-ersättningsvärde	värdet	Lime-ersättningssträngar (som {TOKEN:xxx}, {PRIVACY_MESSAGE}) visas i fet beige text.
röd text	Exempel	tilldelningsoperator (=)	varningsmeddelande	Om du använder en tilldelningsoperator (=) visas operatorn i röd text. Det är till för att förhindra oavsiktlig omtilldelning av värden när du egentligen menade att kontrollera om a == b i stället för att sätta värdet a = b.
normal svart text	Exempel	skiljetecken	inget	Alla andra skiljetecken i uttrycket visas i normal svart text.
text i röd ruta	en fet röd linje omger felet	syntaxfel	beskrivning av felet	Alla upptäckta syntaxfel visas i röda rutor. Verktygstipset visar felet. Exempel är parenteser som inte matchar, användning av odefinierade funktioner, fel antal argument till funktioner, dåligt strukturerade uttryck (t.ex. operatorer som saknas mellan variabler), försök att tilldela ett nytt värde till en skrivskyddad variabel, försök att tilldela värden till något som inte är variabler, eller användning av syntax som inte stöds. Observera att systemet för upptäckt av syntaxfel kanske bara rapporterar ett fel i ett uttryck även om det finns flera; om några fel upptäcks visas dock minst ett fel.

Med verktygstips avser vi det popup-meddelande som visas när du håller muspekaren över vissa funktioner och variabler.