แชร์ผ่าน

ลักษณะการทํางานของตัวดําเนินการ

  • บทความ

ส่วนนี้กําหนดลักษณะการทํางานของตัวดําเนินการ M ต่างๆ

ลำดับความสำคัญของตัวดำเนินการ

เมื่อนิพจน์ประกอบด้วยตัวดําเนินการ หลายตัว ลําดับความสําคัญ ของตัวดําเนินการจะควบคุมลําดับในการประเมินผลตัวดําเนินการแต่ละตัว ตัวอย่างเช่น นิพจน์ x + y * z จะถูกประเมินเป็น x + (y * z) เนื่องจากตัว*ดําเนินการ มีความสําคัญสูงกว่าตัวดําเนินการไบนารี+ ลําดับความสําคัญของตัวดําเนินการจะเป็นไปตามข้อกําหนดของการผลิตไวยากรณ์ที่เกี่ยวข้อง ตัวอย่างเช่น additive-expression ประกอบด้วยลําดับของ multiplicative-expression's ที่คั่นด้วย+ตัวดําเนินการ หรือ - ดังนั้น จึงให้+ตัวดําเนินการ และ - มีความสําคัญต่ํากว่าตัว*ดําเนินการ และ/

การผลิต parenthesized-expression สามารถใช้เพื่อเปลี่ยนการจัดลําดับความสําคัญค่าเริ่มต้นได้

parenthesized-expression:
      (นิพจน์)

ตัวอย่างเช่น

1 + 2 * 3       // 7 
(1 + 2) * 3     // 9

ตารางต่อไปนี้สรุปเกี่ยวกับตัวดําเนินการ M โดยแสดงรายการหมวดหมู่ตัวดําเนินการตามลําดับลําดับความสําคัญจากสูงสุดไปต่ําสุด ตัวดําเนินการในหมวดหมู่เดียวกันจะมีลําดับความสําคัญเท่ากัน

ประเภท Expression Description
รายการหลัก ฉัน
@ฉัน		 นิพจน์ตัวระบุ
(x) นิพจน์ที่มีวงเล็บ
x[i] การค้นหา
x{y} การเข้าถึงหน่วยข้อมูล
x(...) การเรียกฟังก์ชัน
{x, y, ...} การเตรียมใช้งานรายการ
[ i = x, ... ] การเตรียมใช้งานเรกคอร์ด
... ไม่ได้นํามาใช้
ยูนารี +X ข้อมูลประจำตัว
-X ค่าลบ
notX นิเสธเชิงตรรกะ
เมตาดาต้า xmetay เชื่อมโยงเมตาดาต้า
การคูณ x * y การคูณ
x / y ประเภทย่อย
เสริม x + y การเพิ่มเติม
x - y การลบ
เชิงสัมพันธ์ x< y น้อยกว่า
x > y มากกว่า
x<= y น้อยกว่าหรือเท่ากับ
x >= y มากกว่าหรือเท่ากับ
Equality x = y เท่ากับ
x<> y Not equal
การยืนยันชนิด xasy ใช้งานร่วมกันได้กับประเภทดั้งเดิมแบบที่เป็นค่าว่างได้หรือข้อผิดพลาด
ความสอดคล้องกันของชนิด xisy ทดสอบหากเป็นประเภทดั้งเดิมแบบที่เป็นค่าว่างได้ที่เข้ากันได้
ตรรกะ และ xandy การรวมกันเชิงวงจรแบบสั้น
ตรรกะ หรือ xory การแยกเชิงวงจรแบบสั้น
Coalesce x??y ตัวดําเนินการ Coalescing Null

ตัวดําเนินการและเมตาดาต้า

ทุกค่ามีค่าเรกคอร์ดที่เชื่อมโยงกัน ซึ่งสามารถดําเนินการข้อมูลเพิ่มเติมเกี่ยวกับค่าดังกล่าวได้ เรกคอร์ดนี้เรียกว่า เรกคอร์ด ของเมตาดาต้าสําหรับค่าหนึ่ง ๆ เรกคอร์ดของเมตาดาต้าสามารถเชื่อมโยงกับค่าชนิดใดก็ได้ แม้แต่null ผลลัพธ์ของการเชื่อมโยงดังกล่าวคือค่าใหม่ที่มีเมตาดาต้าที่กําหนด

เรกคอร์ดของเมตาดาต้าเป็นเพียงเรกคอร์ดปกติ และสามารถมีเขตข้อมูลและค่าใดๆ ที่เรกคอร์ดปกติสามารถมีได้ และเรกคอร์ดดังกล่าวยังมีเรกคอร์ดของเมตาดาต้าอีกด้วย การเชื่อมโยงเรกคอร์ดของเมตาดาต้ากับค่าเป็นแบบ "ไม่ล่วงล้ํา" และจะไม่เปลี่ยนลักษณะการทํางานของค่าในการประเมิน ยกเว้นว่าตรวจสอบเรกคอร์ดของเมตาดาต้าอย่างชัดเจน

ทุกค่ามีเรกคอร์ดเมตาดาต้าเริ่มต้น แม้ว่าจะไม่ได้ระบุไว้ก็ตาม เรกคอร์ดของเมตาดาต้าเริ่มต้นจะว่างเปล่า ตัวอย่างต่อไปนี้แสดงการเข้าถึงเรกคอร์ดของเมตาดาต้าของค่าข้อความโดยใช้ Value.Metadata ฟังก์ชันไลบรารีมาตรฐาน:

Value.Metadata( "Mozart" )   // []

โดยทั่วไป เรกคอร์ดของเมตาดาต้าจะไม่ถูกรักษาไว้ เมื่อมีการใช้ค่ากับตัวดําเนินการหรือฟังก์ชันที่สร้างค่าใหม่ ตัวอย่างเช่น ถ้ามีการเชื่อมค่าข้อความสองค่าโดยใช้ตัว & ดําเนินการ เมตาดาต้าของค่าข้อความที่เป็นผลลัพธ์คือเรกคอร์ด []ว่าง นิพจน์ต่อไปนี้เทียบเท่ากัน:

"Amadeus " & ("Mozart" meta [ Rating = 5 ])  
"Amadeus " & "Mozart"

ฟังก์ชัน Value.RemoveMetadata ไลบรารีมาตรฐาน และ Value.ReplaceMetadata สามารถใช้เพื่อลบเมตาดาต้าทั้งหมดออกจากค่า และเพื่อแทนที่เมตาดาต้าของค่า (แทนที่จะเป็นการผสานเมตาดาต้าเข้ากับเมตาดาต้าที่อาจมีอยู่แล้ว)

ตัวดําเนินการเดียวที่แสดงผลลัพธ์ที่ดําเนินการเมตาดาต้าคือ ตัวดําเนินการเมตา

ตัวดําเนินการแบบเรียกใช้ซ้ําเชิงโครงสร้าง

ค่าต่างๆ สามารถเป็น วงจรได้ ตัวอย่างเช่น

let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]

M จะจัดการค่าแบบวงจร โดยการดําเนินการสร้างเรกคอร์ด รายการ และตารางที่ขี้เกียจอย่างต่อเนื่อง ความพยายามที่จะสร้างค่าแบบวงจรที่ไม่ได้รับประโยชน์จากค่าแบบโครงสร้างแทรกขี้เกียจ จะให้ผลลัพธ์เป็นข้อผิดพลาด:

[A=B, B=A] 
// [A = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
//  B = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
// ]

ตัวดําเนินการบางอย่างใน M จะถูกกําหนดโดยการเรียกใช้ซ้ําเชิงโครงสร้าง ตัวอย่างเช่น ความเท่ากันของเรกคอร์ดและรายการจะถูกกําหนดโดยความเท่ากันที่ติดกันของเขตข้อมูลเรกคอร์ดที่สอดคล้องกันและรายการหน่วยข้อมูล ตามลําดับ

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

ค่าแบบวงจรจะมีการขยายแบบอนันต์เมื่อใช้การเรียกใช้ซ้ําเชิงโครงสร้าง ตรรกะของ M ไม่มีการปรับพิเศษใดๆ สําหรับการขยายแบบจํากัดดังกล่าว - ความพยายามที่จะเปรียบเทียบค่าแบบวงจร ตัวอย่างเช่น สําหรับความเท่ากัน โดยทั่วไปจะใช้ทรัพยากรหมดและสิ้นสุดการทํางานเป็นข้อยกเว้น

ตัวดําเนินการเลือกและการเลือกส่วน

ตัวดําเนินการเลือกและการเลือกเฉพาะส่วน ช่วยให้สามารถแยกข้อมูลออกจากรายการและค่าเรกคอร์ดได้

การเข้าถึงหน่วยข้อมูล

สามารถเลือกค่าได้จากรายการหรือตารางโดยยึดตามตําแหน่งศูนย์ภายในรายการหรือตารางโดยใช้ item-access-expression

item-access-expression:
      item-selection
      optional-item-selection
item-selection:
      primary-expression{item-selector}
optional-item-selection:
      primary-expression{item-selector} ?
item-selector:
      นิพจน์

item-access-expressionx{y} จะแสดงผลลัพธ์ดังนี้:

  • สําหรับรายการ x และตัวเลข yหน่วยข้อมูลของรายการ x ที่ตําแหน่งy หน่วยข้อมูลแรกของรายการจะถือว่ามีดัชนีลําดับของศูนย์ หากตําแหน่งที่ร้องขอไม่มีอยู่ในรายการ แสดงว่ามีข้อผิดพลาดเกิดขึ้น

  • สําหรับตาราง x และตัวเลข yแถวของตาราง x ที่ตําแหน่งy แถวแรกของตารางจะถือว่ามีดัชนีเลขแสดงอันดับของศูนย์ หากตําแหน่งที่ร้องขอไม่มีอยู่ในตาราง แสดงว่ามีข้อผิดพลาดเกิดขึ้น

  • สําหรับตาราง x และเรกคอร์ด yแถวของตาราง x ที่ตรงกับค่าเขตข้อมูลของเรกคอร์ด y สําหรับเขตข้อมูลที่มีชื่อเขตข้อมูลที่ตรงกับชื่อตาราง-คอลัมน์ที่สอดคล้องกัน ถ้าไม่มีแถวที่ตรงกันที่ไม่ซ้ํากันในตาราง แสดงว่ามีข้อผิดพลาดเกิดขึ้น

ตัวอย่างเช่น

{"a","b","c"}{0}                        // "a" 
{1, [A=2], 3}{1}                        // [A=2] 
{true, false}{2}                        // error 
#table({"A","B"},{{0,1},{2,1}}){0}      // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}  // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}  // error 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}  // error

นอกจากนี้ item-access-expression ยังสนับสนุนฟอร์ม x{y}?ซึ่งแสดงผลลัพธ์nullเมื่อตําแหน่ง (หรือการจับคู่) y ไม่มีอยู่ในรายการหรือตารางx หากมีการจับคู่หลายรายการสําหรับ yแสดงว่าข้อผิดพลาดยังคงเกิดขึ้น

ตัวอย่างเช่น

{"a","b","c"}{0}?                       // "a" 
{1, [A=2], 3}{1}?                       // [A=2] 
{true, false}{2}?                       // null 
#table({"A","B"},{{0,1},{2,1}}){0}?     // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error

การเข้าถึงหน่วยข้อมูลจะไม่บังคับการประเมินหน่วยข้อมูลตารางหรือรายการนอกเหนือจากรายการที่ถูกเข้าถึง ตัวอย่างเช่น

{ error "a", 1, error "c"}{1}  // 1 
{ error "a", error "b"}{1}     // error "b"

รายการต่อไปนี้จะถูกระงับไว้ เมื่อมีการประเมินตัวดําเนินการ x{y} เข้าถึงหน่วยข้อมูล:

  • จะมีข้อผิดพลาดเกิดขึ้นในระหว่างการประเมินนิพจน์ x หรือ y จะถูกเผยแพร่

  • นิพจน์ x สร้างค่าตารางหรือรายการ

  • นิพจน์ y จะสร้างค่าตัวเลข หรือหาก x สร้างค่าตาราง ค่าเรกคอร์ด

  • หาก y สร้างค่าตัวเลข และค่าของ y เป็นค่าลบ แสดงว่ามีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

  • หาก y สร้างค่าตัวเลขและค่าของ y มากกว่าหรือเท่ากับจํานวนของ xแสดงว่ามีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น เว้นแต่ว่าจะมีการใช้ฟอร์ม x{y}? ตัวดําเนินการทางเลือก ในกรณีที่มีการแสดงค่าผลลัพธ์จากค่า null ดังกล่าว

  • หาก x สร้างค่าตารางและ y สร้างค่าเรกคอร์ดและไม่มีรายการที่ตรงกันสําหรับ y ใน xแสดงว่ามีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น เว้นแต่ว่าจะมีการใช้ฟอร์ม x{y}? ตัวดําเนินการทางเลือก ในกรณีที่มีการแสดงค่าผลลัพธ์จากค่า null ดังกล่าว

  • หาก x สร้างค่าตารางและ y สร้างค่าเรกคอร์ด และมีการตรงกันหลายรายการสําหรับ y ใน xแสดงว่ามีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

ไม่มีหน่วยข้อมูลใน x นอกเหนือจากหน่วยข้อมูลที่ตําแหน่ง y จะถูกประเมินในระหว่างกระบวนการเลือกหน่วยข้อมูล (สําหรับการสตรีมรายการหรือตาราง หน่วยข้อมูลหรือแถวที่นําหน้ารายการดังกล่าวที่ตําแหน่ง y จะถูกข้าม ซึ่งอาจทําให้เกิดการประเมินผล ทั้งนี้ขึ้นอยู่กับแหล่งข้อมูลของรายการหรือตาราง)

การเข้าถึงเขตข้อมูล

field-access-expression ถูกใช้เพื่อเลือกค่าจากเรกคอร์ดหรือไปยังโครงการเรกคอร์ดหรือตารางไปยังรายการที่มีเขตข้อมูลหรือคอลัมน์น้อยกว่า ตามลําดับ

field-access-expression:
      field-selection
      implicit-target-field-selection
      ฉาย ภาพ
      implicit-target-projection
field-selection:
      primary-expression field-selector
ตัวเลือกเขตข้อมูล:
      required-field-selector
      optional-field-selector
required-field-selector:
      [field-name]
optional-field-selector:
      [field-name] ?
field-name:
      generalized-identifier
      quoted-identifier
implicit-target-field-selection:
      field-selector
ฉาย ภาพ:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:
      [required-selector-list]
optional-projection:
      [required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list,required-field-selector
implicit-target-projection:
      required-projection
      optional-projection

รูปแบบที่ง่ายที่สุดของการเข้าถึงเขตข้อมูลคือ การเลือกเขตข้อมูลที่จําเป็น ซึ่งใช้ตัวดําเนินการ x[y] เพื่อค้นหาเขตข้อมูลในเรกคอร์ดตามชื่อเขตข้อมูล หากเขตข้อมูล y ไม่มีอยู่ใน xแสดงว่ามีข้อผิดพลาดเกิดขึ้น ฟอร์ม x[y]? จะถูกใช้เพื่อดําเนินการ เลือกเขตข้อมูลทางเลือก และแสดง null ผลลัพธ์ หากไม่มีเขตข้อมูลที่ร้องขอในเรกคอร์ด

ตัวอย่างเช่น

[A=1,B=2][B]       // 2 
[A=1,B=2][C]       // error 
[A=1,B=2][C]?      // null

การเข้าถึงเขตข้อมูลหลายรายการแบบสะสมได้รับการสนับสนุนโดยตัวดําเนินการสําหรับ การเลือกเฉพาะส่วนของ เรกคอร์ดที่จําเป็นและ การเลือกเฉพาะส่วนของเรกคอร์ดทางเลือก ตัวดําเนินการ x[[y1],[y2],...] จะเลือกเฉพาะโครงการเรกคอร์ดเป็นเรกคอร์ดใหม่ที่มีเขตข้อมูลน้อยลง (เลือกโดย y1, , y2...) หากเขตข้อมูลที่เลือกไม่มีอยู่ แสดงว่ามีข้อผิดพลาดเกิดขึ้น ตัวดําเนินการ x[[y1],[y2],...] จะเลือกเฉพาะส่วนของเรกคอร์ดเป็นเรกคอร์ดใหม่ที่มีเขตข้อมูลที่เลือกโดย y1, , y2...; หากเขตข้อมูลขาดหายไป null จะถูกใช้แทน ตัวอย่างเช่น

[A=1,B=2][[B]]           // [B=2] 
[A=1,B=2][[C]]           // error 
[A=1,B=2][[B],[C]]?      // [B=2,C=null]

รูปแบบ [y] และ [y]? ได้รับการสนับสนุนเป็นการอ้างอิงแบบย่อสําหรับตัวระบุ _ (ขีดล่าง) นิพจน์สองรายการต่อไปนี้เทียบเท่ากัน:

[A]                 
_[A]

ตัวอย่างต่อไปนี้แสดงตัวอย่างของการเข้าถึงเขตข้อมูลในรูปแบบย่อ:

let _ = [A=1,B=2] in [A] //1

นอกจากนี้ รูปแบบ [[y1],[y2],...] และ [[y1],[y2],...]? ยังได้รับการสนับสนุนในรูปแบบย่อ และนิพจน์สองรายการต่อไปนี้จะมีค่าเทียบเท่ากันด้วย:

[[A],[B]]                 
_[[A],[B]]

ฟอร์มแบบย่อมีประโยชน์อย่างยิ่งเมื่อใช้งานร่วมกับ each แบบย่อ วิธีแนะนําฟังก์ชันของพารามิเตอร์เดี่ยวที่ _ ชื่อ (สําหรับรายละเอียด โปรดดู การประกาศแบบย่อ เมื่อรวมกัน รูปแบบย่อสองแบบจะทําให้นิพจน์ฟังก์ชันในลําดับสูงกว่าทั่วไปง่ายขึ้น:

List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b]) 
// {[a=1, b=1]}

นิพจน์ข้างต้นเทียบเท่ากับรายการต่อไปนี้ที่ดูกํากวมมากกว่า:

List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b]) 
// {[a=1, b=1]}

การเข้าถึงเขตข้อมูลไม่ได้บังคับการประเมินเขตข้อมูลนอกเหนือจากรายการที่ถูกเข้าถึง ตัวอย่างเช่น

[A=error "a", B=1, C=error "c"][B]  // 1 
[A=error "a", B=error "b"][B]       // error "b"

รายการต่อไปนี้จะถูกระงับไว้ เมื่อมีการประเมินตัวดําเนินการ x[y]เข้าถึงเขตข้อมูล , x[y]?, x[[y]]หรือ x[[y]]? :

  • จะมีข้อผิดพลาดเกิดขึ้นในระหว่างการประเมินนิพจน์ x ถูกเผยแพร่

  • มีข้อผิดพลาดเกิดขึ้นขณะประเมินเขตข้อมูล y เชื่อมโยงกับเขตข้อมูล yอย่างถาวรจากนั้นเผยแพร่ การเข้าถึงเขตข้อมูล y ใดๆ ในอนาคตจะทําให้เกิดข้อผิดพลาดที่เหมือนกัน

  • นิพจน์ x สร้างค่าตารางหรือเรกคอร์ด หรือมีข้อผิดพลาดเกิดขึ้น

  • หากตัวระบุyตั้งชื่อเขตข้อมูลที่ไม่มีอยู่ใน xข้อผิดพลาดที่มีรหัส"Expression.Error"เหตุผล จะเกิดขึ้น เว้นแต่ว่าจะมีการใช้ฟอร์ม...?ตัวดําเนินการทางเลือก ในกรณีที่แสดงค่าnull

ไม่มีเขตข้อมูลของ x อื่นใดนอกเหนือจากเขตข้อมูลที่ถูกตั้งชื่อโดย y จะถูกประเมินในระหว่างกระบวนการเข้าถึงเขตข้อมูล

ตัวดําเนินการเมตาดาต้า

เรกคอร์ดของเมตาดาต้าสําหรับค่าถูกแก้ไขโดยใช้ตัว ดําเนินการ เมตาดาต้า (x meta y)

metadata-expression:
      unary-expression
      unary-expressionmetaunary-expression

ตัวอย่างต่อไปนี้สร้างค่าข้อความที่มีเรกคอร์ดเมตาดาต้าโดยใช้ตัว meta ดําเนินการ แล้วเข้าถึงเรกคอร์ดเมตาดาต้าของค่าที่เป็นผลลัพธ์โดยใช้ Value.Metadata:

Value.Metadata( "Mozart" meta [ Rating = 5 ] ) 
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating] 
// 5

รายการต่อไปนี้จะถูกระงับไว้ ขณะปรับใช้เมตาดาต้าที่รวมตัวดําเนินการ x meta y:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • นิพจน์ y ต้องเป็นเรกคอร์ด หรือมีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

  • เรกคอร์ดเมตาดาต้าที่เป็นผลลัพธ์คือxเรกคอร์ดเมตาดาต้าของ ที่ผสานกับy (สําหรับตรรกะของการผสานเรกคอร์ด โปรดดู การผสานเรกคอร์ด)

  • ค่าที่เป็นผลลัพธ์คือค่าจาก x นิพจน์ โดยไม่มีเมตาดาต้า ซึ่งมีเรกคอร์ดเมตาดาต้าที่คํานวณใหม่แนบมา

ฟังก์ชัน Value.RemoveMetadata ไลบรารีมาตรฐาน และ Value.ReplaceMetadata สามารถใช้เพื่อลบเมตาดาต้าทั้งหมดออกจากค่า และเพื่อแทนที่เมตาดาต้าของค่า (แทนที่จะเป็นการผสานเมตาดาต้าเข้ากับเมตาดาต้าที่อาจมีอยู่แล้ว) นิพจน์ต่อไปนี้เทียบเท่ากัน:

x meta y  
Value.ReplaceMetadata(x, Value.Metadata(x) & y) 
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)

ตัวดําเนินการความเท่ากัน

ตัว ดําเนินการ= ความเท่ากัน จะใช้เพื่อกําหนดว่าค่าสองค่าเท่ากันหรือไม่ ตัว ดําเนินการ<> ความไม่เท่ากันจะใช้เพื่อกําหนดว่าค่าสองค่าไม่เท่ากันหรือไม่

equality-expression:
      relational-expression
      relational-expression=equality-expression
      relational-expression<>equality-expression

ตัวอย่างเช่น

1 = 1            // true 
1 = 2            // false 
1 <> 1           // false 
1 <> 2           // true 
null = true      // false 
null = null      // true

เมตาดาต้าไม่ใช่ส่วนหนึ่งของการเปรียบเทียบความเท่ากันหรือความไม่เท่ากัน ตัวอย่างเช่น

(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true 
(1 meta [ a = 1 ]) = 1                  // true

รายการต่อไปนี้จะถูกระงับไว้ ขณะปรับใช้ตัวดําเนินการ x = y ความเท่ากัน และ x <> y:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • ตัว = ดําเนินการ มีผลลัพธ์เป็น true หากค่าเท่ากัน มิฉะนั้น false จะเป็น

  • ตัว <> ดําเนินการ มีผลลัพธ์เป็น false หากค่าเท่ากัน มิฉะนั้น true จะเป็น

  • เรกคอร์ดของเมตาดาต้าจะไม่รวมอยู่ในการเปรียบเทียบ

  • หากค่าที่สร้างขึ้นโดยการประเมิน x นิพจน์ และ y ไม่ใช่ค่าชนิดเดียวกัน ค่าดังกล่าวจะไม่เท่ากัน

  • หากค่าที่สร้างขึ้นโดยการประเมิน x นิพจน์ และ y เป็นค่าชนิดเดียวกัน จะมีกฎเฉพาะสําหรับการพิจารณาว่าค่าดังกล่าวเท่ากันหรือไม่ ดังที่กําหนดไว้ด้านล่างนี้

  • รายการต่อไปนี้จะเป็นจริงเสมอ:

    (x = y) = not (x <> y)

ตัวดําเนินการความเท่ากันจะถูกกําหนดสําหรับชนิดต่อไปนี้:

  • ค่า null จะเท่ากับตัวเองเท่านั้น
    null = null    // true 
    null = true    // false 
    null = false   // false
  • ค่า true ตรรกะ และ false จะเท่ากับตัวเองเท่านั้น ตัวอย่างเช่น
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • ตัวเลขจะถูกเปรียบเทียบด้วยความแม่นยําที่ระบุ:

    • หากตัวเลขตัวหนึ่งเป็น #nanตัวเลขจะไม่เท่ากัน

    • เมื่อตัวเลข #nanไม่ใช่ ตัวเลขจะถูกเปรียบเทียบกันโดยใช้การเปรียบเทียบค่าตัวเลขแบบบิต

    • #nan เป็นค่าเดียวที่ไม่เท่ากับตัวเอง

      ตัวอย่างเช่น

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true

  • ระยะเวลาสองช่วงจะเท่ากัน หากแสดงตัวเลขเดียวกันเป็นเครื่องหมาย 100 นาโนวินาที

  • เวลาสองรายการจะเท่ากัน หากแมกนิจูดของส่วน (ชั่วโมง, นาที, วินาที) เท่ากัน

  • วันที่สองรายการจะเท่ากัน หากแมกนิจูดของส่วน (ปี, เดือน, วัน) เท่ากัน

  • วันที่เวลาสองรายการจะเท่ากัน หากแมกนิจูดของส่วน (ปี, เดือน, วัน, ชั่วโมง, นาที, วินาที) เท่ากัน

  • เขตวันที่เวลาสองรายการจะเท่ากัน หากวันที่เวลา UTC ที่สอดคล้องกันเท่ากัน เพื่อให้มาถึงในวันที่เวลา UTC ที่สอดคล้องกัน ค่าออฟเซ็ตของชั่วโมง/นาทีจะถูกหักออกจากคอมโพเนนต์วันที่เวลาของเขตวันที่เวลา

  • ค่าข้อความสองค่าจะเท่ากัน หากใช้การเปรียบเทียบที่ไม่ไวต่อวัฒนธรรม แต่ตรงตามตัวพิมพ์ใหญ่-เล็กและลําดับ ซึ่งค่ามีความยาวเท่ากันและมีอักขระในตําแหน่งที่สอดคล้องกันเท่ากัน

  • ค่ารายการสองค่าจะเท่ากัน หากข้อมูลต่อไปนี้ทั้งหมดเป็นจริง:

    • รายการทั้งสองรายการจะมีหน่วยข้อมูลจํานวนเท่ากัน

    • ค่าของหน่วยข้อมูลที่สอดคล้องกันทางตําแหน่งในรายการจะเท่ากัน ซึ่งหมายความว่า ไม่เพียงแต่รายการที่จําเป็นต้องมีหน่วยข้อมูลเท่ากันเท่านั้น แต่หน่วยข้อมูลก็ต้องอยู่ในลําดับเดียวกันด้วย

      ตัวอย่างเช่น

        {1, 2} = {1, 2}     // true 
  {2, 1} = {1, 2}     // false 
  {1, 2, 3} = {1, 2}  // false

  • เรกคอร์ดสองรายการจะเท่ากัน หากข้อมูลต่อไปนี้ทั้งหมดเป็นจริง:

    • จํานวนเขตข้อมูลเท่ากัน

    • นอกจากนี้ ยังมีชื่อเขตข้อมูลแต่ละชื่อของเรกคอร์ดหนึ่งปรากฏอยู่ในเรกคอร์ดอีกรายการด้วย

    • ค่าของแต่ละเขตข้อมูลของเรกคอร์ดหนึ่งจะเท่ากับเขตข้อมูลที่มีชื่อเหมือนกันในอีกเรกคอร์ดหนึ่ง

      ตัวอย่างเช่น

        [ A = 1, B = 2 ] = [ A = 1, B = 2 ]        // true 
  [ B = 2, A = 1 ] = [ A = 1, B = 2 ]        // true 
  [ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false 
  [ A = 1 ] = [ A = 1, B = 2 ]               // false

  • ตารางสองรายการจะเท่ากัน หากข้อมูลต่อไปนี้ทั้งหมดเป็นจริง:

    • จํานวนคอลัมน์เท่ากัน

    • นอกจากนี้ ยังมีชื่อคอลัมน์แต่ละชื่อในตารางหนึ่งปรากฏอยู่ในตารางอีกรายการด้วย

    • จํานวนแถวเท่ากัน

    • แต่ละแถวจะมีค่าที่เท่ากันในเซลล์ที่สอดคล้องกัน

      ตัวอย่างเช่น

        #table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true 
  #table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false 
  #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true

  • ค่าฟังก์ชันจะเท่ากันกับตัวเอง แต่อาจเท่าหรือไม่เท่ากับค่าฟังก์ชันอื่นก็ได้ หากค่าฟังก์ชันสองค่าถือว่าเท่ากัน ค่าจะมีลักษณะการทํางานที่เท่ากันเมื่อเรียกใช้

    ค่าฟังก์ชันที่กําหนดสองค่าจะมีความสัมพันธ์แบบเท่ากันที่เหมือนกันเสมอ

  • ค่าชนิดจะเท่ากันกับตัวเอง แต่อาจเท่าหรือไม่เท่ากับค่าชนิดอื่นก็ได้ หากค่าชนิดสองค่าถือว่าเท่ากัน ค่าจะมีลักษณะการทํางานที่เท่ากันเมื่อถูกสอบถามเกี่ยวกับความสอดคล้อง

    ค่าชนิดที่กําหนดสองค่าจะมีความสัมพันธ์แบบเท่ากันที่เหมือนกันเสมอ

ตัวดําเนินการเชิงสัมพันธ์

<ตัวดําเนินการ , >, <=และ >= เรียกว่า ตัวดําเนินการเชิงสัมพันธ์

relational-expression:
      additive-expression
      additive-expression<relational-expression
      additive-expression>relational-expression
      additive-expression<= _relational-expression
      additive-expression >=relational-expression

ตัวดําเนินการเหล่านี้จะใช้เพื่อกําหนดความสัมพันธ์เชิงลําดับที่สัมพันธ์กันระหว่างสองค่าดังที่แสดงในตารางต่อไปนี้:

การดำเนินงาน ผลลัพธ์
x < y true หาก x น้อยกว่า yจะเป็น false อย่างอื่น
x > y true หาก x มากกว่า yจะเป็น false อย่างอื่น
x <= y true หาก x น้อยกว่าหรือเท่ากับ yจะเป็น false อย่างอื่น
x >= y true หาก x มากกว่าหรือเท่ากับ yจะเป็น false อย่างอื่น

ตัวอย่างเช่น

0 <= 1            // true 
null < 1          // null 
null <= null      // null 
"ab" < "abc"      // true 
#nan >= #nan      // false  
#nan <= #nan      // false

รายการต่อไปนี้จะถูกระงับไว้ ขณะประเมินนิพจน์ที่มีตัวดําเนินการเชิงสัมพันธ์:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะประเมิน x นิพจน์ตัวถูกดําเนินการ หรือ y จะถูกเผยแพร่

  • ค่าที่เกิดจากการประเมินนิพจน์ทั้ง x และ y ต้องเป็นค่าไบนารี วันที่ วันที่เวลา เขตวันที่เวลา ระยะเวลา ตรรกะ ตัวเลข ค่า null ข้อความ หรือเวลา มิฉะนั้น ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล จะปรากฏขึ้น

  • ตัวถูกดําเนินการทั้งสองต้องเป็นค่า ชนิดเดียวกัน หรือnull มิฉะนั้น ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล จะปรากฏขึ้น

  • หากตัวถูกดําเนินการตัวใดตัวหนึ่งหรือทั้งสองตัวเป็น nullผลลัพธ์จะเป็น null ค่า

  • ไบนารีสองรายการจะถูกเปรียบเทียบไบต์

  • วันที่สองรายการจะถูกเปรียบเทียบส่วนปีและหากเท่ากัน จะเป็นส่วนเดือน และหากเท่ากัน จะเป็นส่วนวัน

  • วันที่เวลาสองรายการจะถูกเปรียบเทียบส่วนปี และหากเท่ากัน จะเป็นส่วนเดือน และหากเท่ากัน จะเป็นส่วนวันและ หากเท่ากัน จะเป็นส่วนชั่วโมง และหากเท่ากัน จะเป็นส่วนนาที และหากเท่ากัน จะเป็นส่วนวินาที

  • เขตวันที่เวลาสองรายการจะถูกเปรียบเทียบกัน โดยการปรับเป็นค่ามาตรฐาน UTC โดยการลบค่าออฟเซ็ตชั่วโมง/นาที จากนั้นทําการเปรียบเทียบส่วนประกอบวันที่เวลา

  • ระยะเวลาสองช่วงจะถูกเปรียบเทียบตามจํานวนทั้งหมดของเครื่องหมาย 100 นาโนวินาทีที่แสดง

  • ตรรกะสองรายการจะถูกเปรียบเทียบซึ่งtrueถือว่ามีค่ามากกว่าfalse

  • ตัวเลขสองตัว x และ y จะถูกเปรียบเทียบกันตามกฎของมาตรฐาน IEEE 754:

    • หากตัวถูกดําเนินการตัวใดตัวหนึ่งเป็น #nanผลลัพธ์จะเป็น false สําหรับตัวดําเนินการเชิงสัมพันธ์ทั้งหมด

    • เมื่อไม่มีตัวถูกดําเนินการใดเลยเป็น #nanตัวดําเนินการจะเปรียบเทียบค่าต่างๆ ของตัวถูกดําเนินการที่จุดลอยทั้งสองตัวตามการจัดลําดับโดยที่ค่า -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ ต่ําสุดและค่าสูงสุดเป็นค่าจํากัดบวกที่น้อยที่สุดและมากที่สุดที่สามารถแสดงได้ ชื่อ M สําหรับ -∞ และ +∞ คือ -#infinity และ#infinity

      ผลกระทบที่น่าสังเกตของการเรียงลําดับนี้คือ:

      • ค่าศูนย์ลบและบวกถือว่าเท่ากัน

      • -#infinityค่า ถือว่าน้อยกว่าค่าตัวเลขอื่นๆ ทั้งหมด แต่เท่ากับ อีกตัวหนึ่ง-#infinity

      • #infinityค่า ถือว่ามากกว่าค่าตัวเลขอื่นๆ ทั้งหมด แต่เท่ากับ อีกตัวหนึ่ง#infinity

  • สองข้อความจะถูกเปรียบเทียบโดยใช้การเปรียบเทียบแบบอักขระต่อตัวอักษร และตรงตามตัวพิมพ์ใหญ่-เล็ก แต่ไม่ไวต่อวัฒนธรรม

  • เวลาสองรายการจะถูกเปรียบเทียบส่วนชั่วโมงและหากเท่ากัน จะเป็นส่วนนาที และหากเท่ากัน จะเป็นส่วนวินาที

ตัวดําเนินการเชิงตรรกะแบบมีเงื่อนไข

ตัว and ดําเนินการ และ or เรียกว่า ตัวดําเนินการเชิงตรรกะแบบมีเงื่อนไข

logical-or-expression:
      logical-and-expression
logical-and-expressionorlogical-or-expression
logical-and-expression:
      is-expression
      is-expressionandlogical-and-expression

ตัวorดําเนินการ จะแสดงtrueเมื่อตัวถูกดําเนินการอย่างน้อยหนึ่งตัวเป็นtrue ตัวถูกดําเนินการด้านขวาจะถูกประเมิน ก็ต่อเมื่อตัวถูกดําเนินการด้านซ้ายไม่ใช่ trueเท่านั้น

ตัวandดําเนินการ จะแสดงfalseเมื่อตัวถูกดําเนินการอย่างน้อยหนึ่งตัวเป็นfalse ตัวถูกดําเนินการด้านขวาจะถูกประเมิน ก็ต่อเมื่อตัวถูกดําเนินการด้านซ้ายไม่ใช่ falseเท่านั้น

ตารางจริงสําหรับ or ตัวดําเนินการ และ and จะแสดงด้านล่าง พร้อมกับผลลัพธ์ของการประเมินนิพจน์ตัวถูกดําเนินการด้านซ้ายบนแกนแนวตั้งและผลลัพธ์ของการประเมินนิพจน์ตัวถูกดําเนินการด้านขวาบนแกนนอน

and true false null error
true true false null error
false false false false false
null null false null error
error error error error error
or true false null error
or true false null error
true true true true true
false true false null error
null true null null error
error error error error error

รายการต่อไปนี้จะถูกระงับไว้ ขณะประเมินนิพจน์ที่มีตัวดําเนินการเชิงตรรกะแบบมีเงื่อนไข:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • ตัวดําเนินการเชิงตรรกะแบบมีเงื่อนไขจะถูกกําหนดเหนือชนิด logical และnull หากค่าตัวถูกดําเนินการไม่ใช่ค่าชนิดดังกล่าว ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล จะเกิดขึ้น

  • ผลลัพธ์คือค่าตรรกะ

  • ในนิพจน์ x หรือ จะมีการประเมินนิพจน์ y ถ้า และในกรณีที่ x ไม่ประเมินเป็น trueyเท่านั้น

  • ในนิพจน์ x และ จะมีการประเมินนิพจน์ y ถ้า และในกรณีที่ x ไม่ประเมินเป็น falseyเท่านั้น

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

d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false

ตัวดําเนินการทางคณิตศาสตร์

+ตัวดําเนินการ , -และ /* เป็นตัวดําเนินการทางคณิตศาสตร์

additive-expression:
      multiplicative-expression
      additive-expression+multiplicative-expression
      additive-expression-multiplicative-expression
multiplicative-expression:
      metadata- expression
      multiplicative-expression*metadata-expression
      multiplicative-expression/metadata-expression

ค่าความแม่นยำ

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

ค่าความแม่นยำ ความหมาย
Precision.Decimal การแสดงค่าทศนิยม 128 บิตที่มีช่วง±1.0 x 10-28 ถึง ±7.9 x 1028 และมีหลักที่สําคัญ 28-29 หลัก
Precision.Double การแสดงทางวิทยาศาสตร์โดยใช้ mantissa และเอ็กซ์โพเนนต์ สอดคล้องกับมาตรฐานทางคณิตศาสตร์ IEEE 754 ค่าความแม่นยําคู่ไบนารี 64 บิต IEEE 754-2008

ตัวดําเนินการทางคณิตศาสตร์จะดําเนินการโดยเลือกค่าความแม่นยํา ที่แปลงตัวถูกดําเนินการทั้งสองตัวเป็นค่าความแม่นยําดังกล่าว (หากจําเป็น) จากนั้นจะดําเนินการปฏิบัติการตามจริง และในที่สุดก็ส่งกลับตัวเลขในค่าความแม่นยําที่เลือก

ตัวดําเนินการทางคณิตศาสตร์ที่มีอยู่แล้วภายใน (+, , -, */) จะใช้ค่าความแม่นยําสองเท่า ฟังก์ชันไลบรารีมาตรฐาน (Value.Add, , Value.Subtract, Value.DivideValue.Multiply) สามารถใช้เพื่อร้องขอการดําเนินการเหล่านี้โดยใช้แบบจําลองความแม่นยําเฉพาะ

  • ไม่สามารถใช้โอเวอร์โฟลว์ตัวเลขได้: #infinity หรือ -#infinity แสดงค่าแมกนิจูดที่มากเกินไปที่จะแสดง

  • ไม่สามารถใช้อันเดอร์โฟลว์ตัวเลขได้: 0 และ -0 แสดงค่าแมกนิจูดที่น้อยเกินไปที่จะแสดง

  • ค่า #nan พิเศษของ IEEE 754 (NaN —ไม่ใช่ตัวเลข) จะใช้สําหรับครอบคลุมกรณีที่ไม่ถูกต้องทางคณิตศาสตร์ เช่น การหารศูนย์ด้วยศูนย์

  • การแปลงข้อมูลจากค่าความแม่นยําจุดทศนิยมเป็นคู่ จะดําเนินการโดยการปัดเศษตัวเลขทศนิยมให้เป็นค่าคู่ที่เทียบเท่ากันซึ่งใกล้เคียงกันมากที่สุด

  • การแปลงข้อมูลจากค่าความแม่นยําคู่เป็นจุดทศนิยมจะดําเนินการโดยการปัดเศษตัวเลขคู่ให้เป็นค่าทศนิยมที่เทียบเท่ากันซึ่งใกล้เคียงกันมากที่สุด และหากจําเป็น ให้เกิน#infinityค่า หรือ-#infinity

ตัวดําเนินการเพิ่มเติม

การตีความของตัวดําเนินการเพิ่มเติม (x + y) จะขึ้นอยู่กับชนิดของค่าของนิพจน์ที่ถูกประเมิน x และ y ดังนี้:

X y ผลลัพธ์ ล่าม
type number type number type number ผลรวมตัวเลข
type number null null
null type number null
type duration type duration type duration ผลรวมตัวเลขของแมกนิจูด
type duration null null
null type duration null
typeDatetime type duration typeDatetime ค่าชดเชยวันที่เวลาตามระยะเวลา
type duration typeDatetime typeDatetime
typeDatetime null null
null typeDatetime null

ในตาราง typeวันที่เวลา จะtype dateย่อมาจาก , type datetimetype datetimezone, หรือtype time เมื่อเพิ่มระยะเวลาและค่าวันที่เวลาบางชนิด ค่าที่เป็นผลลัพธ์จะเป็นชนิดเดียวกัน

สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้

จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่

ผลรวมตัวเลข

ผลรวมของตัวเลขสองตัว จะถูกคํานวณโดยใช้ตัว ดําเนินการเพิ่มเติม ทําให้เกิดตัวเลข

ตัวอย่างเช่น

1 + 1             // 2 
#nan + #infinity  // #nan

ตัวดําเนินการ + เพิ่มเติม เหนือตัวเลข จะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Add ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณผลรวมของตัวเลข:

  • ผลรวมในค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิตศาสตร์ IEEE 754 ค่าเลขคณิตไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ xy เป็นค่าแบบจํากัดที่ไม่ใช่ศูนย์ และ z เป็นผลลัพธ์ของx + y หาก x และ y มีแมกนิจูดเดียวกันแต่มีเครื่องหมายตรงกันข้ามกัน z จะเป็นค่าศูนย์บวก หาก x + y มากเกินไปที่จะแสดงในชนิด z ปลายทาง จะเป็นค่าอนันต์ที่มีเครื่องหมาย x + yเดียวกันกับ

    + y +0 0- +∞ -∞ NaN
    X z X X +∞ -∞ NaN
    +0 y +0 +0 +∞ -∞ NaN
    -0 y +0 0- +∞ -∞ NaN
    +∞ +∞ +∞ +∞ +∞ NaN NaN
    -∞ -∞ -∞ -∞ NaN -∞ NaN
    น่าน NaN NaN NaN NaN NaN NaN

  • ผลรวมในค่าความแม่นยําจุดทศนิยมจะถูกคํานวณโดยไม่สูญเสียค่าความแม่นยํา ขนาดของผลลัพธ์มีขนาดใหญ่กว่าของตัวถูกดําเนินการทั้งสองตัว

ผลรวมของระยะเวลา

ผลรวมของระยะเวลาสองช่วงคือระยะเวลาที่แสดงผลรวมของตัวเลขของเครื่องหมาย 100 นาโนวินาทีที่แสดงด้วยระยะเวลาดังกล่าว ตัวอย่างเช่น

#duration(2,1,0,15.1) + #duration(0,1,30,45.3) 
// #duration(2, 2, 31, 0.4)

ค่าชดเชยวันที่เวลาตามระยะเวลา

อาจเพิ่ม วันที่เวลาx และระยะเวลา y โดยใช้ x + y เพื่อคํานวณวันที่เวลาใหม่ซึ่งมีระยะห่างจาก x บนเส้นเวลาแบบเส้นตรงเท่ากับแมกนิจูดของy ใน ที่นี้ วันที่เวลา จะ Dateย่อจาก , DateTime, DateTimeZoneหรือ Time และผลลัพธ์ที่ไม่ใช่ null จะเป็นค่าที่มีชนิดเดียวกัน ค่าออฟเซ็ตวันที่เวลาตามระยะเวลา อาจคํานวณได้ดังนี้:

  • หากจํานวนวันของวันที่เวลานับตั้งแต่ระบุค่ากรณี ให้สร้างวันที่เวลาใหม่ที่มีองค์ประกอบข้อมูลต่อไปนี้:

    • คํานวณจํานวนวันใหม่นับตั้งแต่ยุคที่เทียบเท่ากับการหารแมกนิจูดของ y ด้วยจํานวนสัญญาณนาฬิกา 100 นาโนวินาทีในระยะเวลา 24 ชั่วโมง ที่ตัดทอนส่วนทศนิยมของผลลัพธ์ และเพิ่มค่านี้ไปยังจํานวนวันของ x นับตั้งแต่ยุค

    • คํานวณเครื่องหมายใหม่ตั้งแต่เที่ยงคืนซึ่งเทียบเท่ากับการเพิ่มแมกนิจูดของ y ไปยังเครื่องหมาย x นับตั้งแต่เวลาเที่ยงคืน มอดุโลจํานวนเครื่องหมาย 100 นาโนวินาทีในระยะเวลา 24 ชั่วโมง หาก x ไม่ได้ระบุค่าสําหรับเครื่องหมาย นับตั้งแต่เวลาเที่ยงคืน ระบบจะสันนิษฐานว่าค่าเป็น 0

    • คัดลอกค่าของ x สําหรับค่าออฟเซ็ตนาทีจาก UTC ไม่เปลี่ยนแปลง

  • หากจํานวนวันของวันที่เวลานับตั้งแต่ระบุค่ากรณี ให้สร้างวันที่เวลาใหม่ที่มีองค์ประกอบข้อมูลต่อไปนี้ที่ระบุ:

    • คํานวณเครื่องหมายใหม่ตั้งแต่เที่ยงคืนซึ่งเทียบเท่ากับการเพิ่มแมกนิจูดของ y ไปยังเครื่องหมาย x นับตั้งแต่เวลาเที่ยงคืน มอดุโลจํานวนเครื่องหมาย 100 นาโนวินาทีในระยะเวลา 24 ชั่วโมง หาก x ไม่ได้ระบุค่าสําหรับเครื่องหมาย นับตั้งแต่เวลาเที่ยงคืน ระบบจะสันนิษฐานว่าค่าเป็น 0

    • คัดลอกค่าของ x สําหรับจํานวนวัน นับตั้งแต่ตัวอย่างและค่าออฟเซ็ตนาทีจาก UTC ไม่เปลี่ยนแปลง

ตัวอย่างต่อไปนี้แสดงการคํานวณผลรวมชั่วขณะแบบสัมบูรณ์เมื่อวันที่เวลาระบุจํานวน วันตั้งแต่ยุค:

#date(2010,05,20) + #duration(0,8,0,0) 
    //#datetime( 2010, 5, 20, 8, 0, 0 ) 
    //2010-05-20T08:00:00 
 
#date(2010,01,31) + #duration(30,08,0,0) 
    //#datetime(2010, 3, 2, 8, 0, 0) 
    //2010-03-02T08:00:00 
 
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00) 
    //#datetime(2010, 5, 20, 16, 30, 0, -8, 0) 
    //2010-05-20T16:30:00-08:00 
 
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0) 
   //#datetime(2010, 10, 11, 0, 0, 0, 0, 0) 
   //2010-10-11T00:00:00+00:00

ตัวอย่างต่อไปนี้แสดงการคํานวณค่าออฟเซ็ตวันที่เวลาตามระยะเวลาสําหรับเวลาที่กําหนด:

#time(8,0,0) + #duration(30,5,0,0) 
   //#time(13, 0, 0) 
   //13:00:00

ตัวดําเนินการลบ

การตีความของตัวดําเนินการลบ (x - y) จะขึ้นอยู่กับชนิดของค่านิพจน์ x ที่ได้รับการประเมิน และ yดังต่อไปนี้:

X Y ผลลัพธ์ ล่าม
type number type number type number ความแตกต่างของตัวเลข
type number null null
null type number null
type duration type duration type duration ความแตกต่างของตัวเลขของแมกนิจูด
type duration null null
null type duration null
typeDatetime typeDatetime type duration ระยะเวลาระหว่างวันที่เวลา
typeDatetime type duration typeDatetime ค่าชดเชยวันที่เวลาตามระยะเวลาที่ลบล้าง
typeDatetime null null
null typeDatetime null

ในตาราง typeวันที่เวลา จะtype dateย่อมาจาก , type datetimetype datetimezone, หรือtype time เมื่อลบระยะเวลาออกจากค่าวันที่เวลาบางชนิด ค่าผลลัพธ์ที่ได้จะเป็นค่าชนิดเดียวกัน

สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้

จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่

ความแตกต่างของตัวเลข

ค่าความต่างระหว่างตัวเลขสองค่าจะถูกคํานวณโดยใช้ตัว ดําเนินการลบ ทําให้เกิดตัวเลข ตัวอย่างเช่น

1 - 1                // 0 
#nan - #infinity     // #nan

ตัวดําเนินการ - ลบเหนือตัวเลขจะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Subtract ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณค่าความต่างของตัวเลข:

  • ความแตกต่างของค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิตศาสตร์ IEEE 754 ค่าความแม่นยําคู่ไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ xy เป็นค่าแบบจํากัดที่ไม่ใช่ศูนย์ และ z เป็นผลลัพธ์ของx - y หาก x และ y เท่ากัน z เป็นค่าศูนย์บวก หาก x - y มากเกินไปที่จะแสดงในชนิด z ปลายทาง จะเป็นค่าอนันต์ที่มีเครื่องหมาย x - yเดียวกันกับ

    - y +0 0- +∞ -∞ NaN
    X z X X -∞ +∞ NaN
    +0 -Y +0 +0 -∞ +∞ NaN
    -0 -Y 0- +0 -∞ +∞ NaN
    +∞ +∞ +∞ +∞ NaN +∞ NaN
    -∞ -∞ -∞ -∞ -∞ NaN NaN
    น่าน NaN NaN NaN NaN NaN NaN

  • ความแตกต่างของค่าความแม่นยําจุดทศนิยมจะถูกคํานวณโดยไม่สูญเสียค่าความแม่นยํา ขนาดของผลลัพธ์มีขนาดใหญ่กว่าของตัวถูกดําเนินการทั้งสองตัว

ความแตกต่างของระยะเวลา

ความแตกต่างของระยะเวลาสองช่วง คือระยะเวลาที่แสดงค่าต่างระหว่างตัวเลขของนาวิกโยธิน 100 นาโนวินาทีที่แสดงด้วยแต่ละระยะเวลา ตัวอย่างเช่น

#duration(1,2,30,0) - #duration(0,0,0,30.45) 
// #duration(1, 2, 29, 29.55)

ค่าชดเชยวันที่เวลาตามระยะเวลาที่ลบล้าง

วันที่เวลาx และระยะเวลา y อาจหักออกโดยใช้ x - y ในการคํานวณวันที่เวลาใหม่ ในที่นี่ วันที่เวลา จะdateย่อมาจาก , datetime, datetimezoneหรือtime วันที่เวลา ที่เป็นผลลัพธ์จะมีระยะห่างจาก x บนเส้นเวลาแบบเส้นตรงที่เป็นแมกนิจูด yเท่านั้น ในทิศทางตรงกันข้ามกับเครื่องหมายy การลบระยะเวลาค่าบวกจะให้ผลลัพธเป็นเวลาย้อนกลับที่สัมพันธ์กับ xในขณะที่ลบค่าลบจะให้ผลลัพธ์ที่เป็นเวลาเดินหน้า

#date(2010,05,20) - #duration(00,08,00,00) 
   //#datetime(2010, 5, 19, 16, 0, 0) 
   //2010-05-19T16:00:00 
#date(2010,01,31) - #duration( 30,08,00,00) 
   //#datetime(2009, 12, 31, 16, 0, 0) 
   //2009-12-31T16:00:00

ระยะเวลาระหว่างวันที่เวลาสองรายการ

วันที่เวลาt สองรายการ และ u อาจหักออกโดยใช้ t - u ในการคํานวณระยะเวลาระหว่างรายการ ในที่นี่ วันที่เวลา จะdateย่อมาจาก , datetime, datetimezoneหรือtime ระยะเวลาที่เกิดจากการลบuออกจาก t ต้องให้ผลลัพธ์ t เมื่อเพิ่มเป็นu

#date(2010,01,31) - #date(2010,01,15) 
// #duration(16,00,00,00) 
// 16.00:00:00 
 
#date(2010,01,15)- #date(2010,01,31) 
// #duration(-16,00,00,00) 
// -16.00:00:00 
 
#datetime(2010,05,20,16,06,00,-08,00) - 
#datetime(2008,12,15,04,19,19,03,00) 
// #duration(521,22,46,41)
// 521.22:46:41

การลบ t - u เมื่อ u > t ให้ผลลัพธ์เป็นระยะเวลาค่าลบ:

#time(01,30,00) - #time(08,00,00) 
// #duration(0, -6, -30, 0)

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ลบวันที่เวลาสอง รายการ โดยใช้ t - u:

  • u + (t - u) = t

ตัวดําเนินการคูณ

การตีความของตัวดําเนินการคูณ (x * y) จะขึ้นอยู่กับชนิดของค่าของนิพจน์ที่ได้รับการประเมิน x และ y ดังนี้:

X Y ผลลัพธ์ ล่าม
type number type number type number ผลิตภัณฑ์ตัวเลข
type number null null
null type number null
type duration type number type duration ผลคูณของระยะเวลา
type number type duration type duration ผลคูณของระยะเวลา
type duration null null
null type duration null

สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้

จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่

ผลิตภัณฑ์ตัวเลข

ผลิตภัณฑ์ของตัวเลขสองตัว จะถูกคํานวณโดยใช้ ตัว ดําเนินการคูณ ทําให้เกิดตัวเลข ตัวอย่างเช่น

2 * 4                // 8 
6 * null             // null 
#nan * #infinity     // #nan

ตัวดําเนินการ * คูณเหนือตัวเลขจะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Multiply ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณผลิตภัณฑ์ของตัวเลข:

  • ผลิตภัณฑ์ของค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิตศาสตร์ IEEE 754 ค่าความแม่นยําคู่ไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ xy เป็นค่าจํากัดบวก zเป็นผลลัพธ์ของx * y หากผลลัพธ์มีขนาดใหญ่เกินไปสําหรับชนิด z ปลายทาง จะเป็นค่าอนันต์ หากผลลัพธ์น้อยเกินไปสําหรับชนิด z ปลายทาง จะเป็นค่าศูนย์

    * +y -Y +0 0- +∞ -∞ NaN
    +x +z -Z +0 0- +∞ -∞ NaN
    -X -Z +z 0- +0 -∞ +∞ NaN
    +0 +0 0- +0 0- NaN NaN NaN
    -0 0- +0 0- +0 NaN NaN NaN
    +∞ +∞ -∞ NaN NaN +∞ -∞ NaN
    -∞ -∞ +∞ NaN NaN -∞ +∞ NaN
    น่าน NaN NaN NaN NaN NaN NaN NaN

  • ผลิตภัณฑ์ในค่าความแม่นยําจุดทศนิยมจะถูกคํานวณโดยไม่สูญเสียค่าความแม่นยํา ขนาดของผลลัพธ์มีขนาดใหญ่กว่าของตัวถูกดําเนินการทั้งสองตัว

ผลคูณของระยะเวลา

ผลิตภัณฑ์ของระยะเวลาและตัวเลขเป็นระยะเวลาที่แสดงตัวเลขของเครื่องหมายขีด 100 นาโนวินาทีที่แสดงโดยตัวถูกดําเนินการระยะเวลาคูณด้วยตัวถูกดําเนินการของตัวเลข ตัวอย่างเช่น

#duration(2,1,0,15.1) * 2 
// #duration(4, 2, 0, 30.2)

ตัวดําเนินการหาร

การตีความของตัวดําเนินการหาร (x / y) จะขึ้นอยู่กับชนิดของค่าของนิพจน์ x ที่ประเมิน และ yดังต่อไปนี้:

X Y ผลลัพธ์ ล่าม
type number type number type number ตัวหารตัวเลข
type number null null
null type number null
type duration type number type duration เศษส่วนของระยะเวลา
type duration type duration type duration ผลหารตัวเลขของระยะเวลา
type duration null null
null type duration null

สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้

จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่

ตัวหารตัวเลข

ผลหารของตัวเลขสองตัว จะถูกคํานวณโดยใช้ตัว ดําเนินการหาร ทําให้เกิดตัวเลข ตัวอย่างเช่น

8 / 2               // 4 
8 / 0               // #infinity 
0 / 0               // #nan 
0 / null            // null 
#nan / #infinity    // #nan

ตัวดําเนินการ / หาร เหนือตัวเลข จะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Divide ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณผลหารของตัวเลข:

  • ผลหารในค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิติต IEEE 754 ค่าความแม่นยําคู่ไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ xy เป็นค่าจํากัดบวก zเป็นผลลัพธ์ของx / y หากผลลัพธ์มีขนาดใหญ่เกินไปสําหรับชนิด z ปลายทาง จะเป็นค่าอนันต์ หากผลลัพธ์น้อยเกินไปสําหรับชนิด z ปลายทาง จะเป็นค่าศูนย์

    / +y -Y +0 0- +∞ -∞ NaN
    +x +z -Z +∞ -∞ +0 0- NaN
    -X -Z +z -∞ +∞ 0- +0 NaN
    +0 +0 0- NaN NaN +0 0- NaN
    -0 0- +0 NaN NaN 0- +0 NaN
    +∞ +∞ -∞ +∞ -∞ NaN NaN NaN
    -∞ -∞ +∞ -∞ +∞ NaN NaN NaN
    น่าน NaN NaN NaN NaN NaN NaN NaN

  • ผลรวมในค่าความแม่นยําจุดทศนิยมจะถูกคํานวณโดยไม่สูญเสียค่าความแม่นยํา ขนาดของผลลัพธ์มีขนาดใหญ่กว่าของตัวถูกดําเนินการทั้งสองตัว

ผลหารของระยะเวลา

ผลหารของระยะเวลาสองช่วง คือตัวเลขที่แทนผลหารของตัวเลขของเครื่องหมาย 100 นาโนวินาทีที่แสดงตามระยะเวลา ตัวอย่างเช่น

#duration(2,0,0,0) / #duration(0,1,30,0) 
// 32

ระยะเวลาที่ปรับสัดส่วน

ผลหารของระยะเวลา x และตัวเลขyเป็นระยะเวลาที่แสดงข้อมูลหารของตัวเลขของเครื่องหมาย 100 นาโนวินาทีที่แสดงตามระยะเวลา x และตัวเลขy ตัวอย่างเช่น

#duration(2,0,0,0) / 32 
// #duration(0,1,30,0)

การรวมโครงสร้าง

ตัวดําเนินการรวม (x & y) ถูกกําหนดตามชนิดของค่าต่อไปนี้:

X Y ผลลัพธ์ ล่าม
type text type text type text การเรียงต่อกัน
type text null null
null type text null
type date type time type datetime ผสาน
type date null null
null type time null
type list type list type list การเรียงต่อกัน
type record type record type record ผสาน
type table type table type table การเรียงต่อกัน

การเรียงต่อกัน

สามารถเชื่อมต่อค่าข้อความสองข้อความ รายการสองรายการ หรือตารางสองตารางโดยใช้x & y

ตัวอย่างต่อไปนี้จะแสดงตัวอย่างเกี่ยวกับการเชื่อมต่อค่าข้อความต่างๆ:

"AB" & "CDE"     // "ABCDE"

ตัวอย่างต่อไปนี้จะแสดงตัวอย่างเกี่ยวกับการเชื่อมต่อรายการ:

{1, 2} & {3}     // {1, 2, 3}

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่เชื่อมต่อค่าสองค่าโดยใช้ x & y:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • ไม่มีการเผยแพร่ข้อผิดพลาด ถ้าหน่วยข้อมูลของ หรือ y อย่างใดอย่างหนึ่งxมีข้อผิดพลาด

  • ผลลัพธ์ของการเชื่อมต่อค่าข้อความสองค่าคือค่าข้อความที่ประกอบด้วยค่าของ x ที่ตามด้วย y ทันที หากตัวถูกดําเนินการตัวใดตัวหนึ่งเป็น null และอีกตัวหนึ่งเป็นค่าข้อความ ผลลัพธ์จะเป็น null

  • ผลลัพธ์ของการเชื่อมต่อสองรายการคือรายการที่ประกอบด้วยหน่วยข้อมูลทั้งหมดของ x ตามด้วยหน่วยข้อมูลทั้งหมดของy

  • ผลลัพธ์ของการเชื่อมต่อสองตารางคือตารางที่มีการรวมกันของคอลัมน์ของตารางตัวถูกดําเนินการสองคอลัมน์ การเรียงลําดับคอลัมน์ของ x จะได้รับการรักษาไว้ ตามด้วยคอลัมน์ที่ปรากฏใน yเท่านั้น ทําให้การเรียงลําดับเชิงสัมพันธ์เป็นแบบเดิม สําหรับคอลัมน์ที่ปรากฏเฉพาะในหนึ่งในตัวถูกดําเนินการ null เท่านั้น จะถูกใช้เพื่อกรอกข้อมูลค่าเซลล์สําหรับตัวถูกดําเนินการอีกตัวหนึ่ง

ผสาน

การผสานเรกคอร์ด

เรกคอร์ดสองรายการสามารถผสานได้โดยใช้ x & yทําให้เกิดเรกคอร์ดที่มีเขตข้อมูลจากทั้ง x และy

ตัวอย่างต่อไปนี้แสดงตัวอย่างการผสานเรกคอร์ด:

[ x = 1 ] & [ y = 2 ]                // [ x = 1, y = 2 ] 
[ x = 1, y = 2 ] & [ x = 3, z = 4 ]  // [ x = 3, y = 2, z = 4 ]

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ผสานเรกคอร์ดสองรายการโดยใช้ x + y:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • ถ้าเขตข้อมูลปรากฏใน ทั้ง x และ yค่าจาก y จะถูกใช้

  • ลําดับของเขตข้อมูลในเรกคอร์ดที่เป็นผลลัพธ์คือลําดับxตามด้วยเขตข้อมูลใน y ที่ไม่ใช่ส่วนหนึ่งของ xในลําดับเดียวกับที่ปรากฏในy

  • การผสานเรกคอร์ดไม่ทําให้เกิดการประเมินค่า

  • ไม่มีข้อผิดพลาดเกิดขึ้น เนื่องจากเขตข้อมูลมีข้อผิดพลาด

  • ผลลัพธ์คือระเบียน

การผสานวันที่-เวลา

วันที่xสามารถผสานกับเวลาyโดยใช้ x & yทําให้เกิดวันที่เวลาที่รวมส่วนจากทั้ง x และy

ตัวอย่างต่อไปนี้แสดงตัวอย่างของการผสานวันที่และเวลา:

#date(2013,02,26) & #time(09,17,00) 
// #datetime(2013,02,26,09,17,00)

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ผสานเรกคอร์ดสองรายการโดยใช้ x + y:

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x นิพจน์ หรือ y ถูกเผยแพร่

  • ผลลัพธ์คือ วันที่เวลา

ตัวดำเนินการเอกภาค

+ตัวดําเนินการ , -และ not เป็นตัวดําเนินการยูนารี

unary-expression:
      type-expression
      +นิพจน์ยูนารี
      -นิพจน์ยูนารี
      notนิพจน์ยูนารี

ตัวดําเนินการบวกยูนารี

ตัวดําเนินการบวกยูนารี (+x) จะถูกกําหนดสําหรับชนิดค่าต่อไปนี้:

X ผลลัพธ์ ล่าม
type number type number การบวกยูนารี
type duration type duration การบวกยูนารี
null 'null

สําหรับค่าอื่นๆ ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

ตัวดําเนินการบวกยูนารีอนุญาตให้มี + การใช้เครื่องหมายกับตัวเลข วันที่เวลา หรือค่า null ผลลัพธ์คือค่าที่เหมือนกัน ตัวอย่างเช่น

+ - 1                 // -1 
+ + 1                 // 1 
+ #nan                // #nan 
+ #duration(0,1,30,0) // #duration(0,1,30,0)

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ประเมินตัวดําเนินการ +xบวกยูนารี :

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x ถูกเผยแพร่

  • หากผลลัพธ์ของการประเมิน x ไม่ใช่ค่าตัวเลข ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล จะเกิดขึ้น

ตัวดําเนินการลบยูนารี

ตัวดําเนินการลบยูนารี (-x) จะถูกกําหนดสําหรับชนิดค่าต่อไปนี้:

X ผลลัพธ์ ล่าม
type number type number ค่าลบ
type duration type duration ค่าลบ
null null

สําหรับค่าอื่นๆ ข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

ตัวดําเนินการลบยูนารีถูกใช้เพื่อเปลี่ยนเครื่องหมายของตัวเลขหรือระยะเวลา ตัวอย่างเช่น

- (1 + 1)       // -2 
- - 1           // 1 
- - - 1         // -1 
- #nan          // #nan 
- #infinity     // -#infinity 
- #duration(1,0,0,0)  // #duration(-1,0,0,0) 
- #duration(0,1,30,0) // #duration(0,-1,-30,0)

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ประเมินตัวดําเนินการ -xลบยูนารี :

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x ถูกเผยแพร่

  • ถ้านิพจน์เป็นตัวเลข ผลลัพธ์จะเป็นค่าตัวเลขจากนิพจน์ x โดยเครื่องหมายมีการเปลี่ยนแปลง ถ้าค่าเป็น NaN ผลลัพธ์จะเป็น NaN ด้วย

ตัวดําเนินการลบเชิงตรรกะ

ตัวดําเนินการนิติศาสตร์เชิงตรรกะ (not) จะถูกกําหนดสําหรับชนิดค่าต่อไปนี้:

X ผลลัพธ์ ล่าม
type logical type logical ค่าลบ
null null

ตัวดําเนินการนี้จะคํานวณการดําเนินการเชิงตรรกะ not ของค่าตรรกะที่กําหนด ตัวอย่างเช่น

not true             // false 
not false            // true 
not (true and true)  // false

รายการต่อไปนี้จะถูกระงับไว้ ขณะประเมินตัวดําเนินการ not xนิรวนเชิงตรรกะ :

  • จะมีข้อผิดพลาดเกิดขึ้นขณะที่ประเมิน x ถูกเผยแพร่

  • ค่าที่เกิดจากการประเมินนิพจน์ x ต้องเป็นค่าตรรกะ หรือต้องมีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น หากค่าเป็น trueผลลัพธ์จะเป็นfalse หากตัวถูกดําเนินการเป็น falseผลลัพธ์จะเป็นtrue

ผลลัพธ์คือค่าตรรกะ

ตัวดําเนินการชนิด

ตัวดําเนินการ is และ as เป็นที่รู้จักว่าเป็นตัวดําเนินการชนิด

ตัวดําเนินการความเข้ากันได้ของชนิด

ตัวดําเนินการ x is y ความเข้ากันได้ของชนิด จะถูกกําหนดสําหรับค่าชนิดต่อไปนี้:

X Y ผลลัพธ์
type any nullable-primitive-type type logical

นิพจน์ x is y จะแสดงtrueผลลัพธ์ หากชนิดที่ถูกใช้แทนของ x เข้ากันได้กับ yและแสดงผลลัพธ์ false หากชนิดที่ถูกใช้แทนของ x เข้ากันไม่ได้กับy yต้องเป็น nullable-primitivetype

is-expression:
      as-expression
      is-expressionisnullable-primitive-type
nullable-primitive-type:
      nullableopt primitive-type

ความเข้ากันได้ของชนิด ตามที่ได้รับการสนับสนุนโดยตัว is ดําเนินการ เป็นชุดย่อยของ ความเข้ากันได้ ชนิดทั่วไปและถูกกําหนดโดยใช้กฎต่อไปนี้:

  • หาก x เป็นค่า null ค่าจะเข้ากันได้หาก y เป็นชนิด any, ชนิด null, หรือชนิดที่เป็นค่าว่างได้

  • หาก x ไม่ใช่ค่า null แสดงว่าเข้ากันได้หากชนิดดั้งเดิมของ x เหมือนกับy

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ประเมินนิพจน์ x is y:

  • มีข้อผิดพลาดเกิดขึ้นขณะประเมินนิพจน์ x ถูกเผยแพร่

ตัวดําเนินการยืนยันชนิด

ตัวดําเนินการ x as y ยืนยันชนิด จะถูกกําหนดสําหรับชนิดค่าต่อไปนี้:

X Y ผลลัพธ์
type any nullable-primitive-type type any

นิพจน์ x as y จะระบุว่าค่า x เข้ากันได้กับ y ตามตัว is ดําเนินการ ถ้าไม่เข้ากัน จะเกิดข้อผิดพลาด yต้องเป็น nullable-primitive-type

as-expression:
      equality-expression
      as-expressionasnullable-primitive-type

นิพจน์ x as y จะถูกประเมินดังนี้:

  • จะมีการดําเนินการตรวจสอบ x is y ความเข้ากันได้ของชนิด และการยืนยันจะแสดง x ผลลัพธ์ที่ไม่เปลี่ยนแปลงหากการทดสอบดังกล่าวประสบความสําเร็จ

  • หากการตรวจสอบความเข้ากันได้ล้มเหลว จะมีข้อผิดพลาดที่มีรหัส "Expression.Error" เหตุผล เกิดขึ้น

ตัวอย่าง:

1 as number               // 1 
"A" as number             // error 
null as nullable number   // null

รายการต่อไปนี้จะถูกระงับไว้ ขณะที่ประเมินนิพจน์ x as y:

  • มีข้อผิดพลาดเกิดขึ้นขณะประเมินนิพจน์ x ถูกเผยแพร่

ตัวดําเนินการ Coalesce

ตัวดําเนินการ ?? Coalesce ส่งกลับผลลัพธ์ของตัวถูกดําเนินการด้านซ้ายถ้าไม่ใช่ค่า null มิฉะนั้นจะส่งกลับผลลัพธ์ของตัวถูกดําเนินการด้านขวา ตัวถูกดําเนินการด้านขวาจะถูกประเมิน ก็ต่อเมื่อตัวถูกดําเนินการด้านซ้ายเป็น null เท่านั้น