ลักษณะการทํางานของตัวดําเนินการ
ส่วนนี้กําหนดลักษณะการทํางานของตัวดําเนินการ 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 | คำอธิบาย |
---|---|---|
เบื้องต้น |
ผม @ ผม |
นิพจน์ตัวระบุ |
(x) | นิพจน์ที่มีวงเล็บ | |
x[i] | การค้นหา | |
x{y} | การเข้าถึงหน่วยข้อมูล | |
x(...) | การเรียกฟังก์ชัน | |
{x, y, ...} | การเตรียมใช้งานรายการ | |
[ i = x, ... ] | การเตรียมใช้งานเรกคอร์ด | |
... | ไม่ได้นํามาใช้ | |
ยูนารี | + x | ข้อมูลประจำตัว |
- x | ค่าลบ | |
not
x |
นิเสธเชิงตรรกะ | |
เมตาดาต้า |
xmeta y |
เชื่อมโยงเมตาดาต้า |
การคูณ | x * y | การคูณ |
x / y | ฝ่าย | |
เสริม | x + y | การเพิ่มเติม |
x - y | การลบ | |
เกี่ยวกับความสัมพันธ์ | x< y | น้อยกว่า |
x > y | มากกว่า | |
x<= y | น้อยกว่าหรือเท่ากับ | |
x >= y | มากกว่าหรือเท่ากับ | |
Equality | x = y | เท่ากับ |
x<> y | Not equal | |
การยืนยันชนิด |
xas y |
ใช้งานร่วมกันได้กับประเภทดั้งเดิมแบบที่เป็นค่าว่างได้หรือข้อผิดพลาด |
ความสอดคล้องกันของชนิด |
xis y |
ทดสอบหากเป็นประเภทดั้งเดิมแบบที่เป็นค่าว่างได้ที่เข้ากันได้ |
ตรรกะ และ |
xand y |
การรวมกันเชิงวงจรแบบสั้น |
ตรรกะ หรือ |
xor y |
การแยกเชิงวงจรแบบสั้น |
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-expressionmeta
unary-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-expressionor
logical-or-expression
logical-and-expression:
is-expression
is-expressionand
logical-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
ถ้า และในกรณีที่y
ไม่ประเมินเป็นx
true
เท่านั้นในนิพจน์
x
และ จะมีการประเมินนิพจน์y
ถ้า และในกรณีที่y
ไม่ประเมินเป็นx
false
เท่านั้น
คุณสมบัติสองรายการสุดท้ายจะให้คุณสมบัติ "เงื่อนไข" แก่ตัวดําเนินการเชิงตรรกะแบบมีเงื่อนไข คุณสมบัติยังเรียกว่า "วงจรสั้น" คุณสมบัติเหล่านี้จะเป็นประโยชน์ในการเขียนเพรดิเคตป้องกันที่มีขนาดกะทัดรัด ตัวอย่างเช่น นิพจน์ต่อไปนี้จะเทียบเท่ากัน:
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.Multiply
Value.Divide
) สามารถใช้เพื่อร้องขอการดําเนินการเหล่านี้โดยใช้แบบจําลองความแม่นยําเฉพาะ
ไม่สามารถใช้โอเวอร์โฟลว์ตัวเลขได้:
#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 |
|
type
วันที่เวลา |
type duration |
type
วันที่เวลา |
ค่าชดเชยวันที่เวลาตามระยะเวลา |
type duration |
type
วันที่เวลา |
type
วันที่เวลา |
|
type
วันที่เวลา |
null |
null |
|
null |
type
วันที่เวลา |
null |
ในตาราง type
วันที่เวลา จะtype date
ย่อมาจาก , type datetime
type datetimezone
, หรือtype time
เมื่อเพิ่มระยะเวลาและค่าวันที่เวลาบางชนิด ค่าที่เป็นผลลัพธ์จะเป็นชนิดเดียวกัน
สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error"
เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้
จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่
ผลรวมตัวเลข
ผลรวมของตัวเลขสองตัว จะถูกคํานวณโดยใช้ตัว ดําเนินการเพิ่มเติม ทําให้เกิดตัวเลข
ตัวอย่างเช่น:
1 + 1 // 2
#nan + #infinity // #nan
ตัวดําเนินการ +
เพิ่มเติม เหนือตัวเลข จะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Add
ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณผลรวมของตัวเลข:
ผลรวมในค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิตศาสตร์ IEEE 754 ค่าเลขคณิตไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ
x
y
เป็นค่าแบบจํากัดที่ไม่ใช่ศูนย์ และ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 |
|
type
วันที่เวลา |
type
วันที่เวลา |
type duration |
ระยะเวลาระหว่างวันที่เวลา |
type
วันที่เวลา |
type duration |
type
วันที่เวลา |
ค่าชดเชยวันที่เวลาตามระยะเวลาที่ลบล้าง |
type
วันที่เวลา |
null |
null |
|
null |
type
วันที่เวลา |
null |
ในตาราง type
วันที่เวลา จะtype date
ย่อมาจาก , type datetime
type datetimezone
, หรือtype time
เมื่อลบระยะเวลาออกจากค่าวันที่เวลาบางชนิด ค่าผลลัพธ์ที่ได้จะเป็นค่าชนิดเดียวกัน
สําหรับการรวมกันของค่าอื่นนอกเหนือจากค่าที่แสดงไว้ในตาราง ข้อผิดพลาดที่มีรหัส "Expression.Error"
เหตุผล เกิดขึ้น การรวมกันแต่ละรายการจะครอบคลุมในส่วนต่อไปนี้
จะมีข้อผิดพลาดเกิดขึ้น ขณะที่การประเมินตัวถูกดําเนินการถูกเผยแพร่
ความแตกต่างของตัวเลข
ค่าความต่างระหว่างตัวเลขสองค่าจะถูกคํานวณโดยใช้ตัว ดําเนินการลบ ทําให้เกิดตัวเลข ตัวอย่างเช่น:
1 - 1 // 0
#nan - #infinity // #nan
ตัวดําเนินการ -
ลบเหนือตัวเลขจะใช้ค่าความแม่นยําคู่ โดยสามารถใช้ฟังก์ชัน Value.Subtract
ไลบรารีมาตรฐานเพื่อระบุค่าความแม่นยําของจุดทศนิยม รายการต่อไปนี้จะถูกระงับไว้ ขณะที่คํานวณค่าความต่างของตัวเลข:
ความแตกต่างของค่าความแม่นยําคู่ จะถูกคํานวณตามกฎทางคณิตศาสตร์ IEEE 754 ค่าความแม่นยําคู่ไบนารีแบบ 64 บิต IEEE 754-2008 ตารางต่อไปนี้แสดงรายการผลลัพธ์ของการรวมค่าจํากัดที่ไม่ใช่ศูนย์ทั้งหมดที่เป็นไปได้ ศูนย์ ค่าอนันต์ และค่า NaN ในตาราง และ
x
y
เป็นค่าแบบจํากัดที่ไม่ใช่ศูนย์ และ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 ในตาราง และ
x
y
เป็นค่าจํากัดบวก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 number |
ผลหารตัวเลขของระยะเวลา |
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 ในตาราง และ
x
y
เป็นค่าจํากัดบวก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
ถูกเผยแพร่ไม่มีการเผยแพร่ข้อผิดพลาด ถ้าหน่วยข้อมูลของ หรือ
x
อย่างใดอย่างหนึ่งy
มีข้อผิดพลาดผลลัพธ์ของการเชื่อมต่อค่าข้อความสองค่าคือค่าข้อความที่ประกอบด้วยค่าของ 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-expressionis
nullable-primitive-type
nullable-primitive-type:
nullable
opt 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-expressionas
nullable-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 เท่านั้น