This page is a translated version of the page ExpressionScript - Presentation and the translation is 100% complete.

บทนำ

LimeSurvey ใช้สคริปต์นิพจน์ (Expression Script) เพื่อให้ LimeSurvey รองรับการแตกแขนงที่ซับซ้อนยิ่งขึ้น การประเมินผล การตรวจสอบ และการปรับแต่งเนื้อหา สคริปต์นิพจน์เข้ามาแทนที่วิธีที่ LimeSurvey จัดการการแทนที่ เงื่อนไข และ การประเมินผล ในส่วนหลังบ้าน นอกจากนี้ยังช่วยเพิ่มความเร็วในการประมวลผลอย่างมาก เนื่องจากช่วยลดการอ่านฐานข้อมูลขณะทำงานเกือบทั้งหมด สคริปต์นิพจน์พัฒนาโดย Dr. Thomas White (TMSWhite)

คำจำกัดความสำคัญ

นิพจน์: ทุกสิ่งที่อยู่ภายในวงเล็บปีกกา:
- ตราบใดที่ไม่มีช่องว่างทันทีหลังวงเล็บเปิดหรือก่อนวงเล็บปิด
- เนื้อหาของนิพจน์จะถูกประเมินโดย EM จึงสามารถมีสูตรคณิตศาสตร์ ฟังก์ชัน และการประมวลผลสตริงและวันที่ที่ซับซ้อนได้
การปรับแต่งเนื้อหา (Tailoring): บางครั้งเรียกว่า "piping" คือกระบวนการแก้ไขข้อความตามเงื่อนไข:
- คุณสามารถเข้าถึง 'ฟิลด์แทนที่' ทั้งหมด ข้อมูลผู้เข้าร่วม และข้อมูลการตอบคำถาม
- คุณยังเข้าถึงคำถาม คำตอบ และคุณสมบัติของคำถามเหล่านั้นได้ง่ายขึ้น
สมการความสัมพันธ์กัน: คุณสมบัติของคำถามใหม่ที่ควบคุมการมองเห็นของคำถาม:
- หากมีสมการความสัมพันธ์กัน คำถามจะแสดงก็ต่อเมื่อผลลัพธ์ของสมการเป็นจริงเท่านั้น
- ภายในระบบ คำสั่ง array_filter และ array_filter_exclude ทั้งหมดจะกลายเป็นความสัมพันธ์กันในระดับคำถามย่อย
SGQA (วิธีตั้งชื่อตัวแปรในอดีต):
- ย่อมาจาก Survey-Group-Question-Answer
- ชื่อตัวแปร SGQA มีลักษณะเช่น 123X5X382X971 และอาจมีส่วนต่อท้ายของคำถามย่อย
- ชื่อตัวแปรเหล่านี้เฉพาะเจาะจงกับรหัสฐานข้อมูล S/Q/G/A ที่อยู่เบื้องหลัง จึงมักต้องมีการเปลี่ยนแปลง
สมการ ชนิดของคำถาม: ชนิดของคำถามใหม่ ที่บันทึกการคำนวณหรือรายงานลงในฐานข้อมูล:
- คล้ายกับคำถามแบบ Boilerplate แต่เนื้อหาจะถูกบันทึกลงในฐานข้อมูลแม้ว่าคุณจะตั้งค่า "ซ่อนคำถามนี้" ก็ตาม
รหัสคำถาม: เป็นชื่อตัวแปรที่แนะนำสำหรับ EM:
- อาจเป็นชื่อที่สื่อความหมายถึงวัตถุประสงค์ของคำถาม ทำให้อ่านตรรกะที่ซับซ้อนได้ง่ายขึ้น
- รหัสคำถามที่ถูกต้องต้องไม่ขึ้นต้นด้วยตัวเลข ดังนั้นเมื่อใช้รหัสคำถามเพื่อกำกับหมายเลขคำถาม ให้ใช้เพียง "q1" หรือ "q1a" หรือ "g1q2"
- นี่คือสิ่งที่จะกลายเป็นชื่อตัวแปรเมื่อคุณส่งออกข้อมูลไปยัง SPSS หรือ R ดังนั้น หากคุณทำการวิเคราะห์เชิงสถิติ คุณต้องสร้างรหัสคำถามที่ไม่ซ้ำกันเท่านั้น

ฉันจำเป็นต้องใช้สคริปต์นิพจน์หรือไม่?

คำตอบสั้น ๆ คือ "ไม่จำเป็น" อย่างไรก็ตาม ขึ้นอยู่กับความซับซ้อนของแบบสำรวจที่คุณต้องการสร้างเป็นอย่างมาก

ตัวอย่างเช่น ตัวแก้ไขเงื่อนไข ครอบคลุมนิพจน์พื้นฐานบางอย่างที่นำไปใช้กับคำถามในแบบสำรวจของคุณได้ แต่ตัวแก้ไขเงื่อนไขมีข้อจำกัด นั่นคือเหตุผลที่มีการใช้สคริปต์นิพจน์ ซึ่งขยายขอบเขตของความเป็นไปได้ในการปรับแต่ง

ฉันสามารถใช้เงื่อนไขและสมการความสัมพันธ์กันร่วมกันได้หรือไม่?

ได้ คุณสามารถใช้ตัวแก้ไขเงื่อนไขกับบางคำถาม และใช้สมการความสัมพันธ์กันกับคำถามอื่น ๆ ได้

คุณไม่สามารถตั้งค่าทั้งเงื่อนไขและนิพจน์ในคำถามเดียวกันได้! เมื่อตั้งค่าเงื่อนไขแล้ว เงื่อนไขนั้นจะแทนที่นิพจน์ใด ๆ ที่เขียนไว้ในช่องสมการความสัมพันธ์กัน นอกจากนี้ ช่องสมการความสัมพันธ์กันจะไม่สามารถแก้ไขด้วยตนเองได้อีกต่อไป

อย่างไรก็ตาม ยังมีวิธีใช้ทั้งนิพจน์และเงื่อนไขภายในคำถามเดียว ดังที่กล่าวไว้ข้างต้น เงื่อนไขจะแทนที่ช่องสมการความสัมพันธ์กัน เมื่อทำเสร็จแล้ว ให้ตรวจสอบสมการที่สร้างขึ้นใหม่และคัดลอกไปไว้ในโปรแกรมแก้ไขข้อความ จากนั้นลบเงื่อนไขที่สร้างขึ้นใหม่ออกจากตัวแก้ไขเงื่อนไข แล้วแก้ไขคำถามโดยเพิ่มนิพจน์ที่อิงจากเงื่อนไขจากไฟล์ในโปรแกรมแก้ไขข้อความของคุณ ร่วมกับนิพจน์อื่น ๆ ที่คุณต้องการใช้

ฉันควรเลือกระหว่างเงื่อนไขและความสัมพันธ์กันอย่างไร?

ต่อไปนี้คือรายการข้อดีและข้อเสียของแต่ละรูปแบบ:

รูปแบบ	ข้อดี	ข้อเสีย
เงื่อนไข	1. GUI ที่ใช้งานง่ายสำหรับสร้างเงื่อนไขอย่างง่าย 2. GUI มีเอกสารประกอบครบถ้วนและทีมสนับสนุนเข้าใจเป็นอย่างดี	1. รองรับเฉพาะการเปรียบเทียบอย่างง่าย และไม่รองรับเงื่อนไข "AND" และ "OR" ได้ดีนัก 2. เงื่อนไขแบบลำดับขั้นทำงานไม่แน่นอน 3. ช้า - ใช้ฐานข้อมูลมาก - อาจทำให้แบบสำรวจที่ยาวช้าลง 4. มีรายงานปัญหาบางอย่างเกี่ยวกับการโหลดเงื่อนไขซ้ำ 5. GUI ไม่รองรับการขยายขนาดได้ดีเมื่อมีคำถามหลายสิบ หลายร้อย หรือหลายพันข้อ 6. การแปลงแบบสำรวจที่เป็นกระดาษอาจช้า เนื่องจากต้องใช้ชื่อ SGQA 7. มักต้องใช้โปรแกรมเมอร์เขียนโค้ดตรรกะที่จำเป็นสำหรับการแตกแขนงที่ซับซ้อน
ความสัมพันธ์กัน	1. รองรับตรรกะที่ซับซ้อนมาก รวมถึงฟังก์ชันกว่า 80 รายการ และตัวดำเนินการทางคณิตศาสตร์/สตริง 2. รองรับตรรกะแบบลำดับขั้นได้อย่างสมบูรณ์ 3. เร็ว - ไม่มีการเรียกฐานข้อมูลเพิ่มเติม รองรับแบบสำรวจที่มีคำถามกว่า 1000 ข้อ 4. ไม่มีปัญหาเรื่องการโหลดตรรกะซ้ำ เพราะไม่ต้องใช้รหัส SGQA 5. การเน้นไวยากรณ์รองรับแบบสำรวจที่มีคำถามกว่า 1000 ข้อ 6. ใช้งานง่ายและรวดเร็วสำหรับกลุ่มที่ต้องการทำแบบสำรวจกระดาษที่มีอยู่ให้เป็นระบบคอมพิวเตอร์ 7. รองรับการสัมภาษณ์กึ่งโครงสร้างและแบบสำรวจทางระบาดวิทยาได้อย่างง่ายดายโดยไม่ต้องใช้โปรแกรมเมอร์	1. ไม่มี GUI สำหรับเงื่อนไขอย่างง่าย - แต่ใช้การเน้นไวยากรณ์แทน

หมายเหตุ:

เราแนะนำให้คุณใช้แบบที่เหมาะกับความต้องการของคุณมากที่สุด
หากต้องการคำอธิบายโดยละเอียดเพิ่มเติมเกี่ยวกับคุณสมบัติของ EM โปรดคลิกลิงก์ต่อไปนี้

เริ่มต้นใช้งาน

วิธีที่ดีที่สุดในการเริ่มต้นใช้งาน EM คือ:

ติดตั้งเวอร์ชันเสถียรล่าสุดจาก https://www.limesurvey.org/en/download
นำเข้าและสำรวจแบบสำรวจตัวอย่าง
สำรวจกรณีการใช้งานและวิธีการ และตัวอย่างทีละขั้นตอน
สำรวจเอกสารประกอบ EM (หน้านี้)
- การทดสอบหน่วยของนิพจน์แบบแยกส่วน (ขั้นสูง)
  - แสดงตัวอย่างการใช้ฟังก์ชันและตัวดำเนินการของ EM ทั้งหมด รวมถึงผลลัพธ์ใน PHP และ JavaScript
  - โปรดทราบว่ามีบางฟังก์ชันที่ให้ผลลัพธ์ต่างกันระหว่างเวอร์ชัน PHP และ JavaScript ดังนั้นหน้านี้จะช่วยให้คุณวางแผนตรรกะ EM ได้อย่างเหมาะสม

คำศัพท์

คำเหล่านี้มักใช้อธิบายความสามารถของ EM:

การแตกแขนงตามความสัมพันธ์กัน - หากคำถามมีความสัมพันธ์กัน ก็ให้ถามคำถามนั้น มิฉะนั้นไม่ต้องถาม (เช่น ทำให้มองไม่เห็นและระบุเป็น NULL ในฐานข้อมูล) คุณสามารถพบช่องความสัมพันธ์กันได้ในแผงตัวแก้ไขคำถามและในแผงตัวแก้ไขกลุ่มคำถาม อย่างหลังใช้เพื่อนำชุดเงื่อนไขไปใช้กับทั้งกลุ่มโดยไม่ต้องคัดลอกเงื่อนไขเดียวกันไปยังแต่ละคำถาม และ/หรือรวมตรรกะแบบมีเงื่อนไขระดับกลุ่มและระดับคำถามเข้าด้วยกัน
การปรับแต่งเนื้อหา (Tailoring) - เมื่อคุณทราบแล้วว่าควรถามคำถามใด การปรับแต่งเนื้อหา (บางครั้งเรียกว่า piping) จะกำหนดว่าควรถามคำถามอย่างไร ซึ่งช่วยให้รองรับได้ไม่เพียงการแทนที่อย่างง่าย (เช่น {TOKEN:FIRSTNAME}) แต่ยังรวมถึงการผันคำกริยาและการเปลี่ยนรูปคำนามตามเพศหรือจำนวนของกลุ่มเป้าหมายของคุณ นอกจากนี้ยังช่วยให้คุณเปลี่ยนข้อความที่ส่งถึงผู้ตอบแบบสำรวจตามว่าพวกเขาตอบ (หรือตอบอย่างไร) คำถามอื่น ๆ
สมการ - EM เพิ่มชนิดของคำถามใหม่ที่เรียกว่าสมการ ซึ่งเก็บผลลัพธ์ของนิพจน์ ผลลัพธ์ของสมการจะถูกคำนวณและเขียนลงในฐานข้อมูล แม้ว่าคุณจะซ่อนไว้บนหน้าก็ตาม ดังนั้นจึงใช้สำหรับการคำนวณคะแนนที่ซ่อนอยู่ การนำทางตามสมการที่ซับซ้อน การประเมินผล และรายงานที่จะถูกสร้างและจัดเก็บไว้ในฐานข้อมูล

ความสัมพันธ์กันและความสัมพันธ์กันแบบลำดับขั้น

ปัจจุบันทุกชนิดของคำถามมีตัวเลือกความสัมพันธ์กันซึ่งควบคุมว่าจะแสดงคำถามหรือไม่ EM จะประมวลผลสมการความสัมพันธ์กันแต่ละรายการตามลำดับที่ปรากฏในแบบสำรวจ หากนิพจน์เป็นจริง (หรือไม่มี - เพื่อรองรับแบบสำรวจรุ่นเก่า) คำถามจะถูกแสดง หากไม่มีความสัมพันธ์กัน คำถามจะถูกซ่อน และค่าจะถูกกำหนดเป็น NULL ในฐานข้อมูล หากไม่มีคำถามที่เกี่ยวข้องในกลุ่ม ทั้งกลุ่มจะถูกข้ามไป

นอกจากนี้ หากตัวแปรใดในนิพจน์ไม่มีความสัมพันธ์กัน นิพจน์นั้นจะประเมินเป็นเท็จเสมอ ซึ่งทำให้เกิด ความสัมพันธ์กันแบบลำดับขั้น ดังนั้นคุณจึงไม่ต้องเขียนสมการความสัมพันธ์กันที่ยาวมากสำหรับแต่ละคำถาม

สมมติว่าคุณมีคำถามห้าข้อ Q1-Q5 และต้องการแสดง Q2 ก็ต่อเมื่อมีการตอบ Q1 และแสดง Q3 ก็ต่อเมื่อมีการตอบ Q2 และต่อไปเรื่อย ๆ สมการความสัมพันธ์กันอาจเป็นดังนี้:

รหัสคำถาม	ความสัมพันธ์กัน	คำถาม
Q1	1	คุณชื่ออะไร?
Q2	Q1	{Q1}, คุณอายุเท่าไร?
Q3	Q2	คุณอายุ {Q2} ปี คุณแต่งงานแล้วหรือไม่?
Q4	Q3 == "Y"	{Q1}, คุณแต่งงานมานานเท่าไรแล้ว?
Q5	Q4	คุณมีลูกกี่คน, {Q1}?

ความสัมพันธ์กันระดับกลุ่ม

ExpressionScript ยังรองรับความสัมพันธ์กันในระดับกลุ่ม ซึ่งทำให้ใช้งานการวนซ้ำได้ง่ายขึ้น สมมติว่าคุณต้องการรวบรวมข้อมูลจากหน่วยสูงสุด 10 หน่วย (เช่น ผลิตภัณฑ์หรือบุคคลในครัวเรือน) โดยก่อนอื่นคุณต้องระบุว่ามีกี่หน่วยที่ต้องติดตามผลเพิ่มเติม (เช่น ถามว่ามีกี่คนอาศัยอยู่ในครัวเรือน หรือให้ผู้คนเลือกผลิตภัณฑ์ที่ชอบจากรายการยาว) หลังจากทราบว่ามีกี่หน่วยที่ต้องติดตามผล คุณสามารถใช้ความสัมพันธ์กันระดับกลุ่ม เช่น {count >= 1}, {count >=2}, ... {count >= 10} สำหรับแต่ละกลุ่มจาก 10 กลุ่มของคำถามติดตามผล ภายในแต่ละกลุ่ม คุณสามารถมีตรรกะแบบมีเงื่อนไขระดับคำถาม (เช่น คำถามติดตามผลเฉพาะเพศหรืออายุสำหรับแต่ละบุคคล) สมการความสัมพันธ์กันระดับคำถามและระดับกลุ่มจะถูกรวมกันด้วย AND เพื่อกำหนดว่าควรแสดงอะไร

หากต้องการดูตัวอย่างดังกล่าว ให้นำเข้าแบบสำรวจต่อไปนี้: ตัวอย่างแบบสำรวจสำมะโนประชากร

จากภาพหน้าจอด้านล่าง จะเห็นได้ว่ากลุ่ม Person 1 จะถูกแสดง (หรือมีความสัมพันธ์กัน) หากผู้ตอบอาศัยอยู่กับผู้อยู่ร่วมอาศัยอย่างน้อยอีกหนึ่งคน:

การปรับแต่งข้อความ/Piping

ข้อความใดก็ตามที่อยู่ภายในวงเล็บปีกกาจะถือเป็นนิพจน์ (ยกเว้นกรณีเดียวที่อธิบายไว้ด้านล่าง) นิพจน์สามารถเข้าถึง LimeReplacementFields และตัวแปรทั้งหมด (ผ่านชื่อแทนหลายแบบ) ตัวดำเนินการสมการทั่วไปทั้งหมด (ทางคณิตศาสตร์ ตรรกะ และการเปรียบเทียบ) และฟังก์ชันอีกหลายสิบรายการ (ซึ่งทำงานแบบไดนามิกได้แม้ในฝั่งไคลเอนต์)

เมื่อใช้สมการเหล่านี้ คุณสามารถทำสิ่งต่าง ๆ ได้ เช่น

แสดงข้อความที่ปรับแต่งให้ผู้ตอบแบบมีเงื่อนไขตามการตอบคำถามก่อนหน้า
สร้างการประเมินและแสดงผลการประเมิน (หรือแตกสายงานหรือแสดงข้อความตามเงื่อนไข) โดยอิงจากผลลัพธ์เหล่านั้น โดยไม่ต้องใช้โมดูลการประเมินเลย
ผันคำกริยาและปรับรูปคำนามภายในคำถาม คำตอบ และรายงาน
แสดงสรุปการตอบคำถามก่อนหน้าหน้า "แสดงคำตอบของคุณ" ที่ท้ายแบบสำรวจ

สมการ

มีประเภทคำถามใหม่ที่เรียกว่าสมการ ให้คิดว่าเป็นประเภทคำถามการแสดงผลข้อความ แต่ต่างกันตรงที่จะจัดเก็บค่าของสิ่งที่แสดงไว้ในฐานข้อมูลด้วย ดังนั้น หากข้อความคำถามของสมการมีการคำนวณการประเมิน ค่านั้นจะถูกจัดเก็บในฐานข้อมูลเป็นตัวแปรที่สามารถแสดงในสถิติสาธารณะหรือสถิติส่วนตัวได้

ไวยากรณ์

ข้อความใดก็ตามที่อยู่ภายในวงเล็บปีกกาจะถือเป็นนิพจน์ (มีข้อยกเว้นหนึ่งข้อ: ต้องไม่มีช่องว่างนำหน้าหรือตามหลัง - ทั้งนี้เพื่อให้แน่ใจว่า ExpressionScript จะไม่พยายามประมวลผล JavaScript ที่ฝังอยู่)

โปรดทราบว่านิพจน์สามารถเขียนข้ามหลายบรรทัดได้ ตราบใดที่ไม่มีช่องว่างหลังวงเล็บปีกกาเปิดหรือก่อนวงเล็บปีกกาปิด ซึ่งเป็นประโยชน์อย่างยิ่งสำหรับคำสั่ง "if()" ที่ซ้อนกัน เช่นตัวอย่างนี้:

{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 รองรับไวยากรณ์ต่อไปนี้:

ตัวดำเนินการทางคณิตศาสตร์มาตรฐานทั้งหมด (เช่น +,-,*,/,!)
ตัวดำเนินการเปรียบเทียบมาตรฐานทั้งหมด (เช่น <,<=,==,!=,>,>=, รวมถึงตัวดำเนินการที่เทียบเท่า: lt, le, eq, ne, gt, ge)
วงเล็บ (เพื่อจัดกลุ่มนิพจน์ย่อย)
ตัวดำเนินการเงื่อนไข (เช่น &&,| | และตัวดำเนินการที่เทียบเท่า: and, or)
สตริงที่อยู่ในเครื่องหมายอัญประกาศเดี่ยวและคู่ (ซึ่งแต่ละแบบสามารถฝังสตริงที่ใช้อัญประกาศอีกแบบไว้ข้างในได้)
ตัวดำเนินการจุลภาค (เพื่อให้มีรายการนิพจน์หลายรายการและส่งคืนเฉพาะผลลัพธ์สุดท้าย)
ตัวดำเนินการกำหนดค่า (=)
ตัวแปรที่กำหนดไว้ล่วงหน้า (เพื่ออ้างถึงคำถาม คุณสมบัติคำถาม และการตอบคำถาม) เช่น รหัส SGQA
ฟังก์ชันที่กำหนดไว้ล่วงหน้า (มีมากกว่า 80 ฟังก์ชันแล้ว และเพิ่มฟังก์ชันใหม่ได้ง่าย)

ตัวดำเนินการ

ไวยากรณ์ของ EM เป็นไปตามลำดับความสำคัญของตัวดำเนินการตามปกติ:

ระดับ	ตัวดำเนินการ	คำอธิบาย
1	()	วงเล็บสำหรับจัดกลุ่มหรือเรียกใช้ฟังก์ชัน
2	! - +	ตัวดำเนินการเอกภาค: not, การกลับเครื่องหมาย, เครื่องหมายบวก
3	* /	คูณ, หาร
4	+ -	บวก, ลบ
5	< <= > >= lt le gt ge	การเปรียบเทียบเชิงสัมพัทธ์
6	== != eq ne	การเปรียบเทียบความเท่ากัน
7	and	ตรรกะ AND
8	or	ตรรกะ OR
9	=	ตัวดำเนินการกำหนดค่า
10	,	ตัวดำเนินการจุลภาค

เพื่อให้ JavaScript และ PHP ทำงานสอดคล้องกัน ตัวดำเนินการบวก (+) จะทำการบวกเลขหากตัวถูกดำเนินการทั้งสองเป็นตัวเลข แต่จะทำการต่อสตริงหากทั้งสองส่วนเป็นสตริงที่ไม่ใช่ตัวเลข อย่างไรก็ตาม เราแนะนำให้ใช้ฟังก์ชัน "join()" สำหรับการต่อสตริง เพราะจะทำให้เจตนาของคุณชัดเจนยิ่งขึ้น และยังหลีกเลี่ยงผลลัพธ์ที่ไม่คาดคิดในกรณีที่คุณคาดว่าเป็นสตริงแต่ได้ตัวเลข (หรือกลับกัน)

คำเตือนเกี่ยวกับการใช้ตัวเลขและสตริงไม่ตรงกัน และการเปรียบเทียบตามตัวอักษร/ตามตัวเลข

เมื่อคุณต้องการเปรียบเทียบค่าด้วยการเปรียบเทียบเชิงสัมพัทธ์หรือความเท่ากัน โปรดระวังความไม่ตรงกันของชนิดข้อมูล ค่าที่ผู้ใช้กรอก (หรือที่ได้จากรหัสคำตอบ) สามารถใช้เป็นตัวเลขได้ หากเป็นตัวเลขอย่างชัดเจน หากคุณใส่ " ครอบค่าใดค่าหนึ่ง ระบบจะเปรียบเทียบเป็นข้อความ/สตริง หากต้องการเปรียบเทียบเป็นตัวเลข อย่าใส่ " ครอบตัวเลขเด็ดขาด

ตัวอย่างเช่น Q0.NAOK > "50" จะเป็นจริงหาก Q0.NAOK เป็นคำถามตัวเลขที่มีค่าเป็น 9 เนื่องจากตัวดำเนินการ > จะถือว่าเป็นการเปรียบเทียบตามตัวอักษร ไม่ใช่ตามตัวเลข

เพื่อให้แน่ใจว่าคุณเปรียบเทียบค่าจำนวนเต็ม คุณสามารถใช้ intval(Q0.NAOK) > 50 โปรดจำไว้ว่าหาก Q0.NAOK ไม่ใช่ตัวเลข (ว่างเปล่าหรือเป็นสตริง) intval(Q0.NAOK) จะเท่ากับ 0 เสมอ หากต้องการเปรียบเทียบค่าสตริง ("A" < "B") ให้ใช้ strcmp โดยตรง: strcmp(Q0.NAOK,"B") หรือ strcmp(Q0.NAOK,"A5")

ข้อควรระวังในการใช้ตัวดำเนินการกำหนดค่า (=)

คุณควรหลีกเลี่ยงการใช้ตัวดำเนินการกำหนดค่า เว้นแต่จำเป็นจริง ๆ เนื่องจากอาจก่อให้เกิดผลข้างเคียงที่ไม่คาดคิด ตัวอย่างเช่น หากคุณเปลี่ยนค่าของการตอบคำถามก่อนหน้า ตรรกะความสัมพันธ์กันแบบลำดับขั้นและการตรวจสอบระหว่างคำถามนั้นกับคำถามปัจจุบันจะไม่ถูกคำนวณใหม่ ทำให้คุณอาจได้ข้อมูลที่ขัดแย้งกันเอง (เช่น คำถามที่ยังคงมีคำตอบทั้งที่ควรเป็น NULL หรือคำถามที่ถูกข้ามไปทั้งที่ควรได้รับคำตอบ) โดยทั่วไป หากคุณต้องการกำหนดค่าให้ตัวแปร คุณควรสร้างคำถามประเภทสมการ แล้วใช้นิพจน์เพื่อกำหนดค่าของมัน อย่างไรก็ตาม มีบางครั้งที่ผู้ใช้จำเป็นต้องใช้ตัวดำเนินการนี้จริง ๆ เราจึงเปิดให้ใช้งานได้

เพื่อเตือนให้คุณระวังตัวดำเนินการนี้ ระบบจะแสดงเป็นตัวอักษรสีแดงภายในสมการที่มีการไฮไลต์ไวยากรณ์ (เพื่อไม่ให้สับสนกับ "==")

การใช้ตัวดำเนินการกำหนดค่า

เหตุผลหลักที่คุณอาจต้องการใช้ตัวดำเนินการกำหนดค่ามีดังนี้:

คุณต้องตั้งค่าเริ่มต้นผ่านสมการสำหรับคำถามที่ไม่รองรับค่าเริ่มต้น (เช่น รายการแบบปุ่มตัวเลือก ซึ่งส่วนติดต่อผู้ใช้ให้เลือกตัวเลือกของคำตอบได้ แต่ไม่ให้ป้อนสมการ) อย่างไรก็ตาม โปรดระวัง เพราะ LimeSurvey ไม่สามารถตรวจสอบได้ว่าสมการของคุณให้ผลเป็นหนึ่งในคำตอบที่อนุญาตสำหรับคำถามนั้นหรือไม่
คุณต้องบังคับเปลี่ยนการตอบคำถามก่อนหน้าโดยอิงจากการตอบคำถามที่ตามมาภายหลัง
ฯลฯ

ข้อควรระวัง : การกำหนดค่าทำงานเฉพาะใน PHP ซึ่งหมายความว่าค่าจะไม่ถูกอัปเดตในหน้าเดียวกัน แต่จะอัปเดตเมื่อผู้ใช้ไปยังหน้าถัดไปเท่านั้น ดังนั้น โปรดระมัดระวังเมื่อใช้ตัวดำเนินการกำหนดค่าในหน้าเดียวกันกับนิพจน์อื่น ๆ

คุณสามารถใช้ระบบ Expression Manager ทั้งหมดเพื่อวัตถุประสงค์นี้ได้ แต่ควรใช้สมการจะดีกว่า

ตัวอย่างบางส่วน:

ตั้งคำตอบของคำถามข้อความสั้นให้เป็นตัวพิมพ์เล็ก : {QCODE=strtolower(QCODE.NAOK)};
ตั้งคำตอบเริ่มต้นให้คำถามประเภทอาร์เรย์ที่จุดเริ่มต้นของแบบสำรวจ : {Q1_SQ1=(is_empty(Q1_SQ1.NAOK),"A99",Q1_SQ1.NAOK)};
ตั้งคำตอบเริ่มต้นให้คำถามประเภทอาร์เรย์ข้อความที่จุดเริ่มต้นของแบบสำรวจ : {Q1_SQY1_SQX1 = (is_empty(Q1_SQY1_SQX1.NAOK),"Inserted answer", Q1_SQY1_SQX1.NAOK)};
ตั้งคำตอบตามเงื่อนไข : {QCODE=if(YesNo="Y","A1","")}

ความปลอดภัย XSS

เมื่อเปิดใช้งาน XSS ส่วนบางส่วนของระบบ Expression Manager จะไม่สามารถใช้งานได้:

การเริ่มแท็ก HTML ในนิพจน์หนึ่งแต่ไปปิดในอีกนิพจน์หนึ่ง
การใช้นิพจน์ที่ซับซ้อนภายใน URL

โปรดทราบว่า XSS จะเปิดใช้งานโดยค่าเริ่มต้นในการติดตั้ง LimeSurvey ทุกครั้ง

ตัวอย่างและวิธีแก้ปัญหาชั่วคราว:

{if( 1 ,"","")}information{if( 1 ,"","")} ใช้งานไม่ได้เมื่อเปิดใช้การรักษาความปลอดภัย XSS ในกรณีนี้คุณสามารถใช้ {if(1,"information","information")};
<a href="/script.php?value={if(QCODE == "Y","yes","no")}">next</a> ในกรณีนี้คุณสามารถใช้คำถามประเภทสมการได้ เนื่องจากการใช้รหัสคำถามแบบสมบูรณ์สามารถทำได้ : <a href="/script.php?value={EQUATION.NAOK}">next</a>

การเข้าถึงตัวแปร

ExpressionScript ให้สิทธิ์การเข้าถึงตัวแปรที่คุณอาจต้องใช้แบบอ่านอย่างเดียว เพื่อความเข้ากันได้กับเวอร์ชันก่อนหน้า ระบบจึงให้เข้าถึงสิ่งต่อไปนี้:

TOKEN:xxx - ค่าของ TOKEN (เช่น TOKEN:FIRSTNAME, TOKEN:ATTRIBUTE_5) (ใช้ได้เฉพาะไม่ใช่ แบบสำรวจแบบไม่ระบุตัวตน)
ค่า {XXX} ทั้งหมดที่ใช้โดยเทมเพลต
ในข้อความคำถาม คุณสามารถใช้ {QID} ซึ่งจะถูกแทนที่ด้วย ID ของคำถาม และ {SGQ} ซึ่งจะถูกแทนที่ด้วย SGQA ของคำถาม
{SAVEDID} สำหรับ ID การตอบแบบสอบถามปัจจุบัน

นอกจากนี้ ExpressionScript ยังให้คุณอ้างอิงตัวแปรด้วยรหัสคำถาม (คอลัมน์ 'title' ในตารางคำถามภายในฐานข้อมูล) ซึ่งเป็นป้ายกำกับตัวแปรที่ใช้เมื่อคุณส่งออกข้อมูลไปยัง SPSS, R หรือ SAS ด้วย ตัวอย่างเช่น หากคุณมีคำถามเกี่ยวกับชื่อ อายุ และเพศ คุณสามารถเรียกตัวแปรเหล่านั้นว่า name, age และ gender แทน 12345X13X22, 12345X13X23 และ 12345X13X24 วิธีนี้ทำให้ทุกคนอ่านสมการและตรวจสอบตรรกะได้ง่ายขึ้น อีกทั้งยังสามารถสลับลำดับคำถามได้โดยไม่ต้องติดตามหมายเลขกลุ่มหรือหมายเลขคำถาม

สำคัญ: การอ้างอิงตัวแปรที่อยู่ในหน้าหรือคำถามก่อนหน้าจะปลอดภัยกว่า

นอกจากนี้ ExpressionScript ยังให้คุณเข้าถึงคุณสมบัติหลายอย่างของคำถามได้:

ไวยากรณ์	ความหมาย	ตัวอย่าง	ผลลัพธ์ตัวอย่าง
Qcode	นามแฝงของ Qcode.code	{implode(',',name,gender)}	'Tom','M'
Qcode.code	รหัสคำตอบที่เลือกสำหรับคำถามหากคำถามนั้นมีความสัมพันธ์กัน (มิฉะนั้นจะว่างเปล่า) หรือค่าข้อความหากไม่ใช่คำถามที่มีรหัส	{implode(',',name.code,gender.code)}	'Tom','M'
Qcode.NAOK	เหมือนกับ Qcode - ดูคำอธิบายเรื่อง NAOK	{gender.NAOK}	'M'
Qcode.value	ค่าการประเมินสำหรับคำถามหากคำถามนั้นมีความสัมพันธ์กัน (มิฉะนั้นจะว่างเปล่า) หรือค่าข้อความหากไม่ใช่คำถามที่มีรหัส	{gender.value}	'1'
Qcode.valueNAOK	เหมือนกับ Qcode.value - ดูคำอธิบายเรื่อง NAOK	{gender.valueNAOK}	'1'
Qcode.shown	ค่าที่แสดงของคำถาม	{implode(',',name.shown,gender.shown)}	'Tom','Male'
Qcode.question	ข้อความของคำถาม	{gender.question}	'What is your gender?'
Qcode.mandatory	ระบุว่าคำถามเป็นคำถามที่จำเป็นหรือไม่ (Y/N)	{gender.mandatory}	'N'
Qcode.qid	หมายเลขคำถามภายใน (ไม่ใช่หมายเลขลำดับ)	{gender.qid}	337
Qcode.type	ชนิดของคำถาม	{gender.type}	'G'
Qcode.jsName	ชื่อ javascript ที่ถูกต้องของคำถาม ไม่ว่าจะประกาศไว้ในหน้านี้หรือไม่ก็ตาม	{gender.jsName}	'java1827X3X337'
Qcode.gid	หมายเลขกลุ่มภายใน (ไม่ใช่หมายเลขลำดับ)	{gender.gid}	3
Qcode.qseq	หมายเลขลำดับของคำถาม เริ่มจาก 0	{gender.qseq}	5
Qcode.gseq	หมายเลขลำดับของกลุ่ม เริ่มจาก 0	{gender.gseq}	1
Qcode.relevanceStatus	ระบุว่าขณะนี้คำถามมีความสัมพันธ์กันหรือไม่ (0 หรือ 1)	{gender.relevanceStatus}	1
Qcode.relevance	สมการความสัมพันธ์กันระดับคำถาม	{gender.relevance}	'!is_empty(name)'
Qcode.grelevance	สมการความสัมพันธ์กันระดับกลุ่ม	{gender.grelevance}	'num_children >= 5'
Qcode.sgqa	ค่า SGQA ของคำถามนี้	{gender.sgqa}	'1827X3X337'

ปัญหาเกี่ยวกับตัวแก้ไข HTML

หากคุณใช้ตัวแก้ไข HTML อักขระบางตัวจะถูกแทนที่ด้วย HTML entity

& by &
< by <
> by >

หากคุณใช้ตัวแก้ไข HTML คุณต้องใช้:

and สำหรับ &
lt สำหรับ <
le สำหรับ <=
gt สำหรับ >
ge สำหรับ >=

ขอแนะนำให้ลบ HTML ที่ปรากฏอยู่ภายในนิพจน์ของคุณออก หากคุณใช้ตัวแก้ไข HTML ของ LimeSurvey ให้คลิกปุ่ม "Source" (อยู่ที่ด้านซ้ายบนของตัวแก้ไข) แล้วลบอักขระทั้งหมดที่ไม่เกี่ยวข้องกับนิพจน์ของคุณ (เช่น

,
เป็นต้น)

การตั้งชื่อตัวแปร Qcode

ต่อไปนี้คือรายละเอียดวิธีสร้าง Qcode (และการเข้าถึงคุณสมบัติบางอย่าง) ตามประเภทคำถาม โดยทั่วไป Qcode จะถูกสร้างขึ้นดังนี้:

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

สำหรับ comment และ other รหัสคำถามที่สอดคล้องกันคือ QuestionCode_comment และ QuestionCode_other ตามลำดับ

ประเภท	คำอธิบาย	รหัส	คำถามย่อย	ตัวเลือกของคำตอบ	มาตราส่วน	รหัสคำตอบ	คำตอบที่แสดง	ความสัมพันธ์กัน
5	ปุ่มตัวเลือกแบบ 5 คะแนน	Q1		1-5		{Q1}	{Q1.shown}	{Q1==3}
B	อาร์เรย์ (ตัวเลือก 10 คะแนน) ปุ่มตัวเลือก	Q2	L1-L6	1-10		{Q2_L2}	{Q2_L2.shown}	{Q2_L2==7}
A	อาร์เรย์ ((ตัวเลือก 5 คะแนน)) ปุ่มตัวเลือก	Q3	1-5	1-5		{Q3_1}	{Q3_1.shown}	{Q3_1>=3}
1	อาร์เรย์ (ลาเบลแบบยืดหยุ่น) สองมาตราส่วน	Q4	sq1-sq5	0:a1-a3	1:b1-b3	{Q4_sq1_0}	{Q4_sq1_1.shown}	{Q4_sq1_1=='b2'}
H	อาร์เรย์ (แบบยืดหยุ่น) - รูปแบบคอลัมน์	Q5	1-5	s,m,t		{Q5_1}	{Q5_1.shown}	{Q5_1=='s'}
F	อาร์เรย์ (แบบยืดหยุ่น) - รูปแบบแถว	Q6	F1-F5	1-5		{Q6_F3}	{Q6_F3.shown}	{Q6_F3==4}
E	อาร์เรย์ (เพิ่มขึ้น / เท่าเดิม / ลดลง) ปุ่มตัวเลือก	Q7	1-7	I,S,D		{Q7_4}	{Q7_4.shown}	{Q7_4=='D'}
:	อาร์เรย์ (Multi Flexi) 1 ถึง 10	Q8	ls1,todo,ls2	min,max,avg		{Q8_ls1_max}	{Q8_ls2_avg.shown}	{Q8_ls2_min==7}
;	อาร์เรย์ (Multi Flexi) ข้อความ	Q9	hp,st,sw	1st,2nd,3rd		{Q9_hp_3rd}	{Q9_hp_3rd.shown}	{Q9_hp_3rd=='Peter'}
C	ตัวเลือก (ใช่/ไม่แน่ใจ/ไม่ใช่) ปุ่มตัวเลือก	Q10	1-5	Y,N,U		{Q10_1}	{Q10_1.shown}	{Q10_3=='Y'}
X	คำถามข้อความคงที่ (Boilerplate)	Q11					{Q11.shown}
D	วันที่	Q12				{Q12}	{Q12.shown}
*	สมการ	Q13				{Q13}	{Q13.shown}	{Q13>5}
~124~	อัพโหลดไฟล์ (บันทึกจำนวนไฟล์ที่อัปโหลด)	Q14				{Q14}		{Q14>0}
G	รายการเลือกแบบดึงลงเพศ	Q15		M,F		{Q15}	{Q15.shown}	{Q15=='M'}
U	ข้อความแบบยาวพิเศษ	Q16				{Q16}	{Q16.shown}	{strlen(Q16)>100}
I	คำถามภาษา	Q17				{Q17}	{Q17.shown}	{Q17=='en'}
!	รายการ - ดรอปดาวน์	Q18		1-5		{Q18}	{Q18.shown}	{Q18==3}
L	รายการเลือกแบบดึงลง/รายการปุ่มตัวเลือก	Q19		A-Z		{Q19}	{Q19.shown}	{Q19=='X'}
O	รายการพร้อมความคิดเห็น รายการเลือกแบบดึงลง/รายการปุ่มตัวเลือก + กล่องข้อความ	Q20		A-F		{Q20},{Q20comment}	{Q20.shown}	{Q20=='B'}
T	ข้อความแบบยาว	Q21				{Q21}	{Q21.shown}	{strstr(Q21,'hello')>0}
M	เลือกตอบได้หลายตัว ช่องทำเครื่องหมาย	Q22	A-F, other			{Q22_E}, {Q22_other}	{Q22_E.shown}, {Q22_other.shown}	{Q22_E=='Y'}
P	เลือกตอบได้หลายตัวพร้อมความคิดเห็น ช่องทำเครื่องหมาย + ข้อความ	Q23	A-F			{Q23_D}, {Q23_Dcomment}	{Q23_D.shown}	{!is_empty(Q23)}
K	คำถามตัวเลขหลายรายการ	Q24	self,mom,dad			{Q24_self}	{Q24_self.shown}	{Q24_self>30}
Q	ข้อความสั้นหลายรายการ	Q25	A-F			{Q25_B}	{Q25_B.shown}	{substr(Q25_B,1,1)=='Q'}
N	คำถามประเภทตัวเลข	Q26				{Q26}	{Q26.shown}	{Q26 > 30}
R	รูปแบบการจัดอันดับ	Q27	1-4			{Q27_1}	{Q27_1.shown}	{Q27_1==3}
S	ข้อความแบบสั้น	Q28				{Q28}	{Q28.shown}	{Q28=='mine'}
Y	ปุ่มตัวเลือกใช่/ไม่	Q29				{Q29}	{Q29.shown}	{Q29=='Y'}

การใช้ NAOK

NAOK --> "Not Applicable" (NA) is alright (OK) หรือ "ไม่เกี่ยวข้อง" ถือว่าใช้ได้

การใช้ NAOK หมายความว่าตัวแปรทั้งหมดหรือบางส่วนไม่มีความสัมพันธ์กัน (เช่น "Not Applicable" (NA) is alright (OK))

ตัวอย่างเช่น count(Q1_SQ1,Q1_SQ2,Q1_SQ3,Q1_SQ4) จะให้สตริงว่างเสมอหากมีคำถามย่อยหนึ่งข้อของ Q1 ถูกกรองออก ในการนับจำนวนคำถามย่อยที่ถูกเลือกในคำถามลักษณะนี้ สามารถใช้ count(Q1_SQ1.NAOK,Q1_SQ2.NAOK,Q1_SQ3.NAOK,Q1_SQ4.NAOK) ได้ หากคำถามย่อยถูกซ่อน EM จะส่งคืนสตริงว่าง

หากไม่มี NAOK เมื่อมีคำถามหรือคำถามย่อยหนึ่งข้อถูกซ่อน EM จะส่งคืนสตริงว่างเสมอ (เทียบเท่ากับการส่งคืนค่า false)

.shown จะใช้ระบบ NAOK เสมอ (สตริงว่างหากถูกซ่อน) แต่หากคุณต้องการรหัสของคำตอบ ควรเพิ่ม .NAOK หลังรหัสคำถามเสมอ (ยกเว้นกรณีที่คุณต้องการและเข้าใจสิ่งที่ทำอยู่)

ข้อมูลเพิ่มเติมอยู่ในหัวข้อย่อยการแทนที่เงื่อนไขแบบเรียงซ้อน

ตัวแปรสงวน "this", "self" และ "that"

บ่อยครั้งที่คุณต้องการประเมินทุกส่วนของคำถาม เช่น การนับจำนวนคำถามย่อยที่ได้รับคำตอบ หรือการรวมคะแนน บางครั้งคุณต้องการประมวลผลเฉพาะแถวหรือคอลัมน์บางส่วนของคำถาม (เช่น การหาผลรวมของแถวหรือคอลัมน์และจัดเก็บลงในฐานข้อมูล) ตัวแปรสงวนเหล่านี้ช่วยให้กระบวนการดังกล่าวทำได้ง่ายขึ้นมาก

ตัวแปร "This"

ตัวแปร "this" ใช้เฉพาะภายในตัวเลือก "สมการการตรวจสอบของคำถาม" และ "สมการการตรวจสอบคำถามย่อย" เท่านั้น (ตัวเลือกหลังไม่สามารถตั้งค่าได้จาก GUI) ตัวแปรนี้จะขยายเป็นชื่อตัวแปรของแต่ละเซลล์ภายในคำถามเหล่านั้น ดังนั้น หากคุณต้องการให้แน่ใจว่าแต่ละรายการมีค่ามากกว่าสาม คุณจะตั้งค่า "สมการการตรวจสอบคำถามย่อย" เป็น (this > 3)

ตัวแปร "Self"

ตัวแปร "self" และ "that" มีประสิทธิภาพมากกว่า และทำหน้าที่เป็นแมโครที่ถูกขยายก่อนการประมวลผลสมการ รูปแบบไวยากรณ์ที่ใช้ได้สำหรับตัวแปร "self" คือ:

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

suffix คือคำต่อท้าย qcode ปกติใดก็ได้ (เช่น NAOK, value, shown)

sub-selector สามารถเป็นอย่างใดอย่างหนึ่งต่อไปนี้:

comments - เฉพาะคำถามย่อยที่เป็นความคิดเห็น (เช่น เลือกตอบได้หลายตัวพร้อมความคิดเห็น และ รายการพร้อมความคิดเห็น);
nocomments - เฉพาะคำถามย่อยที่ไม่ใช่ความคิดเห็น;
sq_X - โดยที่ X คือตัวระบุแถวหรือคอลัมน์ ระบบจะเลือกเฉพาะคำถามย่อยที่ตรงกับรูปแบบ X โปรดทราบว่าการค้นหาทำกับตัวระบุรหัสแบบสมบูรณ์ จากนั้น sq_X จะตรงกับและรวมคำถามย่อย nX, X, Xn (เช่น หากคุณใช้ sq_1 คำถามย่อย a1, 1a, 1, 11 หรือ 001 จะถูกรวมไว้ด้วย) โปรดระวังในคำถามประเภทมาตราส่วนคู่ ซึ่งรหัสคำถามย่อยคือ QCODE_SQCODE_1 และ QCODE_SQCODE_1 และในคำถามประเภทการจัดอันดับ ซึ่งรหัสคำถามย่อยคือ QCODE_1,QCODE_2 ....

ตัวอย่าง:

มีการตอบคำถามในส่วนใดส่วนหนึ่งแล้วหรือไม่ -> {count(self.NAOK)>0}
คะแนนการประเมินของคำถามนี้คือเท่าไร -> {sum(self.value)}

คุณยังสามารถใช้ตัวแปรเหล่านี้เพื่อหาผลรวมของแถวและคอลัมน์ได้ สมมติว่าคุณมีอาร์เรย์ของตัวเลขที่มีแถว A-E และคอลัมน์ 1-5

ผลรวมสุดท้ายคือเท่าไร -> {sum(self.NAOK)}
ผลรวมของแถว B คือเท่าไร -> {sum(self.sq_B.NAOK)}
ผลรวมของคอลัมน์ 3 คือเท่าไร -> {sum(self.sq_3.NAOK)}

ตัวแปร "That"

ตัวแปร "that" คล้ายกับตัวแปร "self" แต่ช่วยให้คุณอ้างอิงถึงคำถามอื่นได้ ไวยากรณ์คือ:

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

qname คือชื่อคำถามที่ไม่มีส่วนขยายของคำถามย่อย ดังนั้น สมมติว่าเราสร้างคำถาม 'q1' โดยที่ 'q' ก็คือ qname ของคำถามนั้นด้วย

ตัวอย่าง:

มีการตอบคำถาม q1 ในส่วนใดส่วนหนึ่งแล้วหรือไม่ -> {count(that.q1.NAOK)>0}
คะแนนการประเมินของ q2 คือเท่าไร -> {sum(that.q2.NAOK)}
ผลรวมสุดท้ายของ q3 คือเท่าไร -> {sum(that.q3.NAOK)}
ผลรวมของแถว C ใน q4 คือเท่าไร -> {sum(that.q4.sq_C.NAOK)}
ผลรวมของคอลัมน์ 2 ใน q4 คือเท่าไร -> {sum(that.q4.sq_2.NAOK)}

ตัวแปร "self" และ "that" สามารถใช้ได้ในความสัมพันธ์กัน การตรวจสอบ หรือการปรับแต่งข้อความ (tailoring) ทุกแบบ

ข้อควรระวังอย่างหนึ่งคือ เมื่อคุณใช้ฟีเจอร์ Show logic file ระบบจะแสดงค่าที่ขยายแล้วของ "self" และ "that" ซึ่งช่วยให้คุณเห็นสมการจริงที่จะถูกสร้างขึ้น เพื่อให้คุณ (และ EM) ตรวจสอบได้ว่ามีตัวแปรเหล่านั้นอยู่หรือไม่ อาจดูสับสนเนื่องจากคุณอาจเห็นสมการที่ยาวมาก อย่างไรก็ตาม หากคุณแก้ไขคำถาม คุณจะเห็นสมการต้นฉบับที่ใช้ "self" และ/หรือ "that"

คุณไม่ควรใช้ตัวแปรเหล่านี้ หาก

คุณต้องการระบุชื่อของแต่ละตัวแปรที่ใช้ในสมการอย่างชัดเจน หรือ
ใช้ตัวแปรที่ไม่มีคำถามย่อย (เช่น คำถามที่ตอบได้ข้อเดียว) ในกรณีเหล่านี้ การใส่ "that" นำหน้าตัวแปรถือว่าเกินความจำเป็น และคุณอาจได้ผลลัพธ์ที่ไม่คาดคิด

การเข้าถึงฟังก์ชัน

ExpressionScript ให้คุณเข้าถึงฟังก์ชันทางคณิตศาสตร์ ฟังก์ชันสตริง และฟังก์ชันที่ผู้ใช้กำหนดเอง ดังที่แสดงด้านล่าง ฟังก์ชันเหล่านี้มีเวอร์ชันเทียบเท่าใน PHP และ JavaScript เพื่อให้ทำงานได้เหมือนกันทั้งฝั่งเซิร์ฟเวอร์ (PHP) และฝั่งไคลเอนต์ (JavaScript) และสามารถเพิ่มฟังก์ชันใหม่ได้โดยง่าย

ฟังก์ชันที่มีให้ใช้งาน

ขณะนี้มีฟังก์ชันต่อไปนี้ให้ใช้งาน:

ฟังก์ชัน	ความหมาย	ไวยากรณ์
abs	ค่าสัมบูรณ์	number abs(number)
acos	อาร์กโคไซน์	number acos(number)
addslashes	ใส่เครื่องหมายสแลชให้กับสตริง	string addslashes(string)
asin	อาร์กไซน์	number asin(number)
atan	อาร์กแทนเจนต์	number atan(number)
atan2	อาร์กแทนเจนต์ของสองตัวแปร	number atan2(number, number)
ceil	ปัดเศษขึ้น	number ceil(number)
checkdate	ส่งค่า true(1) ถ้าเป็นวันที่ที่ถูกต้องในปฏิทินเกรกอเรียน	bool checkdate(month,day,year)
convert_value	แปลงค่าตัวเลขโดยใช้ inputTable และ outputTable ของค่าตัวเลข	number convert_value(fValue, iStrict, sTranslateFromList, sTranslateToList)
cos	โคไซน์	number cos(number)
count	นับจำนวนคำถามที่ได้รับคำตอบ (ไม่ว่างเปล่า) ในรายการ	number count(arg1, arg12, ..., argN)
countif	นับจำนวนคำถามที่ได้รับคำตอบในรายการที่เท่ากับอาร์กิวเมนต์แรก	number countif(matches, arg1, arg2, ... argN)
countifop	นับจำนวนคำถามที่ได้รับคำตอบในรายการที่ผ่านเกณฑ์ (arg op value)	number countifop(op, value, arg1, arg2, ... argN)
date	รูปแบบ วันที่/เวลาท้องถิ่น	string date(format [, timestamp=time()])
exp	คำนวณเลขชี้กำลังของ e	number exp(number)
fixnum	แสดงตัวเลขโดยใช้เครื่องหมายจุลภาคเป็นตัวคั่นทศนิยม หากจำเป็น	string fixnum(number)
floor	ปัดเศษลง	number floor(number)
gmdate	รูปแบบวันที่แบบ GMT date/time	string gmdate(format [, timestamp=time()])
html_entity_decode	แปลง HTML entity ทั้งหมดเป็นอักขระที่เกี่ยวข้อง (ใช้ ENT_QUOTES และ UTF-8 เสมอ)	string html_entity_decode(string)
htmlentities	แปลงอักขระที่เกี่ยวข้องทั้งหมดเป็น HTML entity (ใช้ ENT_QUOTES และ UTF-8 เสมอ)	string htmlentities(string)
expr_mgr_htmlspecialchars	แปลงอักขระพิเศษเป็น HTML entity (ใช้ ENT_QUOTES และ UTF-8 เสมอ)	string htmlspecialchars(string)
expr_mgr_htmlspecialchars_decode	แปลง HTML entity พิเศษกลับเป็นอักขระ (ใช้ ENT_QUOTES และ UTF-8 เสมอ)	string htmlspecialchars_decode(string)
idate	รูปแบบ เวลา/วันที่ท้องถิ่น เป็นจำนวนเต็ม	string idate(string [, timestamp=time()])
if	if แบบ Excel: if(test,result_if_true,result_if_false)	if(test,result_if_true,result_if_false)
implode	เชื่อมค่าในอาร์เรย์ด้วยสตริง	string implode(glue,arg1,arg2,...,argN)
intval	รับค่าจำนวนเต็มของตัวแปร	int intval(number [, base=10])
is_empty	ตรวจสอบว่าตัวแปรถือว่าว่างเปล่าหรือไม่	bool is_empty(var)
is_float	ตรวจสอบว่าชนิดของตัวแปรเป็น float หรือไม่	bool is_float(var)
is_int	ตรวจสอบว่าชนิดของตัวแปรเป็นจำนวนเต็มหรือไม่	bool is_int(var)
is_nan	หาชนิดของตัวแปรที่ไม่ใช่ตัวเลข	bool is_nan(var)
is_null	หาตัวแปรที่เป็น NULL	bool is_null(var)
is_numeric	ตรวจสอบว่าตัวแปรเป็นตัวเลขหรือสตริงตัวเลขหรือไม่	bool is_numeric(var)
is_string	ตรวจสอบว่าชนิดของตัวแปรเป็นสตริงหรือไม่	bool is_string(var)
join^{(New in 2.0 build 130129)}	เชื่อมองค์ประกอบเป็นสตริงใหม่	join(arg1, arg2, ... argN)
list	ส่งคืนรายการค่าที่ไม่ว่างเปล่าโดยคั่นด้วยเครื่องหมายจุลภาค	string list(arg1, arg2, ... argN)
listifop^{(New in 3.16.1 )}	ส่งคืนรายการที่คั่นด้วย 'glue' ของคุณสมบัติคำถามที่ระบุ (retProp) จากคำถามในรายการที่ผ่านเกณฑ์ (cmpProp op value)	string listifop(cmpProp, op, value, retProp, glue, sgqa1, sgqa2, ... sgqaN)
ltrim	ตัดช่องว่าง (หรืออักขระอื่น) ออกจากจุดเริ่มต้นของสตริง	string ltrim(string [, charlist])
max	หาค่าสูงสุด	number max(arg1, arg2, ... argN)
min	หาค่าต่ำสุด	number min(arg1, arg2, ... argN)
mktime	รับค่าประทับเวลา UNIX ของวันที่ (อาร์กิวเมนต์ทั้ง 6 ตัวเป็นตัวเลือก)	number mktime([hour [, minute [, second [, month [, day [, year ]]]]]])
modulo-function	ยังไม่รองรับฟังก์ชัน modulo คุณสามารถใช้ฟังก์ชัน floor() แทนได้	floor(x/y)==(x/y)
nl2br	แทรกการขึ้นบรรทัดใหม่ HTML ก่อนอักขระขึ้นบรรทัดใหม่ทั้งหมดในสตริง	string nl2br(string)
number_format	รูปแบบตัวเลขโดยมีการจัดกลุ่มหลักพัน	string number_format(number)
pi	รับค่าของ pi	number pi()
pow	นิพจน์เอ็กซ์โปเนนเชียล	number pow(base, exp)
quoted_printable_decode	แปลงสตริงแบบ quoted-printable เป็นสตริง 8 บิต	string quoted_printable_decode(string)
quoted_printable_encode	แปลงสตริง 8 บิตเป็นสตริงแบบ quoted-printable	string quoted_printable_encode(string)
quotemeta	อ้างอักขระเมตา	string quotemeta(string)
rand	สร้างเลขสุ่ม ดูตัวอย่างนี้	int rand() OR int rand(min, max)
regexMatch	เปรียบเทียบสตริงกับนิพจน์ปรกติ	bool regexMatch(pattern,input)
round	ปัดเศษตัวเลขเป็นความแม่นยำเสริม	number round(val [, precision])
rtrim	ตัดช่องว่าง (หรืออักขระอื่น) ออกจากท้ายสตริง	string rtrim(string [, charlist])
sin	ไซน์	number sin(arg)
sprintf	ส่งคืนสตริงที่จัดรูปแบบ	string sprintf(format, arg1, arg2, ... argN)
sqrt	รากที่สอง	number sqrt(arg)
stddev	คำนวณค่าเบี่ยงเบนมาตรฐานของกลุ่มตัวอย่างสำหรับรายการตัวเลข	number stddev(arg1, arg2, ... argN)
str_pad	เติมสตริงให้ได้ความยาวที่กำหนดด้วยสตริงอื่น	string str_pad(input, pad_length [, pad_string])
str_repeat	ซ้ำค่าอักขระ	string str_repeat(input, multiplier)
str_replace	แทนที่สตริงที่ค้นหาทุกรายการด้วยสตริงทดแทน	string str_replace(search, replace, subject)
strcasecmp	การเปรียบเทียบสตริงที่ไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่ที่ปลอดภัยแบบไบนารี	int strcasecmp(str1, str2)
strcmp	การเปรียบเทียบสตริงที่ปลอดภัยแบบไบนารี	int strcmp(str1, str2)
strip_tags	แยก TAG HTML และ PHP ออกจากข้อความ	string strip_tags(str, allowable_tags)
stripos	ค้นหาตำแหน่งการเกิดขึ้นครั้งแรกของสตริงยูนิโค้ดโดยไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่ (เริ่มจาก 0 ส่งค่า false หากไม่พบ)	int stripos(haystack, needle [, offset=0])
stripslashes	ยกเลิกเครื่องหมายคำพูดจากข้อความที่มีเครื่องหมายคำพูด	string stripslashes(string)
stristr	strstr .ตัวพิมพ์เล็กและตัวพิมพ์ใหญ่	string stristr(haystack, needle [, before_needle=false])
strlen	รับค่าความยาวอักขระ	int strlen(string)
strpos	ค้นหาตำแหน่งการเกิดขึ้นครั้งแรกของสตริงยูนิโค้ด (เริ่มจาก 0 ส่งค่า false หากไม่พบ)	int strpos(haystack, needle [ offset=0])
strrev	กลับค่าอักขระ	string strrev(string)
strstr	ค้นหาการเกิดขึ้นครั้งแรกของสตริง	string strstr(haystack, needle[, before_needle=false])
strtolower	แปลงสตริงเป็นตัวพิมพ์เล็ก	string strtolower(string)
strtotime	แปลงคำอธิบายวันที่และเวลาที่เป็นข้อความภาษาอังกฤษให้เป็นประทับเวลา Unix	int strtotime(string)
strtoupper	แปลงสตริงเป็นตัวพิมพ์ใหญ่	string strtoupper(string)
substr	ส่งคืนส่วนหนึ่งของสตริงยูนิโค้ด	string substr(string, start [, length])
sum	คำนวณผลรวมของค่าในอาร์เรย์	number sum(arg1, arg2, ... argN)
sumifop	รวมค่าของคำถามที่ได้รับคำตอบในรายการที่ผ่านเกณฑ์ (arg op value)	number sumifop(op, value, arg1, arg2, ... argN)
tan	แทนเจนต์	number tan(arg)
time	ส่งค่าปัจจุบันของประทับเวลาU NIX	number time()
trim	ตัดช่องว่าง (หรืออักขระอื่น) ออกจากจุดเริ่มต้นและท้ายสตริง	string trim(string [, charlist])
ucwords	แปลงอักขระตัวแรกของแต่ละคำในสตริงเป็นตัวพิมพ์ใหญ่	string ucwords(string)
unique	ตอบกลับเป็นค่า จริง ถ้าการตอบคำถามที่ไม่ว่างเปล่าทั้งหมดไม่ซ้ำกัน	boolean unique(arg1, ..., argN)

คลิกที่นี่หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับฟังก์ชันที่วางแผนไว้ (หรือที่อยู่ระหว่างการพิจารณา)

สร้างฟังก์ชันนิพจน์ใหม่ด้วยปลั๊กอิน ^{(New in 4.0.0 )}

หากคุณต้องการฟังก์ชันใหม่ที่ไม่มีอยู่ในแกนหลัก คุณสามารถสร้างฟังก์ชันนั้นด้วยปลั๊กอินได้ ฟังก์ชันใหม่ดังกล่าวสร้างขึ้นโดยใช้เหตุการณ์ expressionManagerStart

ExpressionScript ทราบว่าตัวแปรใดเป็นตัวแปรภายใน

เพื่อสร้าง JavaScript สำหรับหน้าได้อย่างถูกต้อง EM จำเป็นต้องทราบว่าตัวแปรใดถูกกำหนดไว้ในหน้านั้น และ JavaScript ID ของตัวแปรเหล่านั้นคืออะไร (เช่น สำหรับ document.getElementById(x)) นอกจากนี้ EM ยังต้องทราบด้วยว่าตัวแปรใดถูกกำหนดไว้ในหน้าอื่น (เพื่อให้แน่ใจว่าช่อง <input type='hidden' value='x'> ที่จำเป็นมีอยู่และมีข้อมูลครบถ้วน)

เงื่อนไขแบบลดหลั่น

หากตัวแปรใดตัวแปรหนึ่งไม่มีความสัมพันธ์กัน (irrelevant) สมการทั้งหมดจะไม่มีความสัมพันธ์กัน (false) ตัวอย่างเช่น ในตารางต่อไปนี้ N/A หมายถึงตัวแปรตัวใดตัวหนึ่งไม่เกี่ยวข้อง:

ตัวดำเนินการ	ตัวอย่าง	a	b	ผลลัพธ์
+ (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

การแทนที่เงื่อนไขแบบลดหลั่น

สมมติว่าคุณต้องการแสดงผลรวมสะสมของคำตอบที่เกี่ยวข้องทั้งหมด คุณอาจลองใช้สมการ {sum(q1,q2,q3,...,qN)} แต่สมการนี้จะถูกแปลงภายในเป็น LEMif(LEManyNA("q1","q2","q3",...,"qN"),"",sum(LEMval("q1"),LEMval("q2"),LEMval("q3"),...,LEMval("qN"))) ดังนั้น หากค่าใดค่าหนึ่งตั้งแต่ q1-qN ไม่เกี่ยวข้อง สมการจะคืนค่า false เสมอ ในกรณีนี้ sum() จะแสดง "0" จนกว่าจะตอบคำถามครบทุกข้อ

เพื่อหลีกเลี่ยงปัญหานี้ คุณสามารถเพิ่มคำต่อท้าย ".NAOK" (หมายถึง Not Applicable is OK) ให้กับแต่ละตัวแปรได้ ในกรณีดังกล่าวจะเกิดพฤติกรรมดังต่อไปนี้ สมมติว่าคุณมีตัวแปร q1.NAOK:

q1 จะไม่ถูกเพิ่มลงในส่วนคำสั่ง LEManyNA()
LEMval('q1') จะยังคงตรวจสอบว่าการตอบคำถามนั้นเกี่ยวข้องหรือไม่ และจะคืนค่า "" หากไม่เกี่ยวข้อง (ดังนั้นการตอบคำถามที่ไม่เกี่ยวข้องแต่ละรายการจะถูกละเว้น แต่จะไม่ทำให้นิพจน์ทั้งหมดเป็นโมฆะ)

ดังนั้น วิธีแก้ปัญหาผลรวมสะสมคือการใช้สมการ sum(q1.NAOK,q2.NAOK,q3.NAOK,...,qN.NAOK)

การใช้คำต่อท้าย .NAOK ยังช่วยให้ผู้สร้างออกแบบแบบสำรวจที่มีเส้นทางที่เป็นไปได้หลายเส้นทาง แล้วมาบรรจบกันที่เส้นทางร่วมในภายหลังได้ ตัวอย่างเช่น สมมติว่าผู้ตอบตอบแบบสำรวจในลักษณะที่อยู่นอกช่วงปกติของการตอบคำถาม ผู้สร้างสามารถแจ้งเตือนผู้ตอบว่าอาจไม่ได้ผลลัพธ์ที่ถูกต้อง และถามว่าต้องการทำแบบสำรวจต่อหรือไม่ หากตอบว่า "ใช่" คำถามที่เหลือจะถูกแสดง เงื่อนไขสำหรับ "คำถามที่เหลือ" จะตรวจสอบว่าคำตอบเริ่มต้นอยู่ในช่วงปกติ หรือผู้ตอบตอบว่า "ใช่" ในคำถามที่เกี่ยวข้องเฉพาะเมื่อตอบอยู่นอกช่วงปกติ

ExpressionScript รองรับ micro-tailoring แบบมีเงื่อนไขได้อย่างไร?

ต่อไปนี้เป็นตัวอย่างของ micro-tailoring (โดย Question Type=='expr' หมายถึงสมการ):

รหัสคำถาม	ความสัมพันธ์กัน	ชนิดของคำถาม	คำถาม
name	1	text	คุณชื่ออะไร?
age	1	text	คุณอายุเท่าไร?
badage	!is_empty(age)	expr	{(age<16) or (age>80)}
agestop	badage	message	ขออภัย {name} คุณ{if( (age<16),'อายุน้อย',if( (age>80),'อายุมาก','วัยกลางคน') ) }เกินไปสำหรับการทดสอบนี้
kids	!badage	yesno	คุณมีบุตรหรือไม่?
parents	1	expr	{!badage && kids=='Y'}
numKids	parents	text	คุณมีบุตรกี่คน?
kid1	parents && numKids >= 1	text	บุตรคนแรกของคุณอายุเท่าไร?
kid2	parents && numKids >= 2	text	บุตรคนที่สองของคุณอายุเท่าไร?
kid3	parents && numKids >= 3	text	บุตรคนที่สามของคุณอายุเท่าไร?
kid4	parents && numKids >= 4	text	บุตรคนที่สี่ของคุณอายุเท่าไร?
kid5	parents && numKids >= 5	text	บุตรคนที่ห้าของคุณอายุเท่าไร?
sumage	1	expr	{sum(kid1.NAOK,kid2.NAOK,kid3.NAOK,kid4.NAOK,kid5.NAOK)}
report	parents	text	{name} คุณบอกว่าคุณอายุ {age} ปี และมีบุตร {numKids} คน ผลรวมอายุของบุตร {min(numKids,5)} คนแรกของคุณคือ {sumage}

หากต้องการดาวน์โหลดตัวอย่างแบบสำรวจข้างต้น ให้คลิกลิงก์ต่อไปนี้: ตัวอย่างแบบสำรวจจำนวนบุตร

คำถามเหล่านี้ทั้งหมดสามารถอยู่ในหน้าเดียวกันได้ (เช่น อยู่ในกลุ่มเดียวกัน) และจะแสดงเฉพาะคำถามที่เกี่ยวข้องเท่านั้น นอกจากนี้ เมื่อคุณป้อนอายุของบุตร นิพจน์ sum() ในคำถามสุดท้ายจะถูกอัปเดตแบบไดนามิก

ExpressionScript ทำงานนี้ได้โดยการครอบแต่ละนิพจน์ด้วยองค์ประกอบ ที่มีชื่อกำกับ ทุกครั้งที่ค่ามีการเปลี่ยนแปลง ระบบจะคำนวณนิพจน์ที่ควรปรากฏในองค์ประกอบ นั้นใหม่ และสร้างการแสดงผลขึ้นใหม่ คุณสามารถมีนิพจน์แบบปรับแต่งเช่นนี้ได้หลายสิบหรือหลายร้อยรายการในหน้าเดียวกัน

การเน้นไวยากรณ์

เพื่อช่วยในการป้อนและตรวจสอบนิพจน์ EM มีการเน้นไวยากรณ์พร้อมคุณสมบัติดังต่อไปนี้:

ประเภทและความหมายของการเน้นไวยากรณ์

สี	ตัวอย่าง	ความหมาย	ทูลทิป	ความคิดเห็น
พื้นหลังสีแทน	Sample	สมการทั้งหมด	ไม่มี	ข้อความใดๆ ภายในวงเล็บปีกกาที่ระบบรู้จักว่าเป็นสมการ (เช่น ไม่มีช่องว่างนำหน้าหรือต่อท้าย) จะถูกแสดงด้วยพื้นหลังสีแทนเพื่อให้แยกจากข้อความโดยรอบได้ง่าย
ข้อความตัวหนาสีแดง	Sample	ข้อผิดพลาด	คำอธิบายเกี่ยวกับข้อผิดพลาด	อาจเป็นตัวแปรที่ไม่รู้จักหรือข้อผิดพลาดในฟังก์ชัน แบบสำรวจจะใช้งานไม่ได้ และคำถามที่ขึ้นอยู่กับนิพจน์นั้นจะไม่ถูกแสดงให้ผู้ตอบเห็น
ข้อความสีน้ำเงิน	Sample	ชื่อฟังก์ชัน	ความหมายและไวยากรณ์ที่อนุญาต	หมายถึงชื่อฟังก์ชันหรือสิ่งที่ควรเป็นฟังก์ชันเนื่องจากตามด้วยวงเล็บเปิด จะแสดงเป็นข้อความตัวหนาสีน้ำเงิน ทูลทิปจะแสดงความหมายและไวยากรณ์ที่อนุญาตของฟังก์ชัน
ข้อความสีเทา	Sample	สตริง	ไม่มี	สตริงที่อยู่ในเครื่องหมายอัญประกาศเดี่ยวและคู่จะแสดงเป็นข้อความสีเทา
ข้อความสีฟ้าอมเขียว (cyan)	Sample	ตัวแปรที่กำหนดในหน้าเดียวกัน	[name]: คำถาม; ค่า; answerList ที่แสดงรหัสของแต่ละค่า	ตัวแปรใดๆ ที่กำหนดในหน้าเดียวกับคำถามที่คุณกำลังแก้ไขจะแสดงเป็นข้อความสีฟ้าอมเขียว (สามารถอัปเดตได้ใน JavaScript) ทูลทิปจะแสดงชื่อ คำถามจริง และค่าปัจจุบัน (หรือว่างหากยังไม่ได้กำหนด) หากชนิดของคำถามคาดหวังคำตอบจากชุดค่าที่ระบุไว้ จะแสดงการจับคู่ระหว่างรหัสกับค่าที่แสดง
ข้อความสีเขียว	Sample	ตัวแปรที่กำหนดในหน้าก่อนหน้า	[name]: คำถาม; ค่า; answerList ที่แสดงรหัสของแต่ละค่า	ตัวแปรใดๆ ที่กำหนดในหน้าก่อนหน้าจะแสดงเป็นข้อความตัวหนาสีเขียว ทูลทิปจะแสดงชื่อ คำถามจริง และค่าปัจจุบัน (หรือว่างหากยังไม่ได้กำหนด) หากชนิดของคำถามคาดหวังคำตอบจากชุดค่าที่ระบุไว้ จะแสดงการจับคู่ระหว่างรหัสกับค่าที่แสดง
ข้อความตัวหนาสีชมพู	Sample	ตัวแปรที่กำหนดในหน้าถัดไป ^{โดยทั่วไป: ว่างเมื่อเริ่มแบบสำรวจ แต่สามารถมีค่าได้จากหน้าสารบัญหรือการย้อนกลับ}	[name หรือรหัส SGQA]: คำถาม; ค่า; answerList ที่แสดงรหัสของแต่ละค่า	ตัวแปรที่กำหนดในหน้าถัดไปจะแสดงเป็นข้อความตัวหนาสีชมพู ทูลทิปจะแสดงชื่อ คำถามจริง และค่าปัจจุบัน (หรือว่างหากยังไม่ได้กำหนด) หากชนิดของคำถามคาดหวังคำตอบจากชุดค่าที่ระบุไว้ จะแสดงการจับคู่ระหว่างรหัสกับค่าที่แสดง
ข้อความตัวหนาสีแทน	Sample	ค่าแทนที่ของ Lime	ค่า	สตริงแทนที่ของ Lime (เช่น {TOKEN:xxx}, {PRIVACY_MESSAGE}) จะแสดงเป็นข้อความตัวหนาสีแทน
ข้อความสีแดง	Sample	ตัวดำเนินการกำหนดค่า (=)	ข้อความเตือน	หากคุณใช้ตัวดำเนินการกำหนดค่า (=) ตัวดำเนินการนั้นจะแสดงเป็นข้อความสีแดง เพื่อช่วยป้องกันการกำหนดค่าใหม่โดยไม่ตั้งใจ ในกรณีที่คุณตั้งใจจะตรวจสอบว่า a == b แต่กลับเป็นการกำหนดค่า a = b
ข้อความสีดำปกติ	Sample	เครื่องหมายวรรคตอน	ไม่มี	เครื่องหมายวรรคตอนอื่นๆ ทั้งหมดภายในนิพจน์จะแสดงเป็นข้อความสีดำปกติ
ข้อความในกรอบสีแดง	เส้นสีแดงตัวหนาล้อมรอบข้อผิดพลาด	ข้อผิดพลาดทางไวยากรณ์	คำอธิบายของข้อผิดพลาด	ข้อผิดพลาดทางไวยากรณ์ที่ตรวจพบจะแสดงภายในกรอบสีแดง ทูลทิปจะแสดงข้อผิดพลาดนั้น ตัวอย่างเช่น วงเล็บไม่ครบคู่ การใช้ฟังก์ชันที่ไม่ได้กำหนดไว้ การส่งจำนวนอาร์กิวเมนต์ให้ฟังก์ชันไม่ถูกต้อง นิพจน์ที่มีโครงสร้างไม่ดี (เช่น ไม่มีตัวดำเนินการระหว่างตัวแปร) การพยายามกำหนดค่าใหม่ให้ตัวแปรที่เป็นแบบอ่านอย่างเดียว การพยายามกำหนดค่าให้สิ่งที่ไม่ใช่ตัวแปร หรือการใช้ไวยากรณ์ที่ไม่รองรับ โปรดทราบว่าระบบตรวจจับข้อผิดพลาดทางไวยากรณ์อาจรายงานข้อผิดพลาดเพียงรายการเดียวในนิพจน์ แม้จะมีข้อผิดพลาดหลายรายการ อย่างไรก็ตาม หากตรวจพบข้อผิดพลาดใดๆ จะแสดงอย่างน้อยหนึ่งรายการ

ทูลทิป (tooltip) หมายถึงข้อความป๊อปอัปที่แสดงขึ้นเมื่อคุณวางเมาส์เหนือฟังก์ชันและตัวแปรบางรายการ

บทหลัก

ExpressionScript - การนำเสนอ

From LimeSurvey Manual