มีเหตุผลใดที่ภาษาการเขียนโปรแกรมส่วนใหญ่ไม่มี '!>' (ไม่มากกว่า) และ '! <' (ไม่น้อยกว่า) ตัวดำเนินการหรือไม่

ฉันสงสัยว่ามีเหตุผลใด - หรือถ้ามันเป็นแค่อุบัติเหตุของประวัติศาสตร์ - ว่าไม่มี!>และ!<ตัวดำเนินการในภาษาการเขียนโปรแกรมส่วนใหญ่ ?

a >= b (เป็นมากกว่าหรือเท่ากับข)อาจจะเขียนเป็น!(a < b) (เป็นขไม่น้อย)a !< bที่เท่าเทียมกัน

คำถามนี้ทำให้ฉันหลงเมื่อฉันอยู่ในระหว่างการสร้างรหัสการสร้างต้นไม้แสดงออกของฉันเอง ภาษาโปรแกรมส่วนใหญ่มีa != bผู้ประกอบการสำหรับ!(a=b)ดังนั้นทำไมไม่!>และ!<?

UPDATE:

• !<(ไม่น้อยกว่า) ออกเสียงได้ง่ายกว่า>=(มากกว่าหรือเท่ากับ)
• !<(ไม่น้อยกว่า) พิมพ์สั้นกว่า>=(มากกว่าหรือเท่ากับ)
• !<(ไม่น้อยกว่า) ง่ายต่อการเข้าใจ *มากกว่า>=(มากกว่าหรือเท่ากับ)

* เนื่องจากORเป็นตัวดำเนินการแบบไบนารีที่คุณสมองจำเป็นต้องใช้ตัวถูกดำเนินการสองตัว (ตัวคูณเท่ากับ) ในขณะที่ตัวNOTดำเนินการแบบเอกเทศและสมองของคุณจำเป็นต้องทำงานด้วยตัวถูกดำเนินการตัวเดียว (น้อยกว่า)

ภาษา D การเขียนโปรแกรมและการขยาย DMC ของไปที่ C และ C ++ ไม่สนับสนุนผู้ประกอบการเหล่านี้ (ทั้งหมด 14 การรวมกันของพวกเขา) แต่ที่น่าสนใจ, D จะไปเลิกประกอบการเหล่านี้ส่วนใหญ่เป็นเพราะ

1. สิ่งที่แน่นอนคือa !< b? a>=b || isNaN(a) || isNaN(b)มันเป็น !<คือไม่ได้เช่นเดียวกับ>=เพราะNaN !< NaNในขณะที่ความจริงNaN >= NaNเป็นเท็จ IEEE 754 นั้นยากที่จะควบคุมดังนั้นการใช้a !< bเพียงแค่จะทำให้เกิดความสับสนในการจัดการ NaN - คุณสามารถค้นหาตัวดำเนินการดังกล่าวใน Phobos (ไลบรารีมาตรฐานของ D) และมีการใช้งานจำนวนมากที่มีความคิดเห็นอยู่ข้างๆ
2. ดังนั้นบางคนจะใช้มันแม้ว่าตัวดำเนินการดังกล่าวจะมีอยู่ใน D
3. และต้องกำหนดโทเค็นอีก 8 ตัวสำหรับตัวดำเนินการที่ใช้บ่อยซึ่งทำให้คอมไพเลอร์ซับซ้อนขึ้นเพื่อผลประโยชน์เพียงเล็กน้อย
4. และหากไม่มีตัวดำเนินการเหล่านั้นเราก็ยังคงสามารถใช้สิ่งที่เทียบเท่า!(a < b)ได้หรือถ้าคนหนึ่งชอบที่จะชัดเจนa >= b || isNaN(a) || isNaN(b)และพวกเขาก็อ่านง่ายขึ้น

นอกจากนี้ความสัมพันธ์ (≮, ≯, ≰, ≱) มักจะไม่ค่อยเห็นในวิชาคณิตศาสตร์ขั้นพื้นฐานซึ่งแตกต่างจาก!=(≠) หรือ>=(≥) ดังนั้นจึงเป็นเรื่องยากที่จะเข้าใจสำหรับคนจำนวนมาก

นี่อาจเป็นเหตุผลว่าทำไมภาษาส่วนใหญ่ไม่สนับสนุนภาษาเหล่านี้

เพราะมันไม่สมเหตุสมผลเลยที่จะมีตัวดำเนินการสองตัวที่ต่างกันซึ่งมีความหมายเหมือนกัน

• “ ไม่ยิ่งใหญ่กว่า” ( !>) เหมือนกันกับ“ น้อยกว่าหรือเท่ากับ” ( <=)
• “ ไม่น้อยกว่า” ( !<) เหมือนกันกับ“ มากกว่าหรือเท่ากับ” ( >=)

สิ่งนี้ใช้ไม่ได้กับ "ไม่เท่ากับ" ( !=) ไม่มีโอเปอเรเตอร์ที่มีความหมายเหมือนกัน

ดังนั้นการดัดแปลงของคุณจะทำให้ภาษาซับซ้อนขึ้นโดยไม่มีประโยชน์

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

แม้จะอยู่ใน 3 คุ้มค่าตรรกะเช่น ANSI SQL, not x < yเทียบเท่าของx >= yที่พวกเขาทั้งสองให้NULLถ้าอย่างใดอย่างหนึ่งxหรือเป็นy NULLแต่มีที่ไม่ได้มาตรฐาน ANSI ภาษาที่สอดคล้องกับ SQL ที่มันไม่เทียบเท่าและพวกเขาจะมี!<

Transact-SQL มี!> (ไม่มากกว่า)และ! <(ไม่น้อยกว่า)ตัวดำเนินการ

นอกจากคุณแล้วใครบางคนที่Sybase Microsoft ก็คิดว่ามันเป็นความคิดที่ดีเช่นกัน เช่นเดียวกับ Microsoft Bob! :)

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

จากRFC 1925

ความสมบูรณ์แบบไม่ถึงเมื่อไม่มีอะไรเหลือให้เพิ่ม แต่เมื่อไม่มีอะไรเหลือให้เอาไป

การเพิ่มโอเปอเรเตอร์เพิ่มเติมที่ทำซ้ำฟังก์ชั่นที่มีอยู่ไม่ได้ทำอะไรนอกจากเพิ่มความซับซ้อน (ไม่จำเป็น) ให้กับภาษา (และ tokenizer และ parser)

ลองใช้ภาษาที่มีความเป็นไปได้ที่โอเปอร์เรเตอร์คุณจะมีโอเปอเรเตอร์ตัวอื่นที่จะโอเวอร์โหลด พิจารณาความสับสนเมื่อใดbool operator<=และbool operator!>จะคืนสิ่งต่าง ๆ ได้อย่างไร (ใช่ฉันรู้ว่าเราสามารถทำการเปรียบเทียบที่ไม่สอดคล้องกันได้แล้ว)

สุดท้ายคิดว่าภาษาที่วิธีการหรือผู้ประกอบการที่มีการกำหนดทวีคูณ (ทับทิม - ฉันกำลังมองหาคุณ ) และคุณมีหนึ่งโปรแกรมเมอร์ที่ใช้ <= ในขณะที่อีกใช้!> และคุณมีหลายรูปแบบรหัสสำหรับการแสดงออกที่เหมือนกัน

! <เท่ากับ> = ทีนี้ทำไมเราถึงมีอันดับที่สองไม่ใช่อันดับแรกเพราะทุกภาษาใช้ตัวดำเนินการเชิงบวกก่อนแล้วจึงเข้าหาตัวดำเนินการเชิงลบเช่นเดียวกับการใช้> = ยังครอบคลุม! <และ <= ครอบคลุม!> ดังนั้นผู้สร้างภาษา และคิดว่าพวกเขาจะซ้ำซ้อนและข้ามพวกเขา

พยายามใช้กรณีที่เป็นบวกก่อนแล้วไปที่กรณีที่เป็นลบ (:) การคิดเชิงบวกฉันมุมมองส่วนตัวเท่านั้น)

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

ดังนั้นในการเขียนโปรแกรมภาษาเรามักจะได้รับสัญลักษณ์ที่ดูเหมือน not สำหรับไม่เท่ากับ ( !=หรือ/=ยกเว้นบางคนถ้าเป็นแฟนซี<>หรือผู้ประกอบการต้นฉบับ)

และสิ่งที่ดูเหมือน like และ≥ ( <=และ>=)

Btw ฉันไม่เห็นด้วยกับการยืนยันของคุณที่ไม่ง่ายต่อการเข้าใจและเหตุผลเกี่ยวกับตอนนั้นหรือ ในวิชาคณิตศาสตร์การพิสูจน์ที่เกี่ยวข้องกับการปฏิเสธหลายครั้ง (เช่นลดการไร้สาระ) มักจะขมวดคิ้วหากมีทางเลือกอื่นที่ตรงกว่า นอกจากนี้ในกรณีการสั่งซื้อความรู้พื้นฐานที่เรามี (และที่ใช้เมื่อคิดหรือพิสูจน์บางอย่าง) คือ tricotomy ระหว่าง <, = และ> ดังนั้นใด ๆ ! คำสั่ง <อาจจะต้องถูกแปลงเป็น> = ถ้าคุณต้องการทำ สิ่งที่มีประโยชน์กับมัน

ฉันจะตำหนิชุดคำสั่งชุดประกอบบางส่วน คุณมีคำแนะนำเช่นjge"กระโดดถ้ามากกว่าหรือเท่ากับ" ตรงข้ามกับ "กระโดดถ้าไม่น้อยกว่า"

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

... อาจจะเป็น

ฉันคิดว่าฉันเห็นบางภาษาเมื่อไม่กี่ปีที่ผ่านมาแทนที่จะใช้!=ตัวดำเนินการ (ไม่เท่ากับ) <>มีการใช้บางอย่าง จำชื่อของพวกเขาไม่ได้ ...

ผมคิดว่ามันยากที่จะอ่าน!(a < b)หรือกว่าa !< b a >= bอาจเป็นเหตุผลว่าทำไม!<ไม่ใช้ (มันดูน่าเกลียดในความคิดของฉัน)