แนวคิดเรื่อง“ การกลับมาครั้งเดียวเท่านั้น” มาจากไหน

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

if (condition)
   return 42;
else
   return 97;

" นี่น่าเกลียดคุณต้องใช้ตัวแปรเฉพาะที่! "

int result;
if (condition)
   result = 42;
else
   result = 97;
return result;

การขยายโค้ด 50% นี้ทำให้โปรแกรมเข้าใจได้ง่ายขึ้นอย่างไร โดยส่วนตัวแล้วฉันพบว่ามันยากขึ้นเพราะพื้นที่ของรัฐเพิ่มขึ้นจากตัวแปรอื่นที่สามารถป้องกันได้ง่าย

แน่นอนโดยปกติฉันจะเขียน:

return (condition) ? 42 : 97;

แต่โปรแกรมเมอร์จำนวนมากหลีกเลี่ยงผู้ปฏิบัติงานที่มีเงื่อนไขและชอบแบบยาว

แนวคิดเรื่อง "หนึ่งคืนเท่านั้น" มาจากไหน มีเหตุผลทางประวัติศาสตร์ว่าทำไมการประชุมครั้งนี้เกิดขึ้น?

"Single Entry, Single Exit" ถูกเขียนขึ้นเมื่อการเขียนโปรแกรมส่วนใหญ่ทำในภาษาแอสเซมบลี, FORTRAN หรือ COBOL มันถูกตีความผิดกันอย่างกว้างขวางเพราะภาษาที่ทันสมัยไม่สนับสนุนการปฏิบัติ Dijkstra ถูกเตือน

"Single Entry" หมายถึง "อย่าสร้างจุดเข้าอื่นสำหรับฟังก์ชั่น" ในภาษาแอสเซมบลีแน่นอนว่าเป็นไปได้ที่จะเข้าสู่ฟังก์ชั่นที่คำสั่ง FORTRAN รองรับหลายฟังก์ชั่นด้วยENTRYคำสั่ง:

      SUBROUTINE S(X, Y)
      R = SQRT(X*X + Y*Y)
C ALTERNATE ENTRY USED WHEN R IS ALREADY KNOWN
      ENTRY S2(R)
      ...
      RETURN
      END

C USAGE
      CALL S(3,4)
C ALTERNATE USAGE
      CALL S2(5)

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

C SUBROUTINE WITH ALTERNATE RETURN.  THE '*' IS A PLACE HOLDER FOR THE ERROR RETURN
      SUBROUTINE QSOLVE(A, B, C, X1, X2, *)
      DISCR = B*B - 4*A*C
C NO SOLUTIONS, RETURN TO ERROR HANDLING LOCATION
      IF DISCR .LT. 0 RETURN 1
      SD = SQRT(DISCR)
      DENOM = 2*A
      X1 = (-B + SD) / DENOM
      X2 = (-B - SD) / DENOM
      RETURN
      END

C USE OF ALTERNATE RETURN
      CALL QSOLVE(1, 0, 1, X1, X2, *99)
C SOLUTION FOUND
      ...
C QSOLVE RETURNS HERE IF NO SOLUTIONS
99    PRINT 'NO SOLUTIONS'

เทคนิคทั้งสองนี้มีข้อผิดพลาดอย่างมาก การใช้รายการทางเลือกมักจะปล่อยให้ตัวแปรบางตัวไม่มีการกำหนดค่าเริ่มต้น การใช้การส่งคืนทางเลือกมีปัญหาทั้งหมดของคำสั่ง GOTO โดยมีความซับซ้อนเพิ่มเติมว่าสภาพสาขาไม่ได้อยู่ติดกับสาขา แต่อยู่ที่ไหนสักแห่งในรูทีนย่อย

แนวคิดของSingle Entry, Single Exit (SESE) มาจากภาษาที่มีการจัดการทรัพยากรอย่างชัดเจนเช่น C และแอสเซมบลี ใน C รหัสเช่นนี้จะทำให้ทรัพยากรรั่วไหล:

void f()
{
  resource res = acquire_resource();  // think malloc()
  if( f1(res) )
    return; // leaks res
  f2(res);
  release_resource(res);  // think free()
}

ในภาษาดังกล่าวโดยทั่วไปคุณมีสามตัวเลือก:

• ทำซ้ำรหัสการล้างข้อมูล
  ฮึ. ความซ้ำซ้อนนั้นไม่ดีอยู่เสมอ

• ใช้ a gotoเพื่อข้ามไปยังรหัสการล้างข้อมูล
  สิ่งนี้ต้องใช้รหัสการล้างข้อมูลเป็นสิ่งสุดท้ายในฟังก์ชัน (และนี่คือเหตุผลที่บางคนโต้แย้งว่าgotoมีที่อยู่และมีแน่นอน - ในค.)

• แนะนำตัวแปรท้องถิ่นและควบคุมการไหลของการควบคุมผ่านสิ่งนั้น
  ข้อเสียคือการควบคุมการไหลจัดการผ่านไวยากรณ์ (คิดว่าbreak, return, if, while) เป็นเรื่องง่ายที่จะปฏิบัติตามกว่าการควบคุมการไหลจัดการผ่านรัฐของตัวแปร (เพราะตัวแปรเหล่านั้นมีสถานะไม่เมื่อคุณมองไปที่ขั้นตอน)

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

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

อย่างไรก็ตามเมื่อภาษามีข้อยกเว้น (เกือบ) ฟังก์ชั่นใด ๆ ที่อาจจะออกก่อนเวลา (เกือบ) จุดใด ๆ ดังนั้นคุณจะต้องทำให้บทบัญญัติสำหรับการกลับมาก่อนกำหนดอยู่แล้ว (ฉันคิดว่าfinallyส่วนใหญ่จะใช้สำหรับที่ใน Java และusing(เมื่อดำเนินการIDisposableเป็นfinallyอย่างอื่น) ใน C #; C ++ แทนใช้RAII .) เมื่อคุณทำสิ่งนี้แล้วคุณไม่สามารถล้มเหลวในการทำความสะอาดหลังจากตัวเองเนื่องจากreturnคำสั่งก่อนดังนั้นสิ่งที่อาจ การโต้แย้งที่แข็งแกร่งที่สุดในความโปรดปรานของ SESE ได้หายไป

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

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

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

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

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

  int function() {
     if (bidi) { print("return 1"); return 1; }
     for (int i = 0; i < n; i++) {
       if (vidi) { print("return 2"); return 2;}
     }
     print("return 3");
     return 3;
  }

ในอีกทางหนึ่งคุณสามารถ refactor สิ่งนี้ลงในการfunction()โทร_function()และบันทึกผลลัพธ์

"Single Entry, Single Exit" มีต้นกำเนิดมาจากการปฏิวัติการเขียนโปรแกรมอย่างมีโครงสร้างของต้นปี 1970 ซึ่งถูกส่งออกโดยจดหมายของ Edsger W. Dijkstra ถึงบรรณาธิการ " GOTO Statement พิจารณาว่าเป็นอันตราย " แนวคิดที่อยู่เบื้องหลังการเขียนโปรแกรมแบบมีโครงสร้างนั้นมีรายละเอียดในหนังสือคลาสสิก "การเขียนโปรแกรมแบบมีโครงสร้าง" โดย Ole Johan-Dahl, Edsger W. Dijkstra และ Charles Anthony Richard Hoare

"คำชี้แจงของ GOTO ที่พิจารณาว่าเป็นอันตราย" จำเป็นต้องอ่านแม้กระทั่งทุกวันนี้ "การเขียนโปรแกรมแบบมีโครงสร้าง" เป็นวันที่ แต่ยังคงมีคุณค่ามากและควรจะอยู่ในอันดับต้น ๆ ของรายการ "ต้องอ่าน" ของนักพัฒนาใด ๆ เหนือสิ่งอื่นใดจากเช่น Steve McConnell (ส่วนของ Dahl วางพื้นฐานของคลาสใน Simula 67 ซึ่งเป็นพื้นฐานทางเทคนิคสำหรับคลาสใน C ++ และการเขียนโปรแกรมเชิงวัตถุทั้งหมด)

มันง่ายเสมอที่จะเชื่อมโยง Fowler

หนึ่งในตัวอย่างหลักที่ขัดแย้งกับ SESE คือคำสั่งป้องกัน:

แทนที่ Nested Conditional ด้วย Guard Clauses

ใช้ Guard Clauses สำหรับทุกกรณีพิเศษ

double getPayAmount() {
    double result;
    if (_isDead) result = deadAmount();
    else {
        if (_isSeparated) result = separatedAmount();
        else {
            if (_isRetired) result = retiredAmount();
            else result = normalPayAmount();
        };
    }
return result;
};  

                                                                                                        

double getPayAmount() {
    if (_isDead) return deadAmount();
    if (_isSeparated) return separatedAmount();
    if (_isRetired) return retiredAmount();
    return normalPayAmount();
};  

สำหรับข้อมูลเพิ่มเติมโปรดดูที่หน้า 250 ของRefactoring ...

ฉันเขียนโพสต์บล็อกในหัวข้อนี้สักครู่

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

คำถามนี้ถูกถามใน Stackoverflow ด้วย

การคืนหนึ่งทำให้การปรับโครงสร้างทำได้ง่ายขึ้น ลองทำการ "แยกเมธอด" ลงในเนื้อความด้านในของ for loop ที่มี return, break หรือ Continue สิ่งนี้จะล้มเหลวเมื่อคุณทำผิดขั้นตอนการควบคุมของคุณ

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

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

พิจารณาข้อเท็จจริงที่ว่าข้อความสั่งคืนหลายรายการมีค่าเท่ากับการมี GOTO เป็นข้อความสั่งกลับรายการเดียว นี่เป็นกรณีเดียวกันกับคำสั่ง break ด้วยเหตุนี้บางคนเช่นฉันจึงพิจารณา GOTO เพื่อจุดประสงค์และจุดประสงค์ทั้งหมด

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

กฎทั่วไปของฉันคือ GOTO นั้นใช้สำหรับควบคุมการไหลเท่านั้น ไม่ควรใช้การวนซ้ำใด ๆ และคุณไม่ควรใช้ GOTO 'ขึ้น' หรือ 'ย้อนกลับ' (ซึ่งเป็นวิธีการแบ่ง / ส่งคืนงาน)

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

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

ความซับซ้อนของวัฏจักร

ฉันเคยเห็น SonarCube ใช้คำสั่งคืนหลายคำสั่งในการพิจารณาความซับซ้อนของวัฏจักร ดังนั้นข้อความสั่งกลับยิ่งมีความซับซ้อนมากขึ้น

ผลตอบแทนประเภทการเปลี่ยนแปลง

ผลตอบแทนหลายรายการหมายความว่าเราจำเป็นต้องเปลี่ยนที่หลายแห่งในฟังก์ชั่นเมื่อเราตัดสินใจที่จะเปลี่ยนประเภทผลตอบแทนของเรา

หลายทางออก

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

โซลูชันที่ปรับโครงสร้างใหม่

วิธีการแก้ปัญหาคำสั่ง return หลายคำคือการแทนที่ด้วย polymorphism มีการคืนค่าครั้งเดียวหลังจากแก้ไขวัตถุการนำไปปฏิบัติที่ต้องการ