มันเป็นการปฏิบัติที่ไม่ถูกต้องหรือไม่ที่จะตั้งชื่อตัวแปรที่ไม่ได้ใช้ด้วยการขีดเส้นใต้เดี่ยว?

_บ่อยครั้งเมื่อไวยากรณ์ของภาษาต้องการให้ฉันชื่อตัวแปรที่ไม่เคยใช้ผมจะตั้งชื่อมันว่า

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

ตัวอย่างทั่วไปที่ฉันทำคือการตั้งชื่อแบบสอบถามย่อยใน SQL

SELECT *
FROM
(
    SELECT *
    FROM TableA
    JOIN TableB
        ON TableA.ColumnB = TableB.ColumnB
    WHERE [ColumnA] > 10
) _ --This name is required, but never used here
ORDER BY ColumnC

อีกตัวอย่างหนึ่งคือตัวแปรลูปที่ไม่ได้ใช้

array = [[] for _ in range(n)] # Defines a list of n empty lists in Python

ฉันใช้เทคนิคนี้มากเท่าที่จำเป็นเท่านั้นเมื่อฉันรู้สึกว่าชื่อที่สื่อความหมายเพิ่มอะไรลงไปในโค้ดและในบางแง่มุมนั้นนำไปใช้โดยการเพิ่มชื่อที่ต้องจำเพิ่มเติม ในบางวิธีฉันดูคล้ายกับvarคำหลักใน C # ซึ่งฉันใช้เท่าที่จำเป็น

เพื่อนร่วมงานของฉันไม่เห็นด้วย พวกเขากล่าวว่าแม้จะมีเพียงครั้งเดียว (ตัวอักษร) _ชื่อตัวละครจะดีกว่า

ฉันผิดหรือเปล่า? การปฏิบัติเช่นนี้ไม่ดีหรือไม่?

ชื่อทั้งหมดควรมีความหมาย หาก_เป็นมาตรฐานที่รู้จักกันดีใน บริษัท ของคุณหรือในชุมชนที่กว้างขึ้นก็จะมีความหมายว่า "ชื่อที่ไม่สำคัญ" ถ้าไม่ใช่ฉันก็จะบอกว่ามันเป็นการฝึกฝนที่ไม่ดี ใช้ชื่อที่สื่อความหมายสำหรับสิ่งที่คุณอ้างถึงโดยเฉพาะอย่างยิ่งเนื่องจากชื่ออาจมีความสำคัญในอนาคต

ฉันจะบอกว่ามันเป็นแนวปฏิบัติที่ยอมรับได้ นี่เป็นตัวอย่างที่หายากที่ฉันจะถือว่าคนส่วนใหญ่ผิดและต้องการปรับปรุงความรู้เกี่ยวกับแนวคิดการเขียนโปรแกรมล่าสุด ในหลาย ๆ ภาษาโดยเฉพาะอย่างยิ่งภาษาทำงานที่ใช้ ML เช่น Haskell และ OCaml เป็นเรื่องธรรมดามากที่จะใช้_เป็นตัวแปร "ไม่ได้ใช้" แม้แต่ Lua ซึ่งไม่ได้ให้การสนับสนุนด้านภาษาอย่างชัดเจน แต่ก็สนับสนุนให้ใช้_เป็นตัวยึดตำแหน่งตามแบบแผน

หลายภาษา (Haskell, Lua และ DI คิดว่าอยู่ด้านบนสุดของหัวของฉัน) นอกจากนี้ยังมีการประชุมที่มีตัวแปรที่นำไปสู่การขีดเส้นใต้ไม่ได้สร้างคำเตือนคอมไพเลอร์เกี่ยวกับ "ตัวแปรท้องถิ่นที่ไม่ได้ใช้" ซึ่งทำให้_ชื่อตัวแปร คุณสามารถใช้สิ่งที่ชอบ_unusedแต่ฉันเห็นด้วยกับคุณว่ามันทำให้เกิดความยุ่งเหยิง

ใน Python _นั้นยอมรับได้อย่างแน่นอน อย่างไรก็ตามสามารถขัดแย้งกับgettextนามแฝง _()ได้

การประชุมร่วมกันอื่น ๆ ที่มีdummy, unused; คนเดียวหรือเป็นคำนำหน้า

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

• PyLintสำหรับ_หรือdummy
• PyDevตัวแปรใด ๆ ที่เริ่มต้นด้วย_, unusedหรือdummy

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

ภาษาการเขียนโปรแกรมบางภาษา (เช่น Haskell) แม้จะมีตัวระบุ 'พิเศษ' นี้อยู่ในรูปแบบไวยากรณ์สำหรับจุดประสงค์ที่คุณพูดถึง

ระวัง _ มีความหมายที่แท้จริงในบางภาษาแล้ว

ใน Python:

9.6 ตัวแปรส่วนตัวและการอ้างอิงระดับท้องถิ่น

ป้อนคำอธิบายลิงก์ที่นี่ตัวแปรส่วนบุคคล“ ส่วนตัว” ที่ไม่สามารถเข้าถึงได้ยกเว้นจากภายในวัตถุไม่มีอยู่ใน Python อย่างไรก็ตามมีการประชุมที่ตามด้วยรหัส Python ส่วนใหญ่: ชื่อที่นำหน้าด้วยเครื่องหมายขีดล่าง (เช่น _spam) ควรได้รับการปฏิบัติเสมือนเป็นส่วนที่ไม่เปิดเผยต่อสาธารณะของ API (ไม่ว่าจะเป็นฟังก์ชันวิธีการหรือสมาชิกข้อมูล) . ควรพิจารณารายละเอียดการดำเนินการและอาจมีการเปลี่ยนแปลงโดยไม่ต้องแจ้งให้ทราบล่วงหน้า

นอกจากนี้ยังมีการพูดถึงอีกอย่างใน PEP 8 (คู่มือสไตล์สำหรับ Python Code):

อธิบาย: รูปแบบการตั้งชื่อ

_single_leading_underscore: ตัวบ่งชี้ "การใช้ภายใน" อ่อน เช่นจากการนำเข้า M * ไม่นำเข้าวัตถุที่มีชื่อขึ้นต้นด้วยเครื่องหมายขีดล่าง

ใน C #:

โดยทั่วไปจะใช้เพื่อทำเครื่องหมายตัวแปรส่วนตัวที่มีคุณสมบัติสาธารณะ / ภายใน แต่การปฏิบัติโดยทั่วไปมักจะดูถูกในวันนี้

ใน JavaScript:

มีไลบรารีชื่อ underscore.js ที่ใช้ขีดล่างเป็นส่วนนำหน้าสำหรับส่วนขยายต้นแบบที่ไม่ได้มาตรฐาน

ตัวอย่าง:

var object = { some:'stuff' };
var newObject = _.clone(object);

ซึ่งทำให้ฉันถึงจุดของฉัน เกิดอะไรขึ้นกับแบบแผนตัวแปรตัวยึดตำแหน่งแบบคลาสสิค

var i, j, k, l; // iterator placeholders
var x, y, z, xx, yy, zz // value placeholders
var foo, bar, bas, fixx, buzz, qux, etc... // demonstration placeholders

เหตุใดจึงใช้การประชุมที่กำหนดเองซึ่งบางคนอาจตีความผิดเมื่อมีการประชุมทั่วไปจำนวนมากที่มีอยู่แล้ว

ฉันใช้ "หุ่นจำลอง" สำหรับสิ่งนั้น หรือ "อึ" ถ้าฉันแค่ทดสอบอะไรบางอย่าง :) ตั้งชื่อตัวแปรของคุณเพื่ออธิบายสิ่งที่พวกเขา หากพวกเขาเป็นคนบ้า ๆ บอ ๆ ตัวแปรที่ไม่ได้ใช้ให้ตั้งชื่อพวกมันว่า

ฉันคิดว่ามันเป็นการปฏิบัติที่ไม่ดีเพราะ

• คุณไม่ควรมีตัวแปรที่มองไม่เห็นในรหัสของคุณ หากคุณรู้สึกว่าควรพูดคุยถึงเหตุผล

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

(ฉันไม่รู้ Python: สิ่งนี้จำเป็นสำหรับการสร้างหรือไม่)

มันอาจจะถูกต้องทางไวยากรณ์และมันอาจจะตกลงเป็นส่วนหนึ่งของมาตรฐาน

ด้วยที่กล่าวว่ามันเป็นสิ่งที่ฉันจะขอให้ใครบางคนในการเปลี่ยนแปลงรหัสตรวจ ฉันจะไม่ใส่ลงในมาตรฐานการเข้ารหัสและจะพยายามลบออกจากที่มีอยู่ อ่านยากกว่าและไม่มีความหมายมากนัก

ฉันคิดว่ามันผิดเพราะ:

1) ยากกว่าที่จะเห็นเนื่องจากมีจำนวนพิกเซลไม่มาก

2) หากมีมากกว่าหนึ่ง_คุณจะรู้ได้อย่างไรที่หนึ่ง - หรือว่าผู้พัฒนาใหม่ได้ 'ปฏิบัติตามกฎ' และทำให้การใช้งานของพวกเขาในขอบเขตมาก?

3) เป็นการฝึกฝนที่ไม่เป็นประโยชน์ การใช้ชื่อตัวแปรตัวอักษรเดียวเป็นโรงเรียนเก่า (เช่นการศึกษาดั้งเดิมของฉัน!) ฉันจะเห็นพวกเขา ... จากนั้นดูความคิดเห็นที่เพิ่มเข้ามาเพื่อบอกว่าโค้ดทำอะไรได้บ้างและนั่นเป็นวิธีปฏิบัติที่ไม่ดีในโลกปัจจุบัน ฉันใช้ชื่อตัวแปรแบบยาวมากที่สุดเท่าที่จะเป็นไปได้เพื่อให้ทุกคนโดยไม่คำนึงถึงระดับการเขียนโปรแกรมหรือความคุ้นเคยกับรหัสเพียงแค่ "อ่าน" เกือบจะเหมือนภาษาอังกฤษ การใช้ชื่อตัวอักษร 1 ตัวเป็นการใช้งานร่วมกันอย่างมากกับรหัสที่เก่ากว่าและกับโปรแกรมเมอร์ที่มีอายุมากกว่า (รวมถึงฉันด้วย) แต่นั่นก็ไม่ได้ทำให้มันดี

เพื่อหลีกเลี่ยงการชนของเนมสเปซและอนุญาตให้ทำการดีบั๊กในกรณีที่ชื่อตัวแปรเป็นเงื่อนงำเดียวของคุณมันอาจจะดีกว่าถ้าเรียกว่า

แรงบันดาลใจจาก Birfl

ใช่มันเป็นการปฏิบัติที่ไม่ดีด้วยเหตุผลสองประการ:

1. คำนำหน้าตัวแปรที่ไม่ได้ใช้กับเครื่องหมายขีดล่างไม่ใช่มาตรฐานที่ยอมรับกันอย่างแพร่หลาย มันอาจจะถูกละเว้น "ไม่ได้ฝึกหัด"
2. ฉันเห็นบางคนนำหน้าตัวแปรสมาชิกส่วนตัวด้วยการขีดเส้นใต้และมาตรฐานของคุณจะทำให้คนเหล่านี้สับสนอย่างมาก

สิ่งที่คุณพยายามทำคือการเขียนโค้ดใน SQL เวอร์ชันที่ดีกว่าซึ่งไม่มีปัญหาในการบังคับให้คุณประดิษฐ์ชื่อสำหรับสิ่งที่ไร้ประโยชน์

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

แต่คุณไม่ได้อยู่ในภาษาอื่นและสิ่งที่คุณกำลังทำไม่ใช่วิธีที่สะอาดในการสร้างส่วนขยายภาษา

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

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

สิ่งนี้จะไม่ดีใน Perl ซึ่งใช้ $ _ (และบางครั้ง _) เป็นตัวแปรพิเศษ

โดยทั่วไปแล้วฉันจะอยู่ห่างจากมันเพียงเพราะ _ ดูเหมือนว่าจะเป็นภาษาที่เฉพาะเจาะจง หากฉันเห็นรหัสของคุณฉันจะอยู่ในเอกสารเพื่อค้นหาสิ่งที่ _ เป็นจนกว่าฉันจะรู้ว่ามันเป็นเพียงหุ่นจำลอง ไม่มีอะไรผิดปกติกับ DUMMY, $ DUMMY อะไรก็ตาม

ฉันจะหลีกเลี่ยงการขีดล่างในช่วงต้นของ vars เว้นแต่คุณจะแน่ใจว่าพวกเขาไม่ได้มีแนวโน้มที่จะระบุสิ่งอื่นใดในภาษาหรือกรอบการทำงานที่กำหนดในการใช้งานหนัก ตัวอย่างเช่นใน Python ขีดเส้นใต้คู่มีแนวโน้มที่จะบ่งบอกถึงความมหัศจรรย์ของเวทมนตร์ ใน JQuery และไลบรารี JS อื่น ๆ ขีดเส้นใต้เดียวมีแนวโน้มที่จะระบุ var ทางเลือกสำหรับการเขียนทับ namespace นอกจากนี้ยังเป็นรูปแบบการตั้งชื่อยอดนิยมสำหรับไฟล์รวมซึ่งมักจะนำไปสู่รหัสที่จัดการรวมอยู่ในรูปแบบ var