คำถามติดแท็ก operators

ฟีเจอร์หนึ่งที่ฉันพลาดจากภาษาที่ใช้งานได้คือความคิดที่ว่าโอเปอเรเตอร์เป็นแค่ฟังก์ชั่นดังนั้นการเพิ่มโอเปอเรเตอร์ที่กำหนดเองมักจะง่ายเหมือนการเพิ่มฟังก์ชั่น ภาษาเชิงโพรซีเดอร์จำนวนมากอนุญาตให้โอเปอเรเตอร์โอเวอร์โหลดดังนั้นในบางโอเปอเรเตอร์จะยังคงใช้งานได้ (นี่เป็นความจริงในDที่โอเปอเรเตอร์ถูกส่งเป็นสตริงในพารามิเตอร์เทมเพลต) ดูเหมือนว่าที่อนุญาตให้ผู้ประกอบการมากเกินไปก็มักจะเล็กน้อยเพื่อเพิ่มผู้ประกอบการที่กำหนดเองเพิ่มเติม ฉันพบโพสต์บล็อกนี้ซึ่งระบุว่าตัวดำเนินการที่กำหนดเองไม่ได้ทำงานได้ดีกับสัญกรณ์ของ infix เนื่องจากกฎที่มีมาก่อน แต่ผู้เขียนให้วิธีการแก้ไขปัญหาหลายประการ ฉันมองไปรอบ ๆ และไม่พบภาษาที่ใช้ในการดำเนินการใด ๆ ที่รองรับตัวดำเนินการที่กำหนดเองในภาษานั้น มีแฮ็ก (เช่นมาโครใน C ++) แต่แทบจะไม่เหมือนกับภาษาที่รองรับ เนื่องจากคุณสมบัตินี้ค่อนข้างง่ายต่อการนำไปใช้ทำไมจึงไม่เป็นเรื่องปกติ ฉันเข้าใจว่ามันอาจนำไปสู่โค้ดที่น่าเกลียด แต่ที่ไม่ได้หยุดนักออกแบบภาษาในอดีตจากการเพิ่มคุณสมบัติที่มีประโยชน์ที่สามารถถูกทำร้ายได้ง่าย (มาโครผู้ประกอบการที่ประกอบไปด้วยตัวชี้ที่ไม่ปลอดภัย) กรณีการใช้งานจริง: ใช้โอเปอเรเตอร์ที่หายไป (เช่น Lua ไม่มีโอเปอเรเตอร์ bitwise) Mimic D's ~(การต่อข้อมูลอาร์เรย์) DSLs ใช้|เป็นไวยากรณ์น้ำตาลแบบ Unix pipe (ใช้ coroutines / generators) ฉันมีความสนใจในภาษาที่ทำให้ผู้ประกอบการที่กำหนดเอง แต่ฉันสนใจมากขึ้นในเหตุผลที่จะได้รับการยกเว้น ฉันคิดถึงการใช้ภาษาสคริปต์เพื่อเพิ่มโอเปอเรเตอร์ที่ผู้ใช้กำหนด แต่หยุดตัวเองเมื่อฉันรู้ว่าฉันไม่เห็นมันเลยดังนั้นอาจมีเหตุผลที่ดีที่นักออกแบบภาษาฉลาดกว่าที่ฉันไม่อนุญาต

94 programming-languages  operators  procedural 

สิ่งที่ฉันรู้จักมาระยะหนึ่ง แต่ไม่เคยพิจารณามาก่อนคือภาษาส่วนใหญ่มีความเป็นไปได้ที่จะให้ความสำคัญกับผู้ประกอบการในคำสั่ง if ตามคำสั่งของพวกเขา ฉันมักจะใช้สิ่งนี้เป็นวิธีในการป้องกันข้อยกเว้นอ้างอิงเป็นโมฆะเช่น: if (smartphone != null && smartphone.GetSignal() > 50) { // Do stuff } ในกรณีนี้รหัสจะส่งผลในการตรวจสอบครั้งแรกว่าวัตถุไม่เป็นโมฆะและจากนั้นใช้วัตถุนี้รู้ว่ามันมีอยู่ ภาษานั้นฉลาดเพราะรู้ว่าถ้าคำสั่งแรกถ้าเป็นเท็จก็ไม่มีประโยชน์ที่จะประเมินคำสั่งที่สองและดังนั้นจึงไม่มีข้อยกเว้นการอ้างอิงโมฆะ สิ่งนี้ใช้งานได้เหมือนกันสำหรับตัวดำเนินการandและor สิ่งนี้มีประโยชน์ในสถานการณ์อื่น ๆ เช่นการตรวจสอบว่าดัชนีอยู่ในขอบเขตของอาเรย์และเทคนิคดังกล่าวสามารถทำได้ในหลายภาษาตามความรู้ของฉัน: Java, C #, C ++, Python และ Matlab คำถามของฉันคือ: รหัสประเภทนี้เป็นตัวแทนของการปฏิบัติที่ไม่ดีหรือไม่? การปฏิบัติที่ไม่ดีนี้เกิดขึ้นจากปัญหาทางเทคนิคที่ซ่อนอยู่หรือไม่ (เช่นนี้อาจส่งผลให้เกิดข้อผิดพลาด) หรือนำไปสู่ปัญหาความสามารถในการอ่านสำหรับโปรแกรมเมอร์อื่น ๆ หรือไม่? มันอาจสร้างความสับสนได้ไหม

88 programming-practices  language-agnostic  code-smell  operators 

ฉันเพิ่งอ่านหนึ่งในบทความของ Joelที่เขาพูดว่า: โดยทั่วไปฉันต้องยอมรับว่าฉันกลัวคุณสมบัติภาษาเล็กน้อยที่ซ่อนสิ่งต่างๆ เมื่อคุณเห็นรหัส i = j * 5; …อย่างน้อยคุณรู้ไหมว่า j นั้นถูกคูณด้วยห้าและผลลัพธ์ที่เก็บไว้ใน i แต่ถ้าคุณเห็นตัวอย่างรหัสเดียวกันใน C ++ คุณจะไม่รู้อะไรเลย ไม่มีอะไร วิธีเดียวที่จะรู้ว่าสิ่งที่เกิดขึ้นจริงใน C ++ คือการค้นหาประเภทของฉันและ j คืออะไรบางอย่างที่อาจถูกประกาศในที่อื่นทั้งหมด นั่นเป็นเพราะ j อาจเป็นประเภทที่มีการoperator*ใช้งานมากเกินไปและจะทำสิ่งที่มีไหวพริบมากเมื่อคุณพยายามคูณมัน (เน้นที่เหมือง) กลัวความสามารถทางภาษาที่ซ่อนสิ่งต่าง ๆ หรือไม่? คุณจะกลัวสิ่งนั้นได้อย่างไร การซ่อนสิ่งต่าง ๆ (หรือที่เรียกว่านามธรรม ) เป็นหนึ่งในแนวคิดหลักของการเขียนโปรแกรมเชิงวัตถุหรือไม่? ทุกครั้งที่คุณเรียกใช้เมธอดa.foo(b)คุณจะไม่มีความคิดว่าจะทำอะไร คุณต้องค้นหาว่าประเภทใดaและbเป็นอะไรบางอย่างที่อาจถูกประกาศในที่อื่นทั้งหมด ดังนั้นเราควรทำอย่างไรกับการเขียนโปรแกรมเชิงวัตถุเพราะมันซ่อนสิ่งต่าง ๆ จากโปรแกรมเมอร์มากเกินไป? และj * 5แตกต่างจากj.multiply(5)ที่คุณอาจต้องเขียนในภาษาที่ไม่รองรับการบรรทุกเกินพิกัดได้อย่างไร อีกครั้งคุณจะต้องค้นหาประเภทของjและมองเข้าไปในmultiplyวิธีการเพราะแท้จริงและดูเถิดjอาจเป็นประเภทที่มีmultiplyวิธีการที่ทำสิ่งที่มีไหวพริบมาก "Muahaha ฉันเป็นนักเขียนโปรแกรมที่ชั่วร้ายที่ตั้งชื่อวิธีการmultiplyแต่สิ่งที่จริง ๆ แล้วมันคือความคลุมเครือและไม่เข้าใจสัญชาตญาณโดยสิ้นเชิง …

82 operators  overload 

ตัวอย่างเช่นคุณต้องการซับไลเนอร์นี้หรือไม่ int median(int a, int b, int c) { return (a<b) ? (b<c) ? b : (a<c) ? c : a : (a<c) ? a : (b<c) ? c : b; } หรือโซลูชัน if / else ที่เกี่ยวข้องกับคำสั่ง return หลายรายการ? เมื่อใด?:ที่เหมาะสมและเมื่อใด ควรสอนหรือซ่อนเร้นจากผู้เริ่มต้นหรือไม่

79 operators  conditions 

เครื่องหมายบวก+จะใช้สำหรับการเพิ่มและสำหรับการต่อสายอักขระ แต่สหายของมัน: เครื่องหมายลบ-, โดยทั่วไปจะไม่เห็นการตัดแต่งสตริงหรือกรณีอื่นนอกเหนือจากการลบ อะไรคือเหตุผลหรือข้อ จำกัด สำหรับสิ่งนั้น พิจารณาตัวอย่างต่อไปนี้ใน JavaScript: var a = "abcdefg"; var b = "efg"; a-b == NaN // but a+b == "abcdefgefg"

64 coding-standards  history  operators  overload 

ใครบางคนสามารถอธิบายเหตุผลได้ทำไมในภาษายอดนิยม (ดูหมายเหตุด้านล่าง) ตัวดำเนินการเปรียบเทียบ (==,! =, <,>, <=,> =) มีลำดับความสำคัญสูงกว่าตัวดำเนินการระดับบิต (&, |, ^ , ~)? ฉันไม่คิดว่าฉันเคยเจอการใช้งานที่สำคัญกว่านี้จะเป็นธรรมชาติ มันเป็นสิ่งที่ชอบเสมอ: if( (x & MASK) == CORRECT ) ... // Chosen bits are in correct setting, rest unimportant if( (x ^ x_prev) == SET ) // only, and exactly SET bit changed if( (x & …

63 language-design  syntax  operators  bitwise-operators  operator-precedence 

ฉันเป็นบิตสับสนโดยเอกสาร # MSDN C ซึ่งระบุว่า&และ|ผู้ประกอบการเชิงตรรกะและที่&&และ||ผู้ประกอบการที่มีเงื่อนไข ฉันให้โทร&&, ||และ!ดำเนินการทางตรรกะดังนั้นผมผิดหรือเปล่า?

62 c#  operators  logical-operator 

บางครั้งฉันเขียนโปรแกรม Python **เพื่อทำการแปลง ฉันเข้าใจสิ่งที่มันทำ แต่ฉันกำลังจัดการกับโครงสร้างข้อมูลอะไร? A dictและอื่น ๆ คืออะไร? array? มีชื่อสำหรับ**ผู้ประกอบการหรือไม่?

59 python  operators  type-conversion 

มีผู้ประกอบการเทียบเท่าหรือไม่? ตัวอย่างเช่นสีโปรดของฉันไม่ได้เป็นสีเขียวหรือสีน้ำเงิน และรหัสจะเทียบเท่ากับ: // example one if (color!="green" && color!="blue") { } // example two if (x nor y) { // x is false and y is false }

56 operators 

โปรแกรมเมอร์ Java ทุกคนรู้ดีว่าคุณต้องใช้ String.equals () เพื่อเปรียบเทียบสตริงแทนที่จะเป็น == เพราะ == ตรวจสอบความเท่าเทียมกันอ้างอิง เมื่อฉันจัดการกับสตริงเวลาส่วนใหญ่ที่ฉันกำลังตรวจสอบความเท่าเทียมกันของค่ามากกว่าความเท่าเทียมกันอ้างอิง ดูเหมือนว่าสำหรับฉันแล้วมันจะง่ายกว่านี้หากภาษาอนุญาตให้เปรียบเทียบค่าสตริงโดยใช้ == จากการเปรียบเทียบตัวดำเนินการ == ของ C # จะตรวจสอบความเท่าเทียมกันของค่าสำหรับสตริง s และถ้าคุณต้องการตรวจสอบความเท่าเทียมกันของการอ้างอิงคุณสามารถใช้ String.ReferenceEquals อีกจุดสำคัญคือสตริงไม่เปลี่ยนรูปดังนั้นจึงไม่มีอันตรายใด ๆ ที่จะทำโดยอนุญาตให้ใช้คุณลักษณะนี้ มีเหตุผลใดเป็นพิเศษหรือไม่ที่สิ่งนี้ไม่ได้นำไปใช้ใน Java?

50 java  programming-languages  operators 

ฉันหมายความว่าอย่างนี้: <?php $number1 = 5; // (Type 'Int') $operator1 = +; // (Type non-existent 'Operator') $number2 = 5; // (Type 'Int') $operator2 = *; // (Type non-existent 'Operator') $number3 = 8; // (Type 'Int') $test = $number1 $operator1 $number2 $operator2 $number3; //5 + 5 * 8. var_dump($test); ?> แต่ด้วยวิธีนี้: <?php …

47 programming-languages  variables  operators 

หากฉันต้องการเปรียบเทียบตัวเลขสองตัว (หรือเอนทิตีที่มีการจัดลำดับที่ดีอื่น ๆ ) ฉันจะทำเช่นx < yนั้น ถ้าผมต้องการเปรียบเทียบสามของพวกเขา, x < y < zนักเรียนพีชคณิตโรงเรียนมัธยมจะแนะนำพยายาม โปรแกรมเมอร์ในตัวฉันจะตอบกลับด้วย "ไม่นั่นไม่ถูกต้องคุณต้องทำx < y && y < z" ภาษาส่วนใหญ่ที่ฉันพบเจอดูเหมือนจะไม่สนับสนุนไวยากรณ์นี้ซึ่งเป็นเรื่องแปลกเพราะมันเป็นเรื่องธรรมดาในวิชาคณิตศาสตร์ Python เป็นข้อยกเว้นที่น่าสังเกต JavaScript ดูเหมือนข้อยกเว้น แต่จริงๆแล้วเป็นเพียงผลพลอยได้ที่โชคร้ายของลำดับความสำคัญของผู้ปฏิบัติงานและการแปลงโดยนัย ใน Node.js, 1 < 3 < 2ประเมินเพราะมันจริงๆtrue(1 < 3) < 2 === true < 2 === 1 < 2 ดังนั้นคำถามของฉันคือ: เหตุใดจึงx < y …

34 language-agnostic  syntax  language-features  comparison  operators 

ทำไมโอเปอเรเตอร์ถึง--ไม่มีอยู่สำหรับบูลในขณะนั้นสำหรับโอเปอเรเตอร์++? ฉันลองใช้ C ++ แล้วและฉันไม่รู้ว่าคำถามของฉันใช้ได้กับภาษาอื่นหรือไม่ ฉันยินดีที่จะรู้ว่ายัง ฉันรู้ว่าฉันสามารถใช้โอเปอเรเตอร์++กับบูล มันทำให้บูลใด ๆ เท่ากับจริง bool b = false; b++; // Now b == true. ทำไมเราไม่สามารถใช้โอเปอเรเตอร์--ในทางตรงกันข้ามได้ bool b = true; b--; // Now b == false; มันไม่มีประโยชน์มาก แต่ฉันอยากรู้

29 c++  history  operators  boolean 

ฉันสงสัยว่ามีเหตุผลใด - หรือถ้ามันเป็นแค่อุบัติเหตุของประวัติศาสตร์ - ว่าไม่มี!>และ!<ตัวดำเนินการในภาษาการเขียนโปรแกรมส่วนใหญ่ ? a >= b (เป็นมากกว่าหรือเท่ากับข)อาจจะเขียนเป็น!(a < b) (เป็นขไม่น้อย)a !< bที่เท่าเทียมกัน คำถามนี้ทำให้ฉันหลงเมื่อฉันอยู่ในระหว่างการสร้างรหัสการสร้างต้นไม้แสดงออกของฉันเอง ภาษาโปรแกรมส่วนใหญ่มีa != bผู้ประกอบการสำหรับ!(a=b)ดังนั้นทำไมไม่!>และ!<? UPDATE: !<(ไม่น้อยกว่า) ออกเสียงได้ง่ายกว่า>=(มากกว่าหรือเท่ากับ) !<(ไม่น้อยกว่า) พิมพ์สั้นกว่า>=(มากกว่าหรือเท่ากับ) !<(ไม่น้อยกว่า) ง่ายต่อการเข้าใจ *มากกว่า>=(มากกว่าหรือเท่ากับ) * เนื่องจากORเป็นตัวดำเนินการแบบไบนารีที่คุณสมองจำเป็นต้องใช้ตัวถูกดำเนินการสองตัว (ตัวคูณเท่ากับ) ในขณะที่ตัวNOTดำเนินการแบบเอกเทศและสมองของคุณจำเป็นต้องทำงานด้วยตัวถูกดำเนินการตัวเดียว (น้อยกว่า)

28 syntax  comparison  operators 

ฉันกำลังพัฒนาภาษาที่ฉันต้องการแทนที่ทั้ง Javascript และ PHP (ฉันไม่เห็นปัญหาใด ๆ กับสิ่งนี้มันไม่เหมือนภาษาใดภาษาหนึ่งเหล่านี้ที่มีฐานการติดตั้งขนาดใหญ่) หนึ่งในสิ่งที่ฉันต้องการเปลี่ยนคือการเปลี่ยนผู้ประกอบการมอบหมายให้เป็นคำสั่งการมอบหมายลบความสามารถในการใช้ประโยชน์จากค่าที่ส่งคืน x=1; /* Assignment. */ if (x==1) {} /* Comparison. */ x==1; /* Error or warning, I've not decided yet. */ if (x=1) {} /* Error. */ ฉันรู้ว่านี่จะหมายความว่าฟังก์ชั่นหนึ่งบรรทัดที่คน C รักมากจะไม่ทำงานอีกต่อไป ฉันคิด (มีหลักฐานน้อยกว่าประสบการณ์ส่วนตัวของฉัน) ว่าส่วนใหญ่ครั้งนี้เกิดขึ้นมันตั้งใจจริง ๆ ที่จะดำเนินการเปรียบเทียบ หรือมันคืออะไร? มีการใช้งานจริงของค่าส่งคืนของผู้ดำเนินการที่ไม่สามารถเขียนใหม่ได้หรือไม่? (สำหรับภาษาใด ๆ ที่มีแนวคิดดังกล่าว)

27 language-agnostic  syntax  operators