เป็นวิธีปฏิบัติที่ดีหรือไม่ที่จะตั้งชื่อตัวแปร“ return” ที่ส่งคืน [ปิด]

เป็นวิธีปฏิบัติที่ดีในการเรียกใช้ตัวแปรที่เมธอดส่งคืนด้วยชื่อตัวแปรresultหรือไม่?

ตัวอย่างเช่น

public Zorglub calculate() {
    Zorglub result = [...]
    [...]
    return result;
}

หรือฉันควรตั้งชื่อตามประเภทของมัน?

public Zorglub calculate() {
    Zorglub zorglub = [...]
    [...]
    return zorglub;
}

ฉันเคยเห็นทั้งสองอย่างในป่าถ้าฉันต้องเลือกเหตุผลอะไรที่ทำให้ฉันชอบอดีตหรือหลัง (หรือชื่อที่ดีกว่า)?

ฉันคิดเกี่ยวกับ Java เป็นหลัก

ถ้านี่เป็นตัวแปรเมธอดมันขึ้นอยู่กับความสามารถในการอ่าน

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

resultข้ามการอ่านจะทำง่ายขึ้นถ้าตัวแปรเป็นชื่อ นี่ทำให้ความตั้งใจของคุณชัดเจน

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

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

แต่ชื่ออื่น ๆ ที่ไม่ได้บอกเป็นนัย (เช่นretหรือresult) หรืออย่างชัดเจน (เช่นmyFunctionReturnValueหรือmyFunctionResult) รัฐว่านี่คือฟังก์ชั่นปัจจุบันกลับตัวแปรทั่วไปเกินไป

ในตัวอย่างที่สองของคุณzorglubคือตัวเลือกที่น่ากลัว การประกาศทั้งหมดบอกฉันจริงๆว่าคุณสร้างตัวแปรชื่อที่เท่ากับคำอธิบายประกอบชนิดที่พบถัดจากชื่อ มันเป็นเรื่องที่เป็นประโยชน์เป็นหรือint someIntZorglub z

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

คุณอาจต้องการอ่านข้อมูลเกี่ยวกับการเขียนโปรแกรม Spartanซึ่งค่อนข้างเกี่ยวข้องกับคำถามของคุณ

ในตัวอย่างที่สองของคุณคุณมหันต์ประเภทของผลที่ได้กับสิ่งที่มันเป็น

Zorglub zorglub;

แค่บอกฉันว่ามันคือ Zorglub สองครั้ง สามครั้งถ้าฉันรำคาญที่จะอ่านวิธีคืนประเภท อย่างไรก็ตาม

double variance;

ตัวอย่างเช่นให้เบาะแสเกี่ยวกับความหมายของค่าตอบแทนในแง่ของความหมายของโปรแกรม มันอาจจะใช่หรือไม่ใช่ชัดเจนกว่าแค่เรียกมันresultขึ้นอยู่กับขนาดของวิธีการ - นั่นเป็นการเรียกการตัดสินสำหรับแต่ละวิธี IMO

ถ้าคุณเล่นกับหลายวัตถุ Zorglub ในวิธีการของคุณคุณ "สามารถ" ทำผิดพลาดและกลับผิดหนึ่งและ / หรือคุณอาจจะอยากจะตั้งชื่อคนอื่น ๆzorglub1, zorglub2ฯลฯ

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

โดยส่วนตัวแล้วฉันไม่ค่อยสบายใจที่ใช้resultชื่อตัวแปร ยุติธรรมพอมันบอกฉันว่าค่าที่เกี่ยวข้องนั้นเป็นผลมาจากการคำนวณบางอย่าง - อย่างไรก็ตามฉันเดาว่าเป็นเรื่องจริง (หรือมากกว่า) 90% ของตัวแปร / ฟิลด์ที่ใช้ในโปรแกรม

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

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

ฉันใช้ชื่อresultสำหรับค่าที่จะส่งคืนจากฟังก์ชัน / เมธอด มันทำให้ชัดเจนว่าเป็นค่าที่จะส่งคืน ดูเหมือนว่าการตั้งชื่อตามประเภทนั้นไม่มีประโยชน์เพราะอาจมีตัวแปรมากกว่าหนึ่งประเภทที่เหมือนกัน

ความแตกต่างคืออะไร? มันแค่ 2 คำที่แตกต่างกันที่นั่นที่จะทำสิ่งเดียวกันดังนั้นปัญหาที่แท้จริงคือสิ่งที่ฟังดูชัดเจนสำหรับคุณ

"ผลลัพธ์" หรือ "zorglub"

ฉันต้องการใช้ZorglubResultสำหรับผู้เริ่มต้นเพื่อดูว่าผลตอบแทนนั้น Zorglubง่ายกว่าเมื่อเปรียบเทียบกับผลลัพธ์อื่น ๆ ที่คุณอาจมีและผลลัพธ์ตามที่คุณเห็น ..

ฉันควรตั้งชื่อตามประเภทของมัน?

ไม่ไม่เคย. สิ่งนี้เรียกว่า Systems Hungarian และล้าสมัยเล็กน้อยโดยแนวคิดของการใช้โปรแกรมที่สามารถแสดงประเภทของตัวแปรใด ๆ ได้ทุกเมื่อที่คุณต้องการ

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

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

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

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

ดังนั้นในตัวอย่างของคุณมันจะเป็นผล Zorglub

ถ้าสิ่งที่มันไม่สำคัญกว่านั้นก็จะเป็นผล (ไม่ใช่ resultString)

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

หากคุณมีค่ากลางที่อาจหรืออาจไม่สามารถเปลี่ยนแปลงได้โดยรหัสตามเงื่อนไขก็จะไม่เป็นผลลัพธ์ (ยัง) ดังนั้นจึงไม่ควรตั้งชื่ออย่างนั้น

เมื่อฉันทำงานใน C ++ และฉันคิดว่านี่อาจใช้กับ Java ที่ฉันทำ

เช่น

int Width() const
{
    Requires(....);
    Requires(....);

    //calculation

    Ensures(...);
    Ensures(...);
    return Result;
}

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

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

def removeOccurence [A] (slice: Seq[A], original: Seq[A]) = {
  @scala.annotation.tailrec
  def remove (leftOriginal: Seq[A], result: Seq[A]) : Seq[A] =
    trimStart (slice, leftOriginal) match {
      case (h :: tail) => remove (tail, h +: result)
      case (Nil)       => result.reverse
    }
    remove (original, Nil)
}

แต่บ่อยครั้งที่ฉันใช้ 'พกพา' และ 'โซฟา' ซึ่งฉันเคยเห็นในป่าและมีความคิดที่ดีขึ้นในกรณีส่วนใหญ่

แน่นอนเหตุผลที่สองคือถ้าหัวข้อของคุณแนะนำคำว่า '' ผลลัพธ์ '' ตัวอย่างเช่นถ้าคุณทำการประเมินทางคณิตศาสตร์ คุณอาจแยกวิเคราะห์สูตรแทนที่ตัวแปรด้วยค่าและคำนวณผลลัพธ์ในที่สุด

เหตุผลข้อที่สามมีการระบุไว้แล้ว แต่ฉันมีความเบี่ยงเบนเล็กน้อย: คุณเขียนวิธีการทำงานบางอย่างสมมติว่ามันประเมินรูปแบบของ '' max ''

def max = {
  val result = somethingElseToDo
  if (foo) result else default 
}

แทนที่จะเรียกผลลัพธ์ '' ผลลัพธ์ '' เราสามารถเรียกมันว่า '' max '' แต่ในบางภาษาคุณสามารถละเว้นวงเล็บเมื่อเรียกใช้เมธอดดังนั้น max จะเป็นการเรียกซ้ำไปยังเมธอดนั้นเอง

โดยทั่วไปแล้วฉันต้องการชื่อที่บอกว่าผลลัพธ์คืออะไร แต่ถ้าชื่อนั้นถูกใช้ไปแล้วอาจมีตัวแปรมากกว่าหนึ่งรายการซึ่งเป็นที่มาหรือวิธีการเนื่องจากมีฟิลด์ GUI, การแทนสตริง, ตัวเลขและอีกหนึ่งสำหรับฐานข้อมูลโดยใช้อีกหนึ่งเพิ่มความน่าจะเป็นของความสับสน ในวิธีการสั้น ๆ 3 ถึง 7 บรรทัด '' result '' ไม่ควรมีปัญหาสำหรับชื่อ

ใน Object Pascal นี่ไม่ใช่ตัวเลือก คุณต้องกำหนดค่าให้กับResultตัวแปรในโค้ดของฟังก์ชัน

ตัวอย่าง:

function AddIntegers( A,B: Integer): Integer;
begin
  Result := A + B; 
end; 

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

แน่นอนว่าถ้าเป็นการแสดงออกที่ง่ายมากในภาษาที่ได้จากภาษา C ฉันไม่ต้องกังวลที่จะประกาศตัวแปรผลลัพธ์โดยส่งคืนนิพจน์โดยตรง

มันไม่ใช่แค่สิ่งที่คุณตั้งชื่อผลลัพธ์ (โดยเฉพาะฉัน 'r') แต่ยังใช้งานได้อย่างไร ตัวอย่างเช่นหากคุณกำลังจะมีตัวแปรส่งคืนแล้วทุกคำสั่งกลับควรส่งกลับ ไม่มี 'return r;' ในตอนท้าย แต่สิ่งโรยเช่น 'return m * x + b; "ตลอดทั้งวิธีการ / ฟังก์ชั่นใช้" r = m * x + b; return r; "แทน

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