IntroductionSource code is a form o

Introduction
Source code is a form of expression and so quality-of-expression must be a primary concern. Poor
quality-of-expression creates ongoing costs and impacts the productivity (hence the reputation) of the
team that produces it. Therefore software authors must learn to clearly express the intention of
variables, methods, classes, and modules.
Furthermore, maintenance errors occur when a programmer does not correctly understand the code he
must modify. The diligent programmer may expend considerable effort to accurately decipher the true
intent of a program, even though its purpose was obvious to the original author. Indeed, it takes much
more time to determine how to change the code than to make and test the change.
Some efforts to improve maintainability of code have actually exacerbated the problem by making
names less intuitive, less obvious, and less natural. They make it easier to glean the information that
was not lost (like type information and scope, still present in variable declarations), without making it
easier to discover the more important information that was lost.
An expressive name for a software object must be clear, precise, and small. This is a guide to better
clarity, precision, and terseness in naming. It is the author's hope that you will find it useful.
Use Intention-revealing Names
We often see comments used where better naming would be appropriate:
int d; // elapsed time in days
Such a comment is an excuse for not using a better variable name. The name 'd' doesn't evoke a sense
of time, nor does the comment describe what time interval it represents. It requires a change:
int elapsedTimeInDays;
int daysSinceCreation;
int daysSinceModification;
int fileAgeInDays;

The simple act of using a better name instead of applying a better comment can reduce the difficulty of
working with the code we write.
What is the purpose of this python code?
list1 = []
for x in theList:
if x[0] == 4:
list1 += x;
return list1

Why is it hard to tell what this code is doing? Clearly there are no complex expressions. Spacing and
indentation are reasonable. There are only three variables and two constants mentioned at all. There
aren't even any fancy classes or overloaded operators, just a list of lists (or so it seems).
The problem isn't the simplicity of the code but the implicity of the code: the degree to which the
context is not explicit in the code itself. The code requires me to answer questions such as:
● What kinds of things are in theList?
● What is the significance of the zeroeth subscript of an item in theList?
● What is the significance of the value 4?
● How would I use the list being returned?
This information is not present in the code sample, but it could have been. Say that we're working in a
mine sweeper game. We find that the board is a list of cells called theList. Let's rename that to
theBoard.
Each cell on the board is represented by a simple array. We further find that the zeroeth subscript is the
location of a status value, and that a status value of 4 means 'flagged'. Just by giving these concepts
names we can improve the code considerably:
flaggedCells = []
for cell in theBoard:
if cell[STATUS_VALUE] == FLAGGED:
flaggedCells += cell
return flaggedCells

Notice that the simplicity of the code is not changed. It still has exactly the same number of operators
and constants, with exactly the same number of nesting levels.
We can go further and write a simple class for cells instead of using an array of ints. The expression
used to check that a cell has been flagged can be renamed by adding an intention-revealing function
(call it isFlagged) to hide the magic numbers. It results in a new version of the function:
flaggedCells = []
for cell in theBoard:
if cell.isFlagged():
flaggedCells += cell
return flaggedCells

or more tersely:
return [ cell for cell in theBoard if cell.isFlagged() ]

Even with the function collapsed to a list comprehension, it's not difficult to understand. My original
four questions are answered fully, and the implicity of the code is reduced. This is the power of
naming.
999999999999999Avoid Disinformation
A software author must avoid leaving false clues which obscure the meaning of code.
We should avoid words whose entrenched meanings vary from our intended meaning. For example,
"hp", "aix", and "sco" would be poor variable names because they are the names of Unix platforms
or variants. Even if you are coding a hypotenuse and "hp" looks like a good abbreviation, it is
disinformative.
Do not refer to a grouping of accounts as an AccountList unless it's actually a list. The word
list means something specific to CS people. If the container holding the accounts is not actually a
list, it may lead to false conclusions. AccountGroup or BunchOfAccounts would have been
better.
Beware of using names which vary in small ways. How long does it take to spot the subtle difference
between a XYZControllerForEfficientHandlingOfStrings in one module and,
somewhere a little more distant XYZControllerForEfficientStorageOfStrings? The
words have frightfully similar shape.
With modern Java environments, you have automatic code completion. You will write a few characters
of a name and press some hot key combination (if that) and you will be greeted with a list of possible
completions for that name. It is nice if names for very similar things sort together alphabetically, and if
the differences are very, very obvious since the developer is likely to pick an object by name without
seeing your copious comments or even the list of methods supplied by that class.
A truly awful example of dis-informative names would be the use of lower-case L or uppercase o as
variable names, especially in combination. The problem, of course is that they look almost entirely like
the constants one and zero (respectively).
int a = l;
if ( O = l )
a = O1;
else
l = 01;
The reader may think this a contrivance, but the author has examined code where such things were
abundant. It's a great technique for shrouding code. The author of the code suggested using a different
font so that the differences were more obvious, a solution that would have to be passed down to all
future developers as oral tradition or in a written document. The problem is conquered with finality and
without creating new work products if an author performs a simple renaming.
Make Meaningful Distinctions
A problem arises from writing code solely to satisfy a compiler or interpreter. One can't have the same
name referring to two things in the same scope, so one name is changed them in an arbitrary way.
Sometimes this is done by misspelling one, leading to the surprising situation where correcting spelling
errors leads to an inability to compile.
It is not sufficient to add number series or noise words, even though the compiler is satisfied. If names
must be different, then they should also mean something different.
Number-series naming (a1, a2, .. aN) is the opposite of intentional naming. Without being
disinformative, number series names provide no clue to the intention of the author. Naming by
intention and by domain may lend one to use names like lvalue and rvalue or source and
destination rather than string1 and string2.
Noise words are another meaningless distinction. Imagine that you have a Product class. If you have
another called ProductInfo or ProductData, you have made the names different without making
them mean anything different. Info and Data are indistinct noise words like "a", "an" and "the".
Noise words are redundant. The word variable should never appear in a variable name. The word
table should never appear in a table name. How is NameString better than Name? Would a Name
ever be a floating point number? If so, it breaks an earlier rule about disinformation. Imagine finding
one class named Customer and another named CustomerObject, what should you understand as the
distinction? Which one will represent the best path to a customer's payment history?
There is an application I know of where this is illustrated. I've changed the names to protect the guilty,
but the exact form of the error is:
getSomething();
getSomethings();
getSomethingInfo();
Consider context. In the absence of a class named Denomination, MoneyAmount is no better than
money. CustomerInfo is no better than Customer.
Disambiguate in such a way that the reader knows what the different versions offer her, instead of
merely that they're different.
Use Pronounceable Names
If you can't pronounce it, you can't discuss it without sounding like an idiot. "Well, over here on the bee
cee arr three cee enn tee we have a pee ess zee kyew int, see?" This matters because programming is a
social activity.
A company I know has genymdhms (generation date, year, month, day, hour, minute and second) so
they walked around saying "gen why emm dee aich emm ess". I have an annoying habit of pronouncing
everything as-written, so I started saying "gen-yah-mudda-hims". It later was being called this by a host
of designers and analysts, and we still sounded silly. But we were in on the joke, so it was fun. Fun or
not, we were tolerating poor naming. New developers had to have the variables explained to them, and
then they spoke about it in silly made-up words instead of using proper English terms.
class DtaRcrd102 {
private Date genymdhms;
private Date modymdhms;
private final String pszqint = "102";
/* ... */
};

class Customer {
private Date generationTimestamp;
private Date modificationTimestamp;;
private final String recordId = "102";
/* ... */
};

Intelligent conversation is now possible:"Hey, Mikey, take a look at this record! The generation
timestamp is set to tomorrow's date! How can that be?"
Use Searchable Names
Single-letter names and numeric constants have a particular problem in that they are not easy to locate
across a body of text.
One might easily grep for MAX_CLASSES_PER_STUDENT but the number 7 could be more
troublesome. Searche

ผลลัพธ์ (ไทย) 1:

แนะนำรหัสแหล่งที่มาเป็นรูปแบบของนิพจน์ และดังนั้นคุณภาพของนิพจน์ต้องเป็นกังวลหลัก ไม่ดีคุณภาพของนิพจน์ที่สร้างต้นทุนอย่างต่อเนื่อง และส่งผลกระทบต่อประสิทธิผล (ดังนั้นชื่อเสียง) ของการกลุ่มคนที่สร้างมัน ดังนั้น ผู้เขียนซอฟต์แวร์ต้องเรียนรู้การแสดงเจตนาชัดเจนตัวแปร วิธี สอน และโมดูลนอกจากนี้ บำรุงข้อผิดพลาดเกิดขึ้นเมื่อโปรแกรมเมอร์ไม่ถูกเข้าใจรหัสเขาต้องปรับเปลี่ยน โปรแกรมเมอร์ที่ขยันอาจสอยมากพยายามถอดรหัสที่ถูกต้องจุดประสงค์ของโปรแกรม แม้ว่าวัตถุประสงค์ชัดเจนเพื่อผู้เขียนต้นฉบับ แน่นอน มันใช้เวลามากเวลาเพิ่มเติมเพื่อกำหนดวิธีการเปลี่ยนรหัสการตรวจ และทดสอบการเปลี่ยนแปลงบางส่วนพยายามที่ปรับปรุง maintainability รหัสมีจริงเลวร้ายปัญหาโดยชื่อธรรมชาติน้อยง่าย ไม่ชัดเจน และน้อยกว่า พวกเขาทำให้ง่ายต่อการรวบรวมข้อมูลที่ได้ไม่แพ้ (เช่นข้อมูลชนิดและขอบเขต ยังคงมีอยู่ในประกาศตัวแปร), ไม่ทำให้ง่ายต่อการค้นพบข้อมูลสำคัญที่หายไปชื่อการแสดงออกสำหรับวัตถุซอฟต์แวร์ต้องชัดเจน แม่นยำ และขนาดเล็ก นี้คือคำแนะนำจะดีกว่าความชัดเจน ความแม่นยำ และ terseness ในการตั้งชื่อ จึงหวังว่าผู้ที่คุณจะพบว่ามีประโยชน์ใช้ชื่อที่เปิดเผยความตั้งใจเรามักจะเห็นข้อคิดเห็นในการใช้ที่ดี ตั้งชื่อน่าจะเหมาะสม: int d วันเวลาผ่านไปความคิดเห็นเป็นข้อแก้ตัวไม่ได้ใช้ชื่อตัวแปรที่ดีกว่า จะชื่อ ' ไม่ปี้เวลา หรือไม่คิดจะอธิบายช่วงเวลาใดจะแสดง ต้องการเปลี่ยนแปลง: int elapsedTimeInDays int daysSinceCreation int daysSinceModification int fileAgeInDaysกระทำการอย่างง่ายของการใช้ชื่อดีกว่าแทนที่จะใช้คิดดีสามารถลดความยากของทำงานกับรหัสที่เราเขียนวัตถุประสงค์ของรหัสนี้งูคืออะไร list1 =[] สำหรับ x ใน theList: ถ้า x [0] == 4: list1 += x กลับ list1เหตุใดจึงยากที่จะบอกว่า รหัสนี้ทำอะไร ชัดเจนมีนิพจน์ไม่ซับซ้อน ระยะห่าง และย่อหน้าเหมาะสม มีเพียงสามตัวแปรและค่าคงที่สองกล่าวถึงเลย มีไม่ได้แฟนซีสอน หรือโอเวอร์โหลดตัว เพียงรายการ (หรือให้ เหมือน)ปัญหาไม่ได้เรียบง่ายของรหัสแต่ implicity รหัส: ปริญญาซึ่งการเนื้อหาชัดเจนในรหัสตัวเองไม่ได้ รหัสต้องตอบคำถามเช่น:●อะไรบ้างใน theList●สิ่งสำคัญของการ zeroeth ตัวห้อยสินค้าใน theList●ความสำคัญของค่า 4 คืออะไร●วิธีจะใช้รายการรับคืนหรือไม่ข้อมูลนี้ไม่มีในตัวอย่างรหัส แต่ก็สามารถได้รับ บอกว่า เรากำลังทำงานอยู่เกมกวาดทุ่นระเบิด เราพบว่า เป็นรายการของเซลล์ที่เรียกว่า theList ลองเปลี่ยนชื่อที่theBoardแต่ละเซลล์บนกระดานแสดง โดยเรย์อย่าง เราพบต่อไปว่าการ zeroeth ตัวห้อยเป็นตั้งค่าสถานะ กว่า ค่าสถานะ 4 หมายความว่า 'ตั้งค่าสถานะ' โดยให้แนวคิดเหล่านี้ชื่อที่เราสามารถปรับปรุงรหัสมาก: flaggedCells =[] เซลล์ใน theBoard: ถ้าเซลล์ [STATUS_VALUE] ==สนทนา: flaggedCells +=เซลล์ กลับ flaggedCellsสังเกตเห็นว่า ความเรียบง่ายของรหัสจะไม่เปลี่ยนแปลง นอกจากนี้ก็ยังมีตรงหมายเลขเดียวกันของตัวดำเนินการและค่า คงที่ ด้วยว่าหมายเลขเดียวกันของระดับซ้อนเราสามารถไปเพิ่มเติม และเขียนง่ายชั้นเซลล์แทนการใช้อาร์เรย์ของ ints นิพจน์ใช้ตรวจสอบว่า เซลล์มีการตั้งค่าสถานะสามารถเปลี่ยนชื่อ โดยเพิ่มฟังก์ชันการเปิดเผยความตั้งใจ(เรียกว่า isFlagged) ซ่อนตัวเลขมหัศจรรย์ จะส่งผลในการทำงานรุ่นใหม่: flaggedCells =[] เซลล์ใน theBoard: ถ้า cell.isFlagged(): flaggedCells +=เซลล์ กลับ flaggedCellsหรือ tersely มากขึ้น: กลับ [เซลล์ถ้าเซลล์ theBoard cell.isFlagged()]แม้ที่ยุบไปทำความเข้าใจกับรายการ ไม่ยากที่จะเข้าใจ ต้นฉบับของฉันตอบคำถามที่สี่เต็ม และ implicity ของรหัสจะลดลง นี่คืออำนาจของตั้งชื่อ999999999999999Avoid อุดมการณ์ผู้เขียนซอฟต์แวร์ต้องหลีกเลี่ยงการทิ้งปมเท็จซึ่งบดบังความหมายของรหัสเราควรหลีกเลี่ยงคำที่ความหมาย entrenched ซึ่งแตกต่างจากความหมายของวัตถุประสงค์ ตัวอย่าง"เอชพี" "อิ๊กซ์ซอง" และ "พร้อม sco" จะเป็นชื่อตัวแปรไม่ดีเพราะเป็นชื่อของแพลตฟอร์ม Unixหรือตัวแปร แม้ว่าคุณจะเขียนโค้ด hypotenuse และ "เอชพี" เหมือนย่อดี เป็นdisinformativeไม่อ้างอิงถึงกลุ่มของบัญชีเป็นการ AccountList เว้นแต่รายการจริง คำรายการหมายถึง บางสิ่งบางอย่างเฉพาะ CS คน ถ้าภาชนะที่ถือบัญชีไม่เป็นจริงรายการ มันอาจนำไปสู่บทสรุปที่ผิดพลาด AccountGroup หรือ BunchOfAccounts จะได้รับดีขึ้นระวังการใช้ชื่อที่แตกต่างกันในวิธีการขนาดเล็ก นานจะถึงจุดแตกต่างอย่างลงตัวระหว่าง XYZControllerForEfficientHandlingOfStrings ในโม และบาง XYZControllerForEfficientStorageOfStrings น้อยไกล ที่คำที่มีรูปร่างคล้าย frightfullyกับสภาพแวดล้อม Java ทันสมัย คุณมีรหัสอัตโนมัติเสร็จสมบูรณ์ คุณจะเขียนอย่างชื่อและกด บางร้อนแป้น (หากว่า) และคุณจะประทับใจกับรายการได้completions สำหรับชื่อ มันจะดี ถ้าชื่อคล้ายมากเรียงกันตามตัวอักษร และความแตกต่างเห็นได้ชัดมาก มากเนื่องจากแนวโน้มที่จะเลือกวัตถุตามชื่อโดยนักพัฒนาดูความเห็นของคุณ copious หรือแม้แต่รายการของวิธีจัดคลาตัวอย่างที่น่ากลัวอย่างแท้จริงของชื่อ dis-informative จะใช้ L เล็กหรือใหญ่ o เป็นชื่อตัวแปร โดยเฉพาะอย่างยิ่งในชุด ปัญหา แน่นอนคือ พวกเขามองเหมือนเกือบทั้งหมดค่าคงที่หนึ่งและศูนย์ (ตามลำดับ) int เป็น = l ถ้า (O = l) ตัว = O1 อื่น l = 01ผู้อ่านอาจคิดสิ่งประดิษฐ์ แต่ผู้เขียนได้ตรวจสอบรหัสที่สิ่งต่าง ๆ ได้อุดมสมบูรณ์ เป็นเทคนิคที่ดีสำหรับ shrouding รหัส รหัสผู้แนะนำการใช้ที่แตกต่างกันแบบอักษรที่แตกต่างได้ชัดเจนมากขึ้น ปัญหาที่จะต้องสามารถผ่านลงไปทั้งหมดพัฒนาในอนาคต เป็นเรื่องเล่า หรือเอกสารเป็นลายลักษณ์อักษร เป็นการเอาชนะปัญหา ด้วย finality และไม่ มีการสร้างงานใหม่ ๆ หาก ผู้ดำเนินการเปลี่ยนชื่อเรื่องทำให้ความหมายปัญหาที่เกิดจากการเขียนรหัสเพื่อตอบสนองการคอมไพเลอร์หรือล่าม หนึ่งไม่ได้เหมือนกันชื่อที่อ้างอิงถึงสองสิ่งในขอบเขตเดียวกัน ดังนั้นหนึ่งเปลี่ยนชื่อพวกเขาในทางที่กำหนดบางครั้งสิ่งนี้ทำ โดยสะกดผิดหนึ่ง นำไปสู่สถานการณ์ที่น่าแปลกใจแก้ไขการสะกดคำข้อผิดพลาดนำไปสู่การไม่สามารถคอมไพล์มันไม่เพียงพอในการเพิ่มหมายเลขชุดหรือเสียงคำ แม้ว่าคอมไพเลอร์จะพอใจ ถ้าชื่อต้องไม่เหมือนกัน แล้วพวกเขายังควรหมายถึง บางสิ่งบางอย่างที่แตกต่างกันตั้งชื่อลำดับหมายเลข (a1, a2, ... การ) อยู่ตรงข้ามกับที่ตั้งชื่อมิ โดยไม่ได้ชื่อชุดหมายเลข disinformative ให้ปมไม่เจตนาของผู้เขียน ตั้งชื่อตามความตั้งใจ และ โดยโดเมนอาจยืมหนึ่งใช้ชื่อเช่น lvalue และ rvalue หรือแหล่งที่มา และปลายทางมากกว่า string1 และ string2คำเสียงแตกอีกไม่ได้ สมมติว่า คุณมีคลาสผลิตภัณฑ์ ถ้าคุณมีอีกเรียกว่า ProductInfo หรือ ProductData คุณได้ชื่อแตกต่างกันโดยไม่ต้องทำพวกเขาหมายถึง อะไรแตกต่างกัน ข้อมูลและข้อมูลเป็น indistinct เสียงคำเช่น "a" "การ" และ ""เสียงคำซ้ำซ้อนกัน ไม่ควรปรากฏตัวแปรคำในชื่อตัวแปร คำตารางจะไม่ปรากฏในชื่อตาราง ว่า NameString ดีกว่าชื่อ จะชื่อเคยมีการลอยตัวชี้เลข ถ้าเป็นเช่นนั้น มันแบ่งกฎการก่อนหน้าเกี่ยวกับอุดมการณ์ คิดค้นหาชั้นชื่อลูกค้า และอีกชื่อ CustomerObject สิ่งควรคุณเข้าใจตามความแตกต่าง ซึ่งจะแสดงเส้นทางดีที่สุดกับประวัติการชำระเงินของลูกค้าหรือไม่ผมรู้ว่าที่นี้จะแสดงโปรแกรมประยุกต์ได้ ได้เปลี่ยนชื่อเพื่อป้องกันการผิดแต่มีรูปแบบแน่นอนของข้อผิดพลาด: getSomething() getSomethings() getSomethingInfo()พิจารณาบริบท ในการขาดงานของคลาสที่ชื่อหน่วย MoneyAmount จะไม่ดีกว่าเงิน CustomerInfo จะไม่ดีกว่าลูกค้าในลักษณะที่ผู้อ่านรู้ว่ารุ่นอื่นมีเธอ disambiguate แทนแต่ที่จะแตกต่างกันใช้ชื่อขจัดถ้าคุณไม่สามารถออกเสียงได้ คุณไม่สามารถสนทนาได้ โดยไม่มีหูเหมือนคนบ้า "ดี มากกว่าที่นี่ในผึ้งซีตารางเข้าสามซี enn ทีเรามีเป็นปี ess ซี kyew int เห็น" เรื่องนี้เนื่องจากการเขียนโปรแกรมเป็นกิจกรรมทางสังคมบริษัทฉันรู้ว่ามี genymdhms (วันสร้าง ปี เดือน วัน ชั่วโมง นาที และวินาที) ดังนั้นเดินใกล้ว่า " gen ทำไม emm ดี aich emm ess " มีนิสัยน่ารำคาญของรอการออกเสียงทุกอย่างเป็นเขียน ดังนั้นฉันเริ่มพูด "gen-yah-mudda-hims" ภายหลังมีการเรียกนี้ โดยโฮสต์ออกแบบและนักวิเคราะห์ และเรายังแต่เพียงแห่งโง่ แต่เรามาในโจ๊ก ดังนั้นมันก็สนุก สนุก หรือไม่ เราได้ tolerating ตั้งชื่อดี มีนักพัฒนาใหม่ให้ตัวแปรอธิบายพวกเขา และจากนั้น พวกเขาพูดเกี่ยวกับคำสมมติโง่แทนที่จะใช้คำภาษาอังกฤษที่เหมาะสมคลาส DtaRcrd102 { ส่วนวัน genymdhms ส่วนวัน modymdhms ส่วนตัวสุดท้ายสาย pszqint = "102" /* ... */};เรียนลูกค้า{ ส่วนวัน generationTimestamp ส่วนวัน modificationTimestamp;; ส่วนตัวสุดท้ายสาย recordId = "102" /* ... */};ขณะนี้เป็นอัจฉริยะสนทนา: "Hey, Mikey มาดูเรกคอร์ดนี้ รุ่นที่เวลาถูกตั้งค่าเป็นวันของวันพรุ่งนี้ ที่จะ"ใช้ชื่อยากชื่ออักษรเดี่ยวและค่าคงที่ตัวเลขมีปัญหาเฉพาะที่พวกเขาไม่ได้ง่ายในเนื้อหาข้อความหนึ่งอาจได้ grep สำหรับ MAX_CLASSES_PER_STUDENT แต่เลข 7 อาจจะเพิ่มเติมแก้ปัญหา Searche

ผลลัพธ์ (ไทย) 2:

บทนำรหัสที่มาเป็นรูปแบบของการแสดงออกและอื่น ๆ ที่มีคุณภาพของการแสดงออกจะต้องเป็นความกังวลหลัก
น่าสงสารที่มีคุณภาพของการแสดงออกสร้างค่าใช้จ่ายอย่างต่อเนื่องและส่งผลกระทบต่อการผลิต (เพราะฉะนั้นชื่อเสียง) ของทีมงานที่ผลิตมัน ดังนั้นผู้เขียนซอฟแวร์จะต้องเรียนรู้ที่จะแสดงให้เห็นอย่างชัดเจนความตั้งใจของตัวแปรวิธีการเรียนและโมดูล. นอกจากนี้ข้อผิดพลาดเกิดขึ้นเมื่อการบำรุงรักษาเป็นโปรแกรมเมอร์ที่ไม่ถูกต้องเข้าใจรหัสที่เขาต้องแก้ไข โปรแกรมเมอร์ขยันอาจใช้จ่ายความพยายามอย่างมากที่จะต้องถอดรหัสความจริงเจตนาของโปรแกรมแม้ว่าจุดประสงค์ของมันเห็นได้อย่างชัดเจนผู้เขียนต้นฉบับ อันที่จริงก็จะใช้เวลามากเวลามากขึ้นเพื่อกำหนดวิธีการเปลี่ยนรหัสกว่าที่จะทำและทดสอบการเปลี่ยนแปลง. ความพยายามบางอย่างเพื่อปรับปรุงการบำรุงรักษาของรหัสได้เลวร้ายจริง ๆ แล้วปัญหาที่เกิดขึ้นโดยการทำให้ชื่อที่ใช้งานง่ายน้อยลงอย่างเห็นได้ชัดน้อยลงและน้อยลงตามธรรมชาติ พวกเขาทำให้มันง่ายที่จะรวบรวมข้อมูลที่ไม่ได้หายไป (เช่นข้อมูลชนิดและขอบเขตยังคงอยู่ในการประกาศตัวแปร) โดยไม่ทำให้มันง่ายที่จะค้นพบข้อมูลที่สำคัญอื่นๆ ที่หายไป. ชื่อมีความหมายสำหรับวัตถุซอฟต์แวร์ที่ต้องมีความชัดเจน แม่นยำและขนาดเล็ก นี้เป็นคำแนะนำที่จะดีขึ้นชัดเจนแม่นยำและรวบรัดในการตั้งชื่อ มันเป็นความหวังของผู้เขียนที่คุณจะพบว่ามันมีประโยชน์. ใช้ชื่อ-เปิดเผยความตั้งใจที่เรามักจะเห็นความคิดเห็นที่ใช้ในการตั้งชื่อที่ดีกว่าจะที่เหมาะสม: int d; // เวลาที่ผ่านไปในวันดังกล่าวแสดงความคิดเห็นเป็นข้อแก้ตัวสำหรับไม่ได้ใช้ชื่อตัวแปรที่ดีขึ้น ชื่อของ d 'ไม่ได้ทำให้เกิดความรู้สึกของเวลาหรือไม่แสดงความคิดเห็นอธิบายสิ่งที่ช่วงเวลาที่มันหมายถึง มันต้องมีการเปลี่ยนแปลง: int elapsedTimeInDays; int daysSinceCreation; int daysSinceModification; int fileAgeInDays; การกระทำที่เรียบง่ายของการใช้ชื่อที่ดีกว่าแทนการใช้ความคิดเห็นที่ดีขึ้นสามารถลดความยากลำบากในการ. ทำงานร่วมกับรหัสที่เราเขียนอะไรคือสิ่งที่จุดประสงค์ของการหลามนี้รหัส? list1 = [] สำหรับ x ใน theList: ถ้า x [0] == 4: list1 + = x; กลับมา list1 ทำไมมันจึงเป็นเรื่องยากที่จะบอกได้ว่ารหัสนี้จะทำ? เห็นได้ชัดว่าไม่มีการแสดงออกที่ซับซ้อน ระยะปลูกและเยื้องมีความเหมาะสม มีเพียงสามตัวแปรและค่าคงที่สองกล่าวถึงเลย มีไม่ได้เรียนแฟนซีใด ๆ หรือผู้ประกอบการมากเกินไปเพียงแค่รายชื่อของรายการ (หรือเพื่อให้ดูเหมือนว่า) เป็น. ปัญหาไม่ได้อยู่ที่เรียบง่ายของรหัส แต่ implicity ของรหัส: ระดับที่บริบทไม่ได้อย่างชัดเจนในรหัสของตัวเอง รหัสต้องการให้ฉันที่จะตอบคำถามเช่น: ●สิ่งที่ชนิดของสิ่งที่อยู่ใน theList? ●เป็นความสำคัญของห้อย zeroeth ของรายการใน theList คืออะไร? ●อะไรคือสิ่งที่สำคัญของค่า 4 หรือไม่●ฉันจะวิธีใช้รายการถูกส่งกลับ? ข้อมูลนี้ไม่ได้อยู่ในตัวอย่างรหัส แต่มันจะได้รับ บอกได้เลยว่าเรากำลังทำงานในเกมเหมืองกวาด เราพบว่าคณะกรรมการคือรายการของเซลล์ที่เรียกว่า theList ขอเปลี่ยนชื่อที่theBoard. แต่ละเซลล์ในคณะกรรมการที่เป็นตัวแทนจากอาเรย์ที่เรียบง่าย เรายังพบว่าสินค้าของห้อย zeroeth เป็นสถานที่ตั้งของค่าสถานะและที่ค่าสถานะของ4 หมายถึง 'การตั้งค่าสถานะ' a เพียงแค่ให้แนวคิดเหล่านี้ชื่อที่เราสามารถปรับปรุงรหัสมาก: flaggedCells = [] สำหรับเซลล์ใน theBoard: ถ้าเซลล์ [STATUS_VALUE] == ตั้งค่าสถานะ: flaggedCells + = เซลล์flaggedCells กลับมาขอให้สังเกตว่าความเรียบง่ายของรหัสที่จะไม่เปลี่ยนแปลง มันก็ยังมีตรงหมายเลขเดียวกันของผู้ประกอบการและค่าคงที่ตรงกับหมายเลขเดียวกันของระดับการทำรัง. เราสามารถไปต่อไปและเขียนระดับที่ง่ายสำหรับเซลล์แทนการใช้อาร์เรย์ของ ints การแสดงออกที่ใช้ในการตรวจสอบว่าเซลล์ที่ได้รับการตั้งค่าสถานะสามารถเปลี่ยนชื่อโดยการเพิ่มฟังก์ชั่นความตั้งใจเปิดเผย(เรียกว่า isFlagged) เพื่อซ่อนหมายเลขมายากล ได้ผลในรุ่นใหม่ของฟังก์ชั่น: flaggedCells = [] สำหรับเซลล์ใน theBoard: ถ้า cell.isFlagged (): flaggedCells + = เซลล์flaggedCells ผลตอบแทนหรือมากกว่ากะทัดรัด: กลับ [มือถือสำหรับเซลล์ใน theBoard ถ้า cell.isFlagged ()] ถึงแม้จะมีฟังก์ชั่นทรุดลงไปเข้าใจรายการก็ไม่ยากที่จะเข้าใจ เดิมของฉันสี่คำถามมีคำตอบอย่างเต็มที่และ implicity ของรหัสจะลดลง นี้เป็นอำนาจของการตั้งชื่อ. 999999999999999Avoid บิดเบือนเขียนซอฟแวร์จะต้องหลีกเลี่ยงการออกเบาะแสเท็จซึ่งปิดบังความหมายของรหัส. เราควรหลีกเลี่ยงคำที่มีความหมายที่ยึดที่มั่นแตกต่างจากความหมายของเรา ยกตัวอย่างเช่น"แรงม้า", "Aix" และ "SCO" จะเป็นชื่อตัวแปรที่ไม่ดีเพราะพวกเขามีชื่อของแพลตฟอร์มระบบปฏิบัติการยูนิกซ์หรือสายพันธุ์ แม้ว่าคุณจะเข้ารหัสด้านตรงข้ามมุมฉากและ "แรงม้า" ดูเหมือนย่อที่ดีก็เป็นdisinformative. ไม่ได้หมายถึงการจัดกลุ่มของบัญชีเป็น AccountList เว้นแต่จะเป็นจริงรายการ คำรายการหมายถึงบางสิ่งบางอย่างที่เฉพาะเจาะจงกับคน CS ถ้าภาชนะที่ถือบัญชีที่ไม่ได้เป็นจริงรายการอาจนำไปสู่ข้อสรุปที่ผิดพลาด AccountGroup หรือ BunchOfAccounts จะได้รับที่ดีกว่า. ระวังของการใช้ชื่อที่แตกต่างกันในรูปแบบขนาดเล็ก นานแค่ไหนที่ไม่ได้ใช้เวลาในการจุดแตกต่างที่ลึกซึ้งระหว่าง XYZControllerForEfficientHandlingOfStrings หนึ่งในโมดูลและบางXYZControllerForEfficientStorageOfStrings ห่างไกลมากขึ้นเล็ก ๆ น้อย ๆ ? คำมีรูปร่างคล้ายน่าขนพองสยองเกล้า. ด้วยสภาพแวดล้อมที่ทันสมัย ​​Java คุณต้องเสร็จรหัสอัตโนมัติ คุณจะเขียนไม่กี่ตัวอักษรของชื่อและบางกดคีย์ผสมร้อน (ว่าที่) และคุณจะได้รับการต้อนรับที่มีรายชื่อที่เป็นไปได้ของความสำเร็จสำหรับชื่อที่ มันเป็นสิ่งที่ดีถ้าชื่อสิ่งที่คล้ายกันมากการจัดเรียงเข้าด้วยกันตามลำดับตัวอักษรและหากความแตกต่างที่มีความชัดเจนมากเนื่องจากนักพัฒนามีแนวโน้มที่จะเลือกวัตถุโดยใช้ชื่อโดยไม่ต้องเห็นความคิดเห็นหรือมากของคุณแม้ในรายการของวิธีการที่จัดทำโดยชั้นเรียนที่. ตัวอย่างอันยิ่งใหญ่อย่างแท้จริงของชื่อโรคให้ข้อมูลจะใช้ L กรณีที่ต่ำกว่าหรือตัวพิมพ์ใหญ่ o เป็นชื่อตัวแปรโดยเฉพาะอย่างยิ่งในการรวมกัน ปัญหาของหลักสูตรคือการที่พวกเขามองเกือบทั้งหมดเช่นค่าคงที่หนึ่งและศูนย์ (ตามลำดับ). int a ลิตร =; if (O = ลิตร) A = O1; อื่นลิตร = 01; ผู้อ่านอาจจะคิดว่านี่ประดิษฐ์ แต่ ผู้เขียนได้รับการตรวจสอบรหัสสิ่งที่ดังกล่าวเป็นที่อุดมสมบูรณ์ มันเป็นเทคนิคที่ดีสำหรับรหัส shrouding ผู้เขียนรหัสแนะนำการใช้แตกต่างกันตัวอักษรเพื่อให้ความแตกต่างได้ชัดเจนมากขึ้นการแก้ปัญหาที่จะต้องถูกส่งผ่านลงไปทั้งหมดนักพัฒนาในอนาคตเช่นปากหรือในเอกสารที่เขียน ปัญหาคือการเอาชนะกับวาระสุดท้ายและโดยไม่ต้องสร้างผลงานใหม่หากผู้เขียนดำเนินการเปลี่ยนชื่อที่เรียบง่าย. ให้มีความหมายแตกต่างปัญหาที่เกิดขึ้นจากการเขียนรหัส แต่เพียงผู้เดียวที่จะตอบสนองคอมไพเลอร์หรือล่าม หนึ่งไม่สามารถมีเหมือนกันชื่อหมายถึงสองสิ่งที่อยู่ในขอบเขตเดียวกันดังนั้นชื่อที่มีการเปลี่ยนแปลงพวกเขาในทางพล. บางครั้งนี้จะกระทำโดยการสะกดคำผิดหนึ่งที่นำไปสู่สถานการณ์ที่น่าแปลกใจที่การแก้ไขการสะกดข้อผิดพลาดที่นำไปสู่การไม่สามารถที่จะรวบรวม. มันไม่เพียงพอที่จะเพิ่มจำนวนชุดหรือคำฟุ่มเฟือยแม้ว่าคอมไพเลอร์เป็นที่พอใจ ถ้าชื่อจะต้องแตกต่างกันแล้วพวกเขายังจะหมายถึงบางสิ่งบางอย่างที่แตกต่างกัน. ตั้งชื่อจำนวนชุด (a1, a2, .. ) ที่อยู่ฝั่งตรงข้ามของการตั้งชื่อโดยเจตนา โดยไม่ต้องdisinformative ชื่อชุดจำนวนให้เบาะแสกับความตั้งใจของผู้เขียนไม่มี การตั้งชื่อโดยความตั้งใจและโดเมนอาจให้ยืมหนึ่งที่จะใช้ชื่อเช่น lvalue และ rvalue หรือแหล่งที่มาและปลายทางมากกว่าstring1 และ string2. คำเสียงเป็นอีกความแตกต่างความหมาย ลองจินตนาการว่าคุณมีระดับผลิตภัณฑ์ ถ้าคุณได้อีกเรียกว่า productinfo หรือ ProductData คุณได้ทำชื่อที่แตกต่างกันโดยไม่ทำให้พวกเขาหมายถึงอะไรที่แตกต่างกัน ข้อมูลและข้อมูลที่เป็นคำเสียงไม่ชัดเช่น "A", "เป็น" และ "". คำเสียงซ้ำซ้อน ตัวแปรคำที่ไม่ควรจะปรากฏในชื่อตัวแปร คำที่โต๊ะไม่ควรจะปรากฏในชื่อตาราง เป็นวิธีการที่ดีกว่า NameString ชื่อ? ชื่อจะเคยเป็นจำนวนจุดลอย? ถ้าเป็นเช่นนั้นจะแบ่งกฎก่อนหน้านี้เกี่ยวบิดเบือน ลองนึกภาพการหาชั้นหนึ่งชื่อลูกค้าและอีกคนหนึ่งชื่อ CustomerObject สิ่งที่คุณควรเข้าใจว่าเป็นความแตกต่าง? ที่หนึ่งที่จะเป็นตัวแทนของเส้นทางที่ดีที่สุดในประวัติศาสตร์การชำระเงินของลูกค้าหรือไม่มีการประยุกต์ใช้ฉันรู้ว่าที่นี่คือตัวอย่างคือ ฉันได้เปลี่ยนชื่อเพื่อป้องกันความผิดแต่รูปแบบที่แน่นอนของข้อผิดพลาดคือgetSomething (); getSomethings (); getSomethingInfo (); พิจารณาบริบท ในกรณีที่ไม่มีชื่อชั้นนิกายที่ MoneyAmount ไม่ดีกว่าเงิน customerinfo ไม่ดีกว่าของลูกค้า. กระจ่างในลักษณะที่ผู้อ่านรู้ว่าสิ่งที่รุ่นที่แตกต่างกันให้เธอแทนการเพียงว่าพวกเขากำลังที่แตกต่างกัน. ใช้ชื่อออกเสียงถ้าคุณไม่สามารถออกเสียงคุณไม่สามารถพูดคุยได้โดยไม่ต้องทำให้เกิดเสียงเหมือนคนงี่เง่า "ดีกว่าที่นี่ในผึ้งCee ARR สาม Cee ที enn เรามีพี่ลิงก์ Zee kyew int ให้ดู?" เรื่องนี้เพราะการเขียนโปรแกรมเป็นกิจกรรมทางสังคม. บริษัท ที่ผมรู้ว่ามี genymdhms (วันรุ่นปีเดือนวันชั่วโมงนาทีและวินาที) เพื่อให้พวกเขาเดินไปรอบๆ ว่า "ทำไมเก็ EMM ดี AICH EMM ลิงก์" ฉันมีนิสัยที่น่ารำคาญของการออกเสียงทุกอย่างตามที่เขียนดังนั้นผมจึงเริ่มพูดว่า "GEN-ย่ะ-mudda-ฮิมส์" หลังจากนั้นมันก็ถูกเรียกว่านี้โดยการเป็นเจ้าภาพของนักออกแบบและนักวิเคราะห์และเรายังคงฟังดูโง่ แต่เราอยู่ในในเรื่องตลกดังนั้นจึงเป็นเรื่องที่สนุก สนุกหรือไม่เราก็ทนการตั้งชื่อที่น่าสงสาร นักพัฒนาใหม่จะต้องมีตัวแปรที่อธิบายให้พวกเขาและพวกเขาก็พูดเกี่ยวกับมันในโง่คำทำขึ้นแทนการใช้คำศัพท์ภาษาอังกฤษที่เหมาะสม. ระดับ DtaRcrd102 {ส่วนตัววันgenymdhms; ส่วนตัววัน modymdhms; String ส่วนตัวสุดท้าย pszqint = "102"; / * ... * /}; ระดับลูกค้า {ส่วนตัววันgenerationTimestamp; ส่วนตัววัน modificationTimestamp ;; ส่วนตัวสุดท้าย RecordID String = "102"; / * ... * /}; สนทนาอัจฉริยะในขณะนี้เป็นไปได้: "เฮ้กี้ ดูที่บันทึกนี้! รุ่นประทับเวลามีการตั้งค่าวันที่ในวันพรุ่งนี้วิธีที่สามารถ? "ใช้ชื่อที่สามารถค้นหาชื่อเดี่ยวตัวอักษรและค่าคงที่ที่เป็นตัวเลขมีปัญหาโดยเฉพาะอย่างยิ่งในการที่พวกเขาจะไม่ง่ายต่อการค้นหาทั่วร่างกายของข้อความหนึ่งได้อย่างง่ายดายอาจ grep สำหรับ MAX_CLASSES_PER_STUDENT แต่จำนวน 7 อาจจะมากขึ้นลำบาก Searche

ผลลัพธ์ (ไทย) 3:

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

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

เรามักจะเห็นความคิดเห็นที่ดีกว่าการใช้จะเหมาะสม :
1 D ; / / เวลาที่ผ่านไปในวัน
เช่นนั้นเป็นข้ออ้างสำหรับการไม่ใช้ชื่อตัวแปรดีกว่าชื่อ ' D ' ไม่ทำให้เกิดความรู้สึก
ของเวลาและไม่แสดงความคิดเห็น อธิบายว่า ช่วงเวลาที่แสดงถึง มันต้องเปลี่ยน :
1 elapsedtimeindays ;
1 dayssincecreation ;
1 dayssincemodification ;
1 fileageindays ;

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

เขียน .อะไรคือจุดประสงค์ของรหัสนี้
list1 = [ ]
สำหรับ x ใน thelist :
ถ้า x [ 0 ] = = 4 :
list1 = x ;

list1
กลับทำไมมันถึงยากที่จะบอกได้ว่ารหัสนี้จะทำอะไร ? ชัดเจนไม่มีการแสดงออกที่ซับซ้อน ระยะเยื้องและ
ที่สมเหตุสมผล มีเพียงสามตัวแปรและค่าคงที่ที่กล่าวถึงทั้งหมด มีไม่ใด ๆแฟนซี
แม้แต่ชั้นเรียน หรือ ทำให้ผู้ประกอบการเพียงรายการของรายการ ( ดูเหมือน ) .
ปัญหาไม่ได้อยู่ที่ความเรียบง่ายของรหัส แต่ implicity ของรหัส : การที่
บริบทไม่ชัดเจนในรหัสตัวเอง รหัสที่ต้องถามคำถามเช่น :
●สิ่งที่ชนิดของสิ่งที่อยู่ใน thelist ?
●อะไรคือความสำคัญของตัวห้อย zeroeth ของรายการใน thelist ?
●อะไรคือความสำคัญของค่า 4