Làm cách nào để tôi chỉnh sửa chuỗi if-if if if tuân thủ các nguyên tắc Clean Code của chú Bob?

Tôi đang cố gắng làm theo các đề xuất mã sạch của chú Bob và đặc biệt để giữ cho các phương thức ngắn.

Tôi thấy mình không thể rút ngắn logic này mặc dù:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Tôi không thể loại bỏ các elses và do đó tách toàn bộ thành các bit nhỏ hơn, vì "khác" trong "if if" giúp thực hiện - đánh giá các điều kiện đó là tốn kém và nếu tôi có thể tránh đánh giá các điều kiện bên dưới, gây ra một trong những điều kiện đầu tiên là sự thật, tôi muốn tránh chúng.

Ngay cả về mặt ngữ nghĩa, việc đánh giá điều kiện tiếp theo nếu đáp ứng trước đó không có ý nghĩa theo quan điểm kinh doanh.

chỉnh sửa: Câu hỏi này được xác định là một bản sao có thể có của các cách Thanh lịch để xử lý nếu (nếu khác) khác .

Tôi tin rằng đây là một câu hỏi khác nhau (bạn cũng có thể thấy điều đó bằng cách so sánh câu trả lời của những câu hỏi đó).

• Câu hỏi của tôi là kiểm tra điều kiện chấp nhận đầu tiên để kết thúc nhanh chóng .
• Câu hỏi được liên kết là cố gắng có tất cả các điều kiện để được chấp nhận để làm một cái gì đó. (thấy rõ hơn trong câu trả lời này cho câu hỏi đó: https://softwareengineering.stackexchange.com/a/122625/96955 )

Lý tưởng nhất là tôi nghĩ bạn nên trích xuất logic của mình để lấy mã / số cảnh báo vào phương thức riêng của nó. Vì vậy, mã hiện tại của bạn được giảm xuống

{
    addAlert(GetConditionCode());
}

và bạn có GetConditionCode () gói gọn logic để kiểm tra các điều kiện. Có lẽ cũng tốt hơn để sử dụng Enum hơn là một con số ma thuật.

private AlertCode GetConditionCode() {
    if (CheckCondition1()) return AlertCode.OnFire;
    if (CheckCondition2()) return AlertCode.PlagueOfBees;
    if (CheckCondition3()) return AlertCode.Godzilla;
    if (CheckCondition4()) return AlertCode.ZombieSharkNado;
    return AlertCode.None;
}

Phép đo quan trọng là độ phức tạp của mã, không phải kích thước tuyệt đối. Giả sử rằng các điều kiện khác nhau thực sự chỉ là các lệnh gọi hàm đơn, giống như các hành động không phức tạp hơn những gì bạn đã thể hiện, tôi nói rằng không có gì sai với mã. Nó đã đơn giản như nó có thể được.

Bất kỳ nỗ lực nào để "đơn giản hóa" hơn nữa sẽ thực sự làm phức tạp mọi thứ.

Tất nhiên, bạn có thể thay thế elsetừ khóa bằng một từ khóa returnnhư những người khác đã đề xuất, nhưng đó chỉ là vấn đề về phong cách, không phải là sự thay đổi về độ phức tạp.

Qua một bên:

Lời khuyên chung của tôi là, đừng bao giờ tôn giáo về bất kỳ quy tắc nào về mã sạch: Hầu hết các lời khuyên về mã hóa bạn thấy trên internet đều tốt nếu được áp dụng trong ngữ cảnh phù hợp, nhưng áp dụng triệt để lời khuyên đó ở mọi nơi có thể giúp bạn tham gia các IOCCC . Bí quyết là luôn luôn đạt được sự cân bằng cho phép con người dễ dàng suy luận về mã của bạn.

Sử dụng các phương pháp quá lớn, và bạn bị vặn. Sử dụng các chức năng quá nhỏ, và bạn bị vặn. Tránh các biểu thức ternary, và bạn đang say sưa. Sử dụng các biểu thức ternary ở khắp mọi nơi, và bạn đang say sưa. Nhận ra rằng có những nơi gọi hàm một dòng và những nơi gọi hàm 50 dòng (vâng, chúng tồn tại!). Nhận ra rằng có những nơi gọi cho các if()câu lệnh và có những nơi gọi cho ?:toán tử. Sử dụng kho vũ khí đầy đủ theo ý của bạn và cố gắng luôn sử dụng công cụ phù hợp nhất bạn có thể tìm thấy. Và hãy nhớ, đừng có tôn giáo ngay cả về lời khuyên này.

Điều gây tranh cãi là liệu điều này 'tốt hơn' so với đơn giản nếu ... cho bất kỳ trường hợp cụ thể nào. Nhưng nếu bạn muốn thử một cái gì đó khác thì đây là một cách phổ biến để làm điều đó.

Đặt điều kiện của bạn vào các đối tượng và đưa các đối tượng đó vào một danh sách

foreach(var condition in Conditions.OrderBy(i=>i.OrderToRunIn))
{
    if(condition.EvaluatesToTrue())
    {
        addAlert(condition.Alert);
        break;
    }
}

Nếu nhiều hành động được yêu cầu với điều kiện bạn có thể thực hiện một số đệ quy điên

void RunConditionalAction(ConditionalActionSet conditions)
{
    foreach(var condition in conditions.OrderBy(i=>i.OrderToRunIn))
    {
        if(condition.EvaluatesToTrue())
        {
            RunConditionalAction(condition);
            break;
        }
    }
}

Chắc chắn đúng. Điều này chỉ hoạt động nếu bạn có một mô hình logic của bạn. Nếu bạn cố gắng thực hiện một hành động đệ quy có điều kiện siêu chung thì việc thiết lập cho đối tượng sẽ phức tạp như câu lệnh if gốc. Bạn sẽ phát minh ra ngôn ngữ / khung mới của riêng bạn.

Nhưng ví dụ của bạn không có mẫu

Một trường hợp sử dụng phổ biến cho mẫu này sẽ là xác nhận. Thay vì :

bool IsValid()
{
    if(condition1 == false)
    {
        throw new ValidationException("condition1 is wrong!");
    }
    elseif(condition2 == false)
    {
    ....

}

Trở thành

[MustHaveCondition1]
[MustHaveCondition2]
public myObject()
{
    [MustMatchRegExCondition("xyz")]
    public string myProperty {get;set;}
    public bool IsValid()
    {
        conditions = getConditionsFromReflection()
        //loop through conditions
    }
}

Cân nhắc sử dụng return;sau khi một điều kiện đã thành công, nó giúp bạn tiết kiệm tất cả các elses. Bạn thậm chí có thể return addAlert(1)trực tiếp nếu phương thức đó có giá trị trả về.

Đôi khi tôi đã thấy các công trình như thế này được coi là sạch hơn:

switch(true) {
    case cond1(): 
        statement1; break;
    case cond2():
        statement2; break;
    case cond3():
        statement3; break;
    // .. etc
}

Ternary với khoảng cách đúng cũng có thể là một thay thế gọn gàng:

cond1() ? statement1 :
cond2() ? statement2 :
cond3() ? statement3 : (null);

Tôi đoán bạn cũng có thể thử tạo một mảng với cặp chứa điều kiện và hàm và lặp lại cho đến khi điều kiện đầu tiên được đáp ứng - điều mà tôi thấy sẽ bằng với câu trả lời đầu tiên của Ewan.

Là một biến thể của câu trả lời của @ Ewan, bạn có thể tạo một chuỗi (thay vì "danh sách phẳng") các điều kiện như sau:

abstract class Condition {
  private static final  Condition LAST = new Condition(){
     public void alertOrPropagate(DisplayInterface display){
        // do nothing;
     }
  }
  private Condition next = Last;

  public Condition setNext(Condition next){
    this.next = next;
    return this; // fluent API
  }

  public void alertOrPropagate(DisplayInterface display){
     if(isConditionMeet()){
         display.alert(getMessage());
     } else {
       next.alertOrPropagate(display);
     }
  }
  protected abstract boolean isConditionMeet();
  protected abstract String getMessage();  
}

Bằng cách này, bạn có thể áp dụng các điều kiện của mình theo thứ tự xác định và cơ sở hạ tầng (lớp trừu tượng được hiển thị) bỏ qua các kiểm tra còn lại sau khi lần đầu tiên được đáp ứng.

Đây là nơi vượt trội so với phương pháp "danh sách phẳng" nơi bạn phải thực hiện "bỏ qua" trong vòng lặp áp dụng các điều kiện.

Bạn chỉ cần thiết lập chuỗi điều kiện:

Condition c1 = new Condition1().setNext(
  new Condition2().setNext(
   new Condition3()
 )
);

Và bắt đầu đánh giá bằng một cuộc gọi đơn giản:

c1.alertOrPropagate(display);

Trước hết, mã gốc không phải là IMO khủng khiếp. Điều đó khá dễ hiểu và vốn dĩ không có gì xấu cả.

Sau đó, nếu bạn không thích nó, hãy xây dựng ý tưởng của @ Ewan để sử dụng một danh sách nhưng loại bỏ foreach breakmô hình hơi không tự nhiên của anh ấy :

public class conditions
{
    private List<Condition> cList;
    private int position;

    public Condition Head
    {
        get { return cList[position];}
    }

    public bool Next()
    {
        return (position++ < cList.Count);
    }
}


while not conditions.head.check() {
  conditions.next()
}
conditions.head.alert()

Bây giờ hãy điều chỉnh điều này bằng ngôn ngữ bạn chọn, biến mỗi thành phần của danh sách thành một đối tượng, một tuple, bất cứ điều gì và bạn đều tốt.

EDIT: có vẻ như nó không rõ ràng như tôi nghĩ, vì vậy hãy để tôi giải thích thêm. conditionslà một danh sách sắp xếp của một số loại; headlà yếu tố hiện tại đang được điều tra - lúc đầu, nó là yếu tố đầu tiên của danh sách và mỗi lần next()được gọi nó sẽ trở thành yếu tố sau; check()và alert()là checkConditionX()và addAlert(X)từ OP.

Câu hỏi thiếu một số chi tiết cụ thể. Nếu các điều kiện là:

• có thể thay đổi hoặc
• lặp đi lặp lại trong các phần khác của ứng dụng hoặc hệ thống hoặc
• sửa đổi trong một số trường hợp nhất định (như các bản dựng khác nhau, thử nghiệm, triển khai)

hoặc nếu nội dung trong addAlertphức tạp hơn, thì một giải pháp có thể tốt hơn có thể nói là c # sẽ là:

//in some central spot
IEnumerable<Tuple<Func<bool>, int>> Conditions = new ... {
  Tuple.Create(CheckCondition1, 1),
  Tuple.Create(CheckCondition2, 2),
  ...
}

//at the original place
var matchingCondition = Conditions.Where(c=>c.Item1()).FirstOrDefault();
if(matchingCondition != null) 
  addAlert(matchingCondition.Item2)

Tuples không quá đẹp trong c # <8, nhưng được chọn để kết hợp.

Ưu điểm của phương pháp này, ngay cả khi không có tùy chọn nào ở trên áp dụng, đó là cấu trúc được gõ tĩnh. Bạn không thể vô tình làm hỏng, nói, thiếu một else.

Cách tốt nhất để giảm độ phức tạp Cyclomatic trong trường hợp bạn có nhiều if->then statementslà sử dụng từ điển hoặc danh sách (phụ thuộc ngôn ngữ) để lưu trữ giá trị khóa (nếu giá trị câu lệnh hoặc một số giá trị) và sau đó là kết quả giá trị / hàm.

Ví dụ: thay vì (C #):

if (i > 10) { return "Two"; }
else if (i > 8) { return "Four" }
else if (i > 4) { return "Eight" }
return "Ten";  //etc etc say anything after 3 or 4 values

Tôi có thể đơn giản

var results = new Dictionary<int, string>
{
  { 10, "Two" },
  { 8, "Four"},
  { 4, "Eight"},
  { 0, "Ten"},
}

foreach(var key in results.Keys)
{
  if (i > results[key]) return results.Values[key];
}

Nếu bạn đang sử dụng các ngôn ngữ hiện đại hơn, bạn có thể lưu trữ nhiều logic hơn thì cũng chỉ đơn giản là các giá trị (c #). Đây thực sự chỉ là các hàm nội tuyến, nhưng bạn cũng có thể chỉ đến các chức năng khác nếu logic là để đặt thẳng hàng.

var results = new Dictionary<Func<int, bool>, Func<int, string>>
{
  { (i) => return i > 10; ,
    (i) => return i.ToString() },
  // etc
};

foreach(var key in results.Keys)
{ 
  if (key(i)) return results.Values[key](i);
}

Tôi đang cố gắng làm theo các đề xuất mã sạch của chú Bob và đặc biệt để giữ cho các phương thức ngắn.

Tôi thấy mình không thể rút ngắn logic này mặc dù:

if (checkCondition()) {addAlert(1);}
else if (checkCondition2()) {addAlert(2);}
else if (checkCondition3()) {addAlert(3);}
else if (checkCondition4()) {addAlert(4);}

Mã của bạn đã quá ngắn, nhưng bản thân logic không nên thay đổi. Thoạt nhìn, có vẻ như bạn đang lặp lại chính mình với bốn cuộc gọi đến checkCondition()và chỉ rõ ràng là mỗi cuộc gọi sẽ khác nhau sau khi đọc lại mã cẩn thận. Bạn nên thêm định dạng và tên hàm thích hợp, ví dụ:

if (is_an_apple()) {
  addAlert(1);
}
else if (is_a_banana()) {
  addAlert(2);
}
else if (is_a_cat()) {
  addAlert(3);
}
else if (is_a_dog()) {
  addAlert(4);
}

Mã của bạn nên được đọc trên tất cả những thứ khác. Đã đọc một vài cuốn sách của chú Bob, tôi tin rằng đó là thông điệp mà anh ấy luôn cố gắng vượt qua.

Giả sử tất cả các hàm được thực hiện trong cùng một thành phần, bạn có thể làm cho các hàm giữ một số trạng thái để thoát khỏi nhiều nhánh trong luồng.

EG: checkCondition1()sẽ trở thành evaluateCondition1(), trên đó nó sẽ kiểm tra nếu điều kiện trước được đáp ứng; nếu vậy, thì nó lưu trữ một số giá trị được lấy bởi getConditionNumber().

checkCondition2()sẽ trở thành evaluateCondition2(), trên đó nó sẽ kiểm tra nếu các điều kiện trước được đáp ứng. Nếu điều kiện trước không được đáp ứng, thì nó sẽ kiểm tra kịch bản điều kiện 2, lưu vào bộ đệm một giá trị cần lấy getConditionNumber(). Và như vậy.

clearConditions();
evaluateCondition1();
evaluateCondition2();
evaluateCondition3();
evaluateCondition4();
if (anyCondition()) { addAlert(getConditionNumber()); }

BIÊN TẬP:

Đây là cách kiểm tra các điều kiện đắt tiền sẽ cần phải được thực hiện để phương pháp này hoạt động.

bool evaluateCondition34() {
    if (!anyCondition() && A && B && C) {
        conditionNumber = 5693;
        return true;
    }
    return false;
}

...

bool evaluateCondition76() {
    if (!anyCondition() && !B && C && D) {
        conditionNumber = 7658;
        return true;
    }
    return false;
}

Do đó, nếu bạn có quá nhiều séc đắt tiền được thực hiện và những thứ trong mã này vẫn ở chế độ riêng tư, phương pháp này giúp duy trì nó, cho phép thay đổi thứ tự của séc nếu cần thiết.

clearConditions();
evaluateCondition10();
evaluateCondition9();
evaluateCondition8();
evaluateCondition7();
...
evaluateCondition34();
...
evaluateCondition76();

if (anyCondition()) { addAlert(getConditionNumber()); }

Câu trả lời này chỉ cung cấp một số gợi ý thay thế từ các câu trả lời khác và có thể sẽ không tốt hơn mã gốc nếu chúng tôi chỉ xem xét 4 dòng mã. Mặc dù, đây không phải là một phương pháp khủng khiếp (và không làm cho bảo trì khó khăn hơn như những người khác đã nói) cho kịch bản tôi đã đề cập (quá nhiều kiểm tra, chỉ có chức năng chính như tiếp xúc với công chúng, tất cả các chức năng chi tiết thi hành cùng lớp).

Bất kỳ nhiều hơn hai mệnh đề "khác" buộc người đọc mã phải đi qua toàn bộ chuỗi để tìm ra một điều quan tâm. Sử dụng một phương thức như: void AlertUponCondition (Điều kiện điều kiện) {switch (condition) {case condition.Con1: ... break; trường hợp Điều kiện.Con2: ... nghỉ; vv ...} Trong đó "Điều kiện" là một enum thích hợp. Nếu cần, trả về một bool hoặc giá trị. Gọi nó như thế này: AlertOnCondition (GetCondition ());

Nó thực sự không thể đơn giản hơn, VÀ nó nhanh hơn chuỗi if-if một khi bạn vượt quá một vài trường hợp.

Tôi không thể nói cho tình huống cụ thể của bạn vì mã không cụ thể, nhưng ...

mã như thế thường là một mùi cho một mô hình OO thiếu. Bạn thực sự có bốn loại, mỗi loại được liên kết với loại thay thế riêng của nó, nhưng thay vì nhận ra các thực thể này và tạo một thể hiện lớp cho mỗi loại, bạn coi chúng là một thứ và cố gắng bù đắp cho nó sau, tại một thời điểm bạn thực sự cần phải biết những gì bạn đang giải quyết để tiến hành.

Đa hình có thể phù hợp với bạn tốt hơn.

Hãy nghi ngờ về mã với các phương thức dài chứa các cấu trúc if-then dài hoặc phức tạp. Bạn thường muốn một cây lớp ở đó với một số phương thức ảo.