เหตุใดฉันจึงไม่ควรใช้ "สัญลักษณ์ภาษาฮังการี"

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

ดูเพิ่มเติม: ผู้คนใช้หลักการตั้งชื่อภาษาฮังการีในโลกแห่งความเป็นจริงหรือไม่?

คนส่วนใหญ่ใช้สัญกรณ์ฮังการีในทางที่ผิดและได้ผลลัพธ์ที่ไม่ถูกต้อง

อ่านบทความที่ดีเยี่ยมนี้โดยโจ Spolsky: ทำผิดรหัสดูผิด

ในระยะสั้นสัญกรณ์ภาษาฮังการีที่คุณนำหน้าชื่อตัวแปรของคุณด้วยtype(สตริง) (ระบบฮังการี) ไม่ดีเพราะไม่มีประโยชน์

สัญลักษณ์ภาษาฮังการีตามที่ผู้เขียนตั้งใจไว้โดยที่คุณนำหน้าชื่อตัวแปรด้วยkind(โดยใช้ตัวอย่างของ Joel: สตริงที่ปลอดภัยหรือสตริงที่ไม่ปลอดภัย) ดังนั้น Apps Hungarian จึงมีประโยชน์และยังคงมีประโยชน์

v การใช้ adj การตั้งชื่อภาษาฮังการีทำให้ nreading ncode adjdifficult

โจเอลผิดและนี่คือเหตุผล

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

หลายสิ่งหลายอย่างที่โจเอลพูดถึงว่าเป็น "ชนิด" ไม่ใช่ชนิด; ในความเป็นจริงพวกเขาเป็นประเภท

อย่างไรก็ตามสิ่งที่ภาษาส่วนใหญ่ขาดคือระบบประเภทที่แสดงออกมากพอที่จะบังคับใช้ความแตกต่างเหล่านี้ ตัวอย่างเช่นถ้า C มีชนิด "strong typedef" (โดยที่ชื่อ typedef มีการดำเนินการทั้งหมดของประเภทพื้นฐาน แต่ไม่สามารถแปลงเป็นได้) ปัญหาเหล่านี้จะหมดไป ตัวอย่างเช่นหากคุณสามารถพูดได้ว่าstrong typedef std::string unsafe_string;จะแนะนำประเภทใหม่unsafe_stringที่ไม่สามารถแปลงเป็นสตริง std :: (และสามารถมีส่วนร่วมในการแก้ปัญหาโอเวอร์โหลดได้เป็นต้น) เราก็ไม่จำเป็นต้องใช้คำนำหน้าโง่ ๆ

ดังนั้นการอ้างว่าฮังกาเรียนมีไว้เพื่อสิ่งที่ไม่ใช่ประเภทนั้นผิด มันถูกใช้สำหรับข้อมูลประเภท ข้อมูลประเภทที่สมบูรณ์กว่าข้อมูลประเภท C แบบเดิมอย่างแน่นอน เป็นข้อมูลประเภทที่เข้ารหัสรายละเอียดความหมายบางอย่างเพื่อระบุวัตถุประสงค์ของวัตถุ แต่ยังคงเป็นข้อมูลประเภทและวิธีแก้ปัญหาที่เหมาะสมคือการเข้ารหัสลงในระบบประเภทเสมอ การเข้ารหัสลงในระบบประเภทเป็นวิธีที่ดีที่สุดในการตรวจสอบความถูกต้องและการบังคับใช้กฎอย่างเหมาะสม ชื่อตัวแปรไม่ต้องตัดมัสตาร์ด

กล่าวอีกนัยหนึ่งจุดมุ่งหมายไม่ควร "ทำให้โค้ดผิดดูผิดสำหรับนักพัฒนา" มันควรจะ "ทำให้โค้ดผิดดูคอมไพเลอร์ผิด"

ฉันคิดว่ามันรวมซอร์สโค้ดไว้อย่างหนาแน่น

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

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

หลายคำตอบอ้างอิงบทความ Joels อย่างไรก็ตามโปรดทราบว่าตัวอย่างของเขาอยู่ใน VBScript ซึ่งไม่รองรับคลาสที่ผู้ใช้กำหนดเอง (อย่างน้อยก็เป็นเวลานาน) ในภาษาที่มีชนิดที่ผู้ใช้กำหนดเองคุณจะแก้ปัญหาเดียวกันได้โดยสร้าง HtmlEncodedString-type จากนั้นให้เมธอด Write ยอมรับเฉพาะสิ่งนั้น ในภาษาที่พิมพ์แบบคงที่คอมไพลเลอร์จะตรวจจับข้อผิดพลาดในการเข้ารหัสใด ๆ ในการพิมพ์แบบไดนามิกคุณจะได้รับข้อยกเว้นรันไทม์ - แต่ในกรณีใด ๆ คุณจะได้รับการป้องกันจากการเขียนสตริงที่ไม่ได้เข้ารหัส สัญกรณ์ภาษาฮังการีเปลี่ยนโปรแกรมเมอร์ให้เป็นตัวตรวจสอบประเภทมนุษย์โดยเป็นงานประเภทหนึ่งที่โดยทั่วไปแล้วซอฟต์แวร์จะจัดการได้ดีกว่า

Joel แยกความแตกต่างระหว่าง "ระบบฮังการี" และ "แอปฮังการี" โดยที่ "ระบบฮังการี" เข้ารหัสประเภทในตัวเช่น int, float และอื่น ๆ และ "แอปฮังการี" เข้ารหัส "ชนิด" ซึ่งเป็นข้อมูลเมตาระดับสูงกว่า เกี่ยวกับตัวแปรตามประเภทเครื่องใน OO หรือภาษาที่ใช้งานได้สมัยใหม่คุณสามารถสร้างประเภทที่ผู้ใช้กำหนดได้ดังนั้นจึงไม่มีความแตกต่างระหว่างประเภทและ "ชนิด" ในแง่นี้ - ทั้งสองสามารถแสดงโดยระบบประเภท - และ "แอป" ฮังการีมีความซ้ำซ้อนพอ ๆ กับฮังการี "ระบบ"

ดังนั้นเพื่อตอบคำถามของคุณ: Systems Hungarianจะมีประโยชน์ในภาษาที่ไม่ปลอดภัยและพิมพ์ผิดเท่านั้นซึ่งเช่นการกำหนดค่า float ให้กับตัวแปร int จะทำให้ระบบขัดข้อง สัญกรณ์ภาษาฮังการีถูกคิดค้นขึ้นโดยเฉพาะในช่วงอายุหกสิบเศษเพื่อใช้ในBCPLซึ่งเป็นภาษาระดับต่ำที่ไม่ได้ทำการตรวจสอบประเภทใด ๆ เลย ฉันไม่คิดว่าภาษาใด ๆ ในการใช้งานทั่วไปในวันนี้มีปัญหานี้ แต่สัญกรณ์อาศัยอยู่บนเป็นชนิดของการเขียนโปรแกรมสินค้าศาสนา

แอปฮังการีจะมีเหตุผลหากคุณกำลังทำงานกับภาษาโดยไม่มีประเภทที่ผู้ใช้กำหนดเช่น VBScript เดิมหรือ VB เวอร์ชันก่อนหน้า บางทีอาจเป็น Perl และ PHP เวอร์ชันแรก ๆ อีกครั้งการใช้มันในยุคใหม่เป็นลัทธิการขนส่งสินค้าที่บริสุทธิ์

ภาษาฮังการีเป็นภาษาที่น่าเกลียดซ้ำซ้อนและเปราะบาง มันซ้ำข้อมูลรู้จักกันอยู่แล้วจากระบบการพิมพ์และคุณไม่ควรซ้ำตัวเอง ใช้ชื่อที่สื่อความหมายสำหรับตัวแปรที่อธิบายจุดประสงค์ของอินสแตนซ์เฉพาะของประเภทนี้ ใช้ระบบ type เพื่อเข้ารหัสข้อมูลที่ไม่เปลี่ยนแปลงและข้อมูลเมตาเกี่ยวกับ "ชนิด" หรือ "คลาส" ของตัวแปร - เช่น ประเภท

ประเด็นทั่วไปของบทความ Joels - การมีรหัสผิดดูผิดเป็นหลักการที่ดีมาก อย่างไรก็ตามการป้องกันจุดบกพร่องที่ดียิ่งขึ้นคือ - เมื่อเป็นไปได้ - คอมไพเลอร์จะตรวจพบรหัสผิดโดยอัตโนมัติ

ฉันมักจะใช้สัญกรณ์ภาษาฮังการีสำหรับโครงการทั้งหมดของฉัน ฉันพบว่ามันมีประโยชน์มากเมื่อต้องจัดการกับชื่อตัวระบุที่แตกต่างกันกว่า 100 ชื่อ

ตัวอย่างเช่นเมื่อฉันเรียกใช้ฟังก์ชันที่ต้องใช้สตริงฉันสามารถพิมพ์ 's' และกด control-space และ IDE ของฉันจะแสดงชื่อตัวแปรที่นำหน้าด้วย 's'

ข้อดีอีกอย่างเมื่อฉันนำหน้า u สำหรับไม่ได้ลงนามและฉันสำหรับ ints ที่ลงนามฉันจะเห็นได้ทันทีว่าฉันกำลังผสมลายเซ็นและไม่ได้ลงนามในลักษณะที่อาจเป็นอันตรายได้

ฉันจำไม่ได้ว่าจำนวนครั้งที่อยู่ในโค้ดเบส 75000 บรรทัดขนาดใหญ่จุดบกพร่องเกิดจากฉันและคนอื่น ๆ ด้วย) เนื่องจากการตั้งชื่อตัวแปรโลคัลเหมือนกับตัวแปรสมาชิกที่มีอยู่ของคลาสนั้น ตั้งแต่นั้นมาฉันมักจะนำหน้าสมาชิกด้วย "m_"

มันเป็นคำถามของรสชาติและประสบการณ์ อย่าเคาะจนกว่าคุณจะได้ลอง

คุณลืมเหตุผลอันดับหนึ่งในการรวมข้อมูลนี้ ไม่มีส่วนเกี่ยวข้องกับคุณโปรแกรมเมอร์ มีทุกอย่างที่เกี่ยวข้องกับคนที่มาตามถนน 2 หรือ 3 ปีหลังจากที่คุณออกจาก บริษัท ซึ่งต้องอ่านสิ่งนั้น

ใช่ IDE จะระบุประเภทให้คุณได้อย่างรวดเร็ว อย่างไรก็ตามเมื่อคุณอ่านโค้ด 'กฎทางธุรกิจ' แบบยาว ๆ เป็นเรื่องดีที่ไม่ต้องหยุดตัวแปรแต่ละตัวชั่วคราวเพื่อดูว่าเป็นประเภทใด เมื่อฉันเห็นสิ่งที่ต้องการ strUserID, intProduct หรือ guiProductID มันทำให้มากง่ายขึ้น 'ทางลาดขึ้นเวลา

ฉันยอมรับว่า MS ไปไกลเกินไปกับรูปแบบการตั้งชื่อของพวกเขา - ฉันจัดหมวดหมู่สิ่งนั้นไว้ในกอง "สิ่งที่ดีมากเกินไป"

หลักการตั้งชื่อเป็นสิ่งที่ดีหากคุณยึดติดกับมัน ฉันได้อ่านโค้ดเก่า ๆ มากพอที่ทำให้ฉันต้องย้อนกลับไปดูคำจำกัดความของตัวแปรที่มีชื่อคล้าย ๆ กันมากมายที่ฉันผลักดัน "ปลอกอูฐ" (ตามที่เรียกในงานก่อนหน้านี้) ตอนนี้ฉันทำงานที่มีโค้ด ASP คลาสสิกที่ไม่มีการใส่ความคิดเห็นมากมายหลายพันบรรทัดพร้อม VBScript และมันเป็นฝันร้ายที่พยายามคิดออก

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

นอกจากนี้ยังมีสถานการณ์ที่ในระหว่างการบำรุงรักษาประเภทตัวแปรจำเป็นต้องเปลี่ยน ตัวอย่าง: หากตัวแปรที่ประกาศเป็น "uint_16 u16foo" จำเป็นต้องกลายเป็น 64 บิตที่ไม่ได้ลงนามจะเกิดสิ่งใดสิ่งหนึ่งจากสองอย่าง:

1. คุณจะต้องดำเนินการและเปลี่ยนชื่อตัวแปรแต่ละตัว (อย่าลืมใส่ชื่อตัวแปรที่ไม่เกี่ยวข้องกัน) หรือ
2. เพียงแค่เปลี่ยนประเภทและไม่เปลี่ยนชื่อซึ่งจะทำให้เกิดความสับสนเท่านั้น

Joel Spolsky เขียนบล็อกโพสต์ที่ดีเกี่ยวกับเรื่องนี้ http://www.joelonsoftware.com/articles/Wrong.html โดยพื้นฐานแล้วจะไม่ทำให้โค้ดของคุณอ่านยากขึ้นเมื่อ IDE ที่เหมาะสมจะบอกว่าคุณต้องการให้พิมพ์ตัวแปรถ้าคุณจำไม่ได้ นอกจากนี้หากคุณทำให้รหัสของคุณแบ่งส่วนได้เพียงพอคุณไม่จำเป็นต้องจำว่าตัวแปรใดที่ประกาศเป็นสามหน้าขึ้นไป

ขอบเขตไม่สำคัญไปกว่าการพิมพ์ในทุกวันนี้เช่น

* l for local
* a for argument
* m for member
* g for global
* etc

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

ไม่มีเหตุผลที่คุณไม่ควรใช้สัญกรณ์ภาษาฮังการีอย่างถูกต้อง ความไม่เป็นที่นิยมเกิดจากการย้อนกลับมาเป็นเวลานานเพื่อต่อต้านการใช้สัญกรณ์ภาษาฮังการีในทางที่ผิดโดยเฉพาะใน Windows API

ในวันที่เลวร้ายก่อนที่จะมีสิ่งใดที่คล้ายกับ IDE สำหรับ DOS (โอกาสที่คุณมีหน่วยความจำว่างไม่เพียงพอที่จะเรียกใช้คอมไพเลอร์ใน Windows ดังนั้นการพัฒนาของคุณจึงเสร็จสิ้นใน DOS) คุณไม่ได้รับความช่วยเหลือจาก วางเมาส์เหนือชื่อตัวแปร (สมมติว่าคุณมีเมาส์) สิ่งที่คุณต้องจัดการคือฟังก์ชันการเรียกกลับเหตุการณ์ที่ทุกอย่างถูกส่งผ่านไปยังคุณเป็น int (WORD) 16 บิตหรือ 32 บิต (LONG WORD) จากนั้นคุณต้องแคสต์พารามิเตอร์เหล่านั้นเป็นประเภทที่เหมาะสมสำหรับประเภทเหตุการณ์ที่กำหนด ที่จริง API ส่วนใหญ่แทบจะไม่พิมพ์

ผลลัพธ์คือ API ที่มีชื่อพารามิเตอร์ดังนี้:

LRESULT CALLBACK WindowProc(HWND hwnd,
                            UINT uMsg,
                            WPARAM wParam,
                            LPARAM lParam);

โปรดทราบว่าชื่อ wParam และ lParam แม้ว่าจะดูแย่มาก แต่ก็ไม่ได้แย่ไปกว่าการตั้งชื่อ param1 และ param2

เพื่อให้เรื่องแย่ลง Window 3.0 / 3.1 มีพอยน์เตอร์สองประเภทใกล้และไกล ตัวอย่างเช่นค่าส่งคืนจากฟังก์ชันการจัดการหน่วยความจำ LocalLock เป็น PVOID แต่ค่าที่ส่งคืนจาก GlobalLock เป็น LPVOID (โดยมี 'L' เป็นเวลานาน) สัญกรณ์ที่น่ากลัวนั้นได้ขยายออกไปเพื่อให้สตริงl ong p ointer มีคำนำหน้าlpเพื่อแยกความแตกต่างจากสตริงที่เป็น malloc'd

ไม่น่าแปลกใจเลยที่มีฟันเฟืองต่อต้านสิ่งนี้

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

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

ในทางกลับกันอาจมีบางกรณีที่แม้แต่ภาษาการตรวจสอบประเภทเวลาคอมไพล์ก็จะได้รับประโยชน์จากสัญลักษณ์ฮังการี - เป็นโมฆะพอยน์เตอร์หรือHANDLEใน win32 API สิ่งเหล่านี้ทำให้ประเภทข้อมูลจริงสับสนและอาจมีประโยชน์ที่จะใช้สัญกรณ์ภาษาฮังการีที่นั่น แต่หากสามารถทราบประเภทของข้อมูลในเวลาสร้างทำไมไม่ใช้ประเภทข้อมูลที่เหมาะสม

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

ในฐานะโปรแกรมเมอร์ Python ภาษาฮังการีก็แตกสลายไปอย่างรวดเร็ว ใน Python ฉันไม่สนใจว่าบางอย่างจะเป็นสตริง - ฉันสนใจว่ามันสามารถทำหน้าที่เหมือนสตริงได้หรือไม่ (กล่าวคือหากมี___str___()วิธีที่ส่งคืนสตริง)

ตัวอย่างเช่นสมมติว่าเรามี foo เป็นจำนวนเต็ม 12

foo = 12

สัญกรณ์ภาษาฮังการีบอกเราว่าเราควรเรียกสิ่งนั้นว่า iFoo หรือบางสิ่งเพื่อแสดงว่ามันเป็นจำนวนเต็มเพื่อที่เราจะได้รู้ว่ามันคืออะไรในภายหลัง ยกเว้นใน Python ซึ่งใช้ไม่ได้หรือไม่สมเหตุสมผล ใน Python ฉันตัดสินใจว่าฉันต้องการประเภทใดเมื่อใช้งาน ฉันต้องการสตริงไหม ถ้าฉันทำอะไรแบบนี้:

print "The current value of foo is %s" % foo

สังเกต%s- สตริง Foo ไม่ใช่สตริง แต่ตัว%ดำเนินการจะเรียกfoo.___str___()และใช้ผลลัพธ์ (สมมติว่ามีอยู่) fooยังคงเป็นจำนวนเต็ม แต่เราถือว่าเป็นสตริงหากเราต้องการสตริง ถ้าเราต้องการลอยเราก็ถือว่าเป็นลูกลอย ในภาษาที่พิมพ์แบบไดนามิกเช่น Python สัญลักษณ์ภาษาฮังการีไม่มีจุดหมายเพราะไม่สำคัญว่าจะเป็นประเภทใดจนกว่าคุณจะใช้มันและหากคุณต้องการประเภทเฉพาะให้แน่ใจว่าได้ส่งเป็นประเภทนั้น (เช่นfloat(foo)) เมื่อคุณ ใช้มัน.

โปรดทราบว่าภาษาแบบไดนามิกเช่น PHP ไม่มีประโยชน์นี้ - PHP พยายามทำ 'สิ่งที่ถูกต้อง' ในพื้นหลังโดยอาศัยชุดกฎที่คลุมเครือซึ่งแทบไม่มีใครจดจำได้ซึ่งมักส่งผลให้เกิดความเสียหายอย่างคาดไม่ถึง ในกรณีนี้กลไกการตั้งชื่อบางประเภทเช่น$files_countหรือ$file_nameอาจเป็นประโยชน์

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

IDE ควรให้ข้อมูลที่เป็นประโยชน์นั้น ฮังการีอาจมีความรู้สึกบางอย่าง (ไม่มากนัก แต่มีความรู้สึกบางอย่าง) เมื่อ IDE มีความก้าวหน้าน้อยกว่ามาก

แอพภาษาฮังการีเป็นภาษากรีกสำหรับฉัน - ในทางที่ดี

ในฐานะที่เป็นวิศวกรไม่ได้เป็นโปรแกรมเมอร์ฉันทันทีเอาไปบทความของโจเอลเกี่ยวกับประโยชน์ของปพลิเคชันฮังการี: "ทำผิดรหัสดูผิด" ฉันชอบแอปภาษาฮังการีเพราะเลียนแบบวิธีที่วิศวกรรมวิทยาศาสตร์และคณิตศาสตร์แสดงสมการและสูตรโดยใช้สัญลักษณ์ย่อยและสคริปต์ขั้นสูง (เช่นตัวอักษรกรีกตัวดำเนินการทางคณิตศาสตร์ ฯลฯ ) ยกตัวอย่างเฉพาะของกฎแรงโน้มถ่วงสากลของนิวตัน : อันดับแรกในสัญกรณ์ทางคณิตศาสตร์มาตรฐานจากนั้นในรหัสเทียมของ Apps ภาษาฮังการี:

frcGravityEarthMars = G * massEarth * massMars / norm(posEarth - posMars)

ในสัญกรณ์ทางคณิตศาสตร์สัญลักษณ์ที่โดดเด่นที่สุดคือสัญลักษณ์ที่แสดงถึงชนิดของข้อมูลที่เก็บไว้ในตัวแปร: แรงมวลเวกเตอร์ตำแหน่ง ฯลฯ ตัวห้อยเล่นซอตัวที่สองเพื่อชี้แจง: ตำแหน่งของอะไร? นี่คือสิ่งที่ Apps Hungarian กำลังทำอยู่ มันจะบอกคุณถึงประเภทของสิ่งที่เก็บไว้ในตัวแปรก่อนจากนั้นจึงเข้าสู่ข้อมูลเฉพาะ - เกี่ยวกับโค้ดที่ใกล้เคียงที่สุดสามารถเข้าถึงสัญกรณ์ทางคณิตศาสตร์ได้

การพิมพ์ที่ชัดเจนอย่างชัดเจนสามารถแก้ไขตัวอย่างสตริงที่ปลอดภัยและไม่ปลอดภัยได้จากเรียงความของ Joel แต่คุณจะไม่กำหนดประเภทแยกสำหรับเวกเตอร์ตำแหน่งและความเร็ว ทั้งสองเป็นอาร์เรย์คู่ที่มีขนาดสามและสิ่งที่คุณน่าจะทำกับอาร์เรย์หนึ่งอาจนำไปใช้กับอีกอันหนึ่ง นอกจากนี้การต่อตำแหน่งและความเร็วให้เข้ากัน (เพื่อสร้างเวกเตอร์สเตต) หรือใช้ผลิตภัณฑ์ดอท แต่อาจจะไม่เพิ่มเข้าไป การพิมพ์จะอนุญาตให้สองตัวแรกและตัวที่สองห้ามได้อย่างไรและระบบดังกล่าวจะขยายไปยังทุกการดำเนินการที่คุณอาจต้องการปกป้องได้อย่างไร เว้นแต่คุณเต็มใจที่จะเข้ารหัสคณิตศาสตร์และฟิสิกส์ทั้งหมดในระบบการพิมพ์ของคุณ

ยิ่งไปกว่านั้นวิศวกรรมจำนวนมากจะทำในภาษาระดับสูงที่พิมพ์ผิดเล็กน้อยเช่น Matlab หรือภาษาเก่า ๆ เช่น Fortran 77 หรือ Ada

ดังนั้นหากคุณมีภาษาแปลก ๆ และ IDE และ Apps Hungarian ไม่ได้ช่วยให้คุณลืมมันไป - เห็นได้ชัดว่ามีคนจำนวนมาก แต่สำหรับฉันแย่กว่าโปรแกรมเมอร์มือใหม่ที่ทำงานในภาษาที่พิมพ์ผิดหรือแบบไดนามิกฉันสามารถเขียนโค้ดได้ดีขึ้นด้วย Apps Hungarian ได้เร็วกว่าที่ไม่มี

มันซ้ำซ้อนและไร้ประโยชน์อย่างไม่น่าเชื่อเป็น IDE ที่ทันสมัยที่สุดซึ่งพวกเขาทำงานได้ดีในการทำให้ประเภทชัดเจน

บวก - สำหรับฉัน - มันน่ารำคาญมากที่เห็น intI, strUserName ฯลฯ :)

หากฉันรู้สึกว่ามีการให้ข้อมูลที่เป็นประโยชน์เหตุใดฉันจึงไม่ควรใส่ข้อมูลดังกล่าวในที่ที่มีอยู่

แล้วใครจะสนว่าใครจะคิดยังไง? หากคุณพบว่ามีประโยชน์ให้ใช้สัญกรณ์

ประสบการณ์ของฉันมันไม่ดีเพราะ:

1 - จากนั้นคุณทำลายรหัสทั้งหมดหากคุณต้องการเปลี่ยนประเภทของตัวแปร (เช่นถ้าคุณต้องการขยายจำนวนเต็ม 32 บิตเป็นจำนวนเต็ม 64 บิต)

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

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

ในการทำให้รหัสผิดดูผิดของ Joel Spolskyเขาอธิบายว่าสิ่งที่ทุกคนคิดว่าเป็นสัญลักษณ์ของฮังการี (ซึ่งเขาเรียกว่าระบบฮังการี) ไม่ใช่สิ่งที่ตั้งใจให้เป็นจริง ๆ (สิ่งที่เขาเรียกว่า Apps Hungarian) เลื่อนลงไปที่หัวข้อI'm Hungaryเพื่อดูการสนทนานี้

โดยพื้นฐานแล้ว Systems Hungarian นั้นไร้ค่า มันบอกคุณในสิ่งเดียวกับที่คอมไพเลอร์และ / หรือ IDE ของคุณจะบอกคุณ

แอพภาษาฮังการีจะบอกคุณว่าตัวแปรควรหมายถึงอะไรและสามารถมีประโยชน์ได้จริง

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

เป็นรูปแบบที่มีประโยชน์สำหรับการตั้งชื่อตัวควบคุมบนฟอร์ม (btnOK, txtLastName เป็นต้น) หากรายการตัวควบคุมปรากฏในรายการแบบเลื่อนลงตามตัวอักษรใน IDE ของคุณ

ฉันมักจะใช้สัญกรณ์ฮังการีกับเซิร์ฟเวอร์ ASP.NET เท่านั้นมิฉะนั้นฉันจะพบว่ามันยากเกินไปที่จะตรวจสอบว่าการควบคุมคืออะไรในแบบฟอร์ม

ใช้ข้อมูลโค้ดนี้:

<asp:Label ID="lblFirstName" runat="server" Text="First Name" />
<asp:TextBox ID="txtFirstName" runat="server" />
<asp:RequiredFieldValidator ID="rfvFirstName" runat="server" ... />

หากมีใครสามารถแสดงวิธีที่ดีกว่าในการมีชื่อควบคุมชุดนั้นโดยไม่ใช้ภาษาฮังการีฉันก็อยากจะย้ายไปที่ชื่อนี้

บทความของ Joel นั้นยอดเยี่ยม แต่ดูเหมือนว่าจะละเลยประเด็นสำคัญประการหนึ่ง:

ฮังการีสร้าง 'ความคิด' เฉพาะ (ชนิด + ชื่อตัวระบุ) ที่ไม่ซ้ำกันหรือใกล้เคียงกับที่ไม่ซ้ำกันใน codebase - แม้แต่ codebase ที่มีขนาดใหญ่มาก

เป็นเรื่องใหญ่สำหรับการบำรุงรักษาโค้ด หมายความว่าคุณสามารถใช้ 'การค้นหาข้อความบรรทัดเดียว' ที่ดี (grep, findstr, 'find in all files') เพื่อค้นหาทุกคำที่กล่าวถึง 'แนวคิด' นั้น

เหตุใดจึงสำคัญเมื่อเรามี IDE ที่รู้วิธีอ่านโค้ด เพราะยังไม่ค่อยเก่ง สิ่งนี้ยากที่จะเห็นในโค้ดเบสขนาดเล็ก แต่ชัดเจนในโค้ดขนาดใหญ่เมื่อมีการกล่าวถึง 'ไอเดีย' ในความคิดเห็นไฟล์ XML สคริปต์ Perl และในตำแหน่งภายนอกการควบคุมซอร์ส (เอกสารวิกิฐานข้อมูลบั๊ก)

คุณต้องระมัดระวังเล็กน้อยในที่นี้เช่นการวางโทเค็นในมาโคร C / C ++ สามารถซ่อนการกล่าวถึงของตัวระบุได้ กรณีดังกล่าวสามารถจัดการได้โดยใช้รูปแบบการเข้ารหัสและอย่างไรก็ตามพวกเขามักจะส่งผลกระทบต่อตัวระบุเพียงเล็กน้อยใน codebase

ป.ล. ในประเด็นเกี่ยวกับการใช้ระบบ type เทียบกับฮังการี - ควรใช้ทั้งสองอย่าง คุณต้องใช้รหัสผิดเท่านั้นถึงจะดูผิดถ้าคอมไพเลอร์ไม่จับมันให้คุณ มีหลายกรณีที่ไม่สามารถทำให้คอมไพเลอร์จับได้ แต่ที่เป็นไปได้ - ใช่โปรดทำแทน!

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

หักล้างประโยชน์ของสัญกรณ์ฮังการี

• เป็นวิธีการแยกแยะตัวแปร

หากประเภทคือทั้งหมดที่แยกความแตกต่างของค่าหนึ่งจากอีกประเภทหนึ่งก็สามารถใช้สำหรับการแปลงประเภทหนึ่งไปเป็นอีกประเภทหนึ่งเท่านั้น หากคุณมีค่าเดียวกันที่กำลังถูกแปลงระหว่างประเภทมีโอกาสที่คุณจะทำสิ่งนี้ในฟังก์ชันเฉพาะสำหรับการแปลง (ฉันเคยเห็น VB6 ที่เหลือในฮังการีใช้สตริงกับพารามิเตอร์วิธีการทั้งหมดของพวกเขาเพียงเพราะพวกเขาไม่สามารถหาวิธีการแยกซีเรียลไลซ์อ็อบเจ็กต์ JSON หรือเข้าใจวิธีการประกาศหรือใช้ประเภท nullable ได้อย่างถูกต้อง ) หากคุณมีสองตัวแปรที่แตกต่างกันโดยเฉพาะ คำนำหน้าภาษาฮังการีและไม่ใช่การเปลี่ยนใจเลื่อมใสจากคนหนึ่งไปเป็นอีกคนหนึ่งดังนั้นคุณต้องอธิบายความตั้งใจของคุณกับพวกเขาอย่างละเอียด

• ทำให้โค้ดอ่านง่ายขึ้น

ฉันพบว่าสัญกรณ์ภาษาฮังการีทำให้คนขี้เกียจกับชื่อตัวแปร พวกเขามีบางอย่างที่จะแยกแยะได้โดยและพวกเขาไม่จำเป็นต้องอธิบายให้ละเอียดเพื่อวัตถุประสงค์ของมัน นี่คือสิ่งที่คุณมักจะพบในโค้ดที่มีสัญลักษณ์ของฮังการีเทียบกับ modern: sSQL กับ groupSelectSql ( หรือโดยปกติแล้วจะไม่มี sSQL เลยเพราะพวกเขาควรจะใช้ ORM ที่นักพัฒนารุ่นก่อนหน้านี้ใส่ไว้ ), sValue เทียบกับ formCollectionValue ( หรือโดยปกติจะไม่มี sValue ด้วยเพราะมันอยู่ใน MVC และควรใช้คุณสมบัติการผูกโมเดล ), sType เทียบกับ publishedSource เป็นต้น

ไม่สามารถอ่านได้ ฉันเห็น sTemp1, sTemp2 ... sTempN เพิ่มเติมจาก VB6 ที่เหลืออยู่ในฮังการีมากกว่าทุกคนที่รวมกัน

• ป้องกันข้อผิดพลาด

นี่จะเป็นโดยอาศัยหมายเลข 2 ซึ่งเป็นเท็จ

ในคำพูดของอาจารย์:

http://www.joelonsoftware.com/articles/Wrong.html

การอ่านที่น่าสนใจตามปกติ

สารสกัดจาก:

"มีใครบางคนอ่านกระดาษของ Simonyi ซึ่งเขาใช้คำว่า" type "และคิดว่าเขาหมายถึงประเภทเช่นคลาสเหมือนในระบบ type เหมือนกับการตรวจสอบ type ที่คอมไพเลอร์ทำเขาไม่ได้อธิบายอย่างระมัดระวัง สิ่งที่เขาหมายถึงโดยคำว่า“ ประเภท” แต่มันไม่ได้ช่วยอะไรเสียหาย”

"แต่ Apps Hungarian ยังมีมูลค่ามหาศาลเพราะมันเพิ่มการจัดระเบียบในโค้ดซึ่งทำให้โค้ดอ่านเขียนแก้ไขข้อบกพร่องและดูแลรักษาได้ง่ายขึ้นและที่สำคัญที่สุดคือทำให้โค้ดผิดดูผิด"

ตรวจสอบให้แน่ใจว่าคุณมีเวลาพอสมควรก่อนที่จะอ่าน Joel On Software :)

เหตุผลหลายประการ:

• IDE ที่ทันสมัยใด ๆ จะให้ประเภทตัวแปรแก่คุณเพียงแค่วางเมาส์เหนือตัวแปร
• ชื่อประเภทส่วนใหญ่มีความยาว (คิดว่าHttpClientRequestProvider ) เพื่อใช้เป็นคำนำหน้าอย่างสมเหตุสมผล
• ข้อมูลประเภทไม่มีข้อมูลที่ถูกต้องเป็นเพียงการถอดความการประกาศตัวแปรแทนที่จะสรุปวัตถุประสงค์ของตัวแปร (คิดว่าmyIntegerเทียบกับpageSize )

ฉันไม่คิดว่าทุกคนจะต่อต้านมันอย่างบ้าคลั่ง ในภาษาที่ไม่มีประเภทคงที่มันมีประโยชน์มาก ฉันชอบมันมากเมื่อใช้เพื่อให้ข้อมูลที่ไม่มีอยู่ในประเภท เช่นเดียวกับใน C char * szNameกล่าวว่าตัวแปรจะอ้างถึงสตริงที่สิ้นสุดด้วยค่าว่างซึ่งไม่ได้หมายถึง char * - แน่นอนว่า typedef ก็ช่วยได้เช่นกัน

Joel มีบทความดีๆเกี่ยวกับการใช้ภาษาฮังการีเพื่อบอกว่าตัวแปรนั้นเข้ารหัส HTML หรือไม่:

http://www.joelonsoftware.com/articles/Wrong.html

อย่างไรก็ตามฉันมักจะไม่ชอบภาษาฮังการีเมื่อมันใช้เพื่อให้ข้อมูลที่ฉันรู้อยู่แล้ว

แน่นอนเมื่อ 99% ของโปรแกรมเมอร์เห็นด้วยกับบางสิ่งมีบางอย่างผิดปกติ เหตุผลที่พวกเขาเห็นด้วยที่นี่เป็นเพราะพวกเขาส่วนใหญ่ไม่เคยใช้สัญกรณ์ภาษาฮังการีอย่างถูกต้อง

สำหรับการโต้แย้งโดยละเอียดฉันขอแนะนำให้คุณอ่านบล็อกโพสต์ที่ฉันสร้างไว้ในหัวข้อนี้

http://codingthriller.blogspot.com/2007/11/rediscovering-hungarian-notation.html

ฉันเริ่มเขียนโค้ดในช่วงเวลาที่มีการคิดค้นสัญกรณ์ภาษาฮังการีและเป็นครั้งแรกที่ฉันถูกบังคับให้ใช้มันในโครงการที่ฉันเกลียดมัน

หลังจากนั้นไม่นานฉันก็รู้ว่าเมื่อมันทำอย่างถูกต้องมันช่วยได้จริงและทุกวันนี้ฉันก็รักมัน

แต่เช่นเดียวกับทุกสิ่งที่ดีจะต้องมีการเรียนรู้และเข้าใจและการทำอย่างถูกต้องต้องใช้เวลา

สัญลักษณ์ภาษาฮังการีถูกใช้ในทางที่ผิดโดยเฉพาะอย่างยิ่งโดย Microsoft ซึ่งนำไปสู่คำนำหน้ายาวกว่าชื่อตัวแปรและแสดงว่าค่อนข้างเข้มงวดโดยเฉพาะอย่างยิ่งเมื่อคุณเปลี่ยนประเภท (lparam / wparam ที่น่าอับอายประเภท / ขนาดที่แตกต่างกันใน Win16 เหมือนกันใน Win32 )

ด้วยเหตุนี้ทั้งเนื่องจากการละเมิดนี้และการใช้ M $ จึงถูกทำให้ไร้ประโยชน์

ในที่ทำงานของฉันเราเขียนโค้ดใน Java แต่ผู้ก่อตั้งชื่อมาจาก MFC world ดังนั้นให้ใช้รูปแบบรหัสที่คล้ายกัน (วงเล็บปีกกาฉันชอบสิ่งนี้! ตัวพิมพ์ใหญ่เป็นชื่อเมธอดฉันคุ้นเคยกับคำนำหน้าเช่น m_ ถึงสมาชิกคลาส (ฟิลด์ ), s_ ถึงสมาชิกแบบคงที่ ฯลฯ )

และพวกเขากล่าวว่าตัวแปรทั้งหมดควรมีคำนำหน้าแสดงประเภทของมัน (เช่น BufferedReader ชื่อ brData) ซึ่งแสดงว่าเป็นความคิดที่ไม่ดีเนื่องจากประเภทสามารถเปลี่ยนแปลงได้ แต่ชื่อไม่เป็นไปตามนั้นหรือตัวเข้ารหัสไม่สอดคล้องกันในการใช้คำนำหน้าเหล่านี้ (ฉันเห็น aBuffer, theProxy ฯลฯ !)

โดยส่วนตัวแล้วฉันเลือกคำนำหน้าสองสามคำที่ฉันคิดว่ามีประโยชน์สิ่งที่สำคัญที่สุดคือ b ในการนำหน้าตัวแปรบูลีนเนื่องจากเป็นตัวแปรเดียวที่ฉันอนุญาตให้ใช้ไวยากรณ์เช่นif (bVar)(ไม่มีการใช้ autocast ของค่าบางค่าเป็นจริงหรือเท็จ) เมื่อฉันเขียนโค้ดด้วย C ฉันใช้คำนำหน้าสำหรับตัวแปรที่จัดสรรด้วย malloc เพื่อเป็นการเตือนความจำว่าควรจะปล่อยในภายหลัง เป็นต้น

โดยพื้นฐานแล้วฉันไม่ปฏิเสธสัญกรณ์นี้โดยรวม แต่ใช้สิ่งที่ดูเหมือนว่าเหมาะกับความต้องการของฉัน
และแน่นอนเมื่อมีส่วนร่วมในโครงการบางอย่าง (งานโอเพ่นซอร์ส) ฉันก็แค่ใช้การประชุมแทน!