การฝึกอบรม
โมดูล
Perform basic operations on numbers in C# - Training
Learn the operators and techniques used to perform basic math operations on numeric data.
เบราว์เซอร์นี้ไม่ได้รับการสนับสนุนอีกต่อไป
อัปเกรดเป็น Microsoft Edge เพื่อใช้ประโยชน์จากคุณลักษณะล่าสุด เช่น การอัปเดตความปลอดภัยและการสนับสนุนด้านเทคนิค
ส่วนนี้กําหนดลักษณะการทํางานของตัวดําเนินการ 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
ในการคํานวณระยะเวลาระหว่างรายการ ในที่นี่ วันที่เวลา จะ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
:
การตีความของตัวดําเนินการคูณ (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 ส่งกลับผลลัพธ์ของตัวถูกดําเนินการด้านซ้ายถ้าไม่ใช่ค่า null มิฉะนั้นจะส่งกลับผลลัพธ์ของตัวถูกดําเนินการด้านขวา ตัวถูกดําเนินการด้านขวาจะถูกประเมิน ก็ต่อเมื่อตัวถูกดําเนินการด้านซ้ายเป็น null เท่านั้น
การฝึกอบรม
โมดูล
Perform basic operations on numbers in C# - Training
Learn the operators and techniques used to perform basic math operations on numeric data.