क्या मुझे पर्ले में बयान देते हुए घोंसला से बचना चाहिए?

Question

मैं कुछ पर्ल कर रहा हूं और अपना घोंसला देख रहा हूं "अगर" कथन मुझे पागल कर रहा है। मैंने उनमें से कुछ को दूसरे खंड में गार्ड ब्लॉक के साथ कम करने में कामयाब रहे, लेकिन मैं यहां फंस गया हूं।

क्या आपको लगता है कि मैं कोड छोड़ सकता हूं, या क्या निम्नलिखित को दोबारा करने का एक "उचित" तरीका है? (मैं पर्ल के लिए अपेक्षाकृत नया मानता हूं)

यह वास्तव में एक सबराउटिन है जो सूची (बाहरी फ़ाइल) के प्रत्येक पैरामीटर पर उपयोगकर्ता इनपुट मांगता है। $ [3] मिलान पैटर्न है, $ [2] माना गया पैरामीटर (NULL यदि कोई नहीं है) के लिए डिफ़ॉल्ट मान है, $ _ [1] निर्दिष्ट करता है कि यह अनिवार्य है या नहीं। 'अगला' कथन अगले पैरामीटर को पढ़ता है (जबकि लूप)।

हर किसी की मदद से (धन्यवाद!), यहां नवीनतम संस्करण है।

100   if ($input ne '' && ($input !~ $match || $input =~ /'.+'/)) { 
101    print "! Format not respected. Match : /$match/ (without \' \')\n"; 
102    next; 
103   } 
104   if ($input eq '') { 
105    if ($default eq 'NULL') { 
106     if ($manda eq 'y') { 
107      print "! Mandatory parameter not filled in\n"; 
108      next; 
109     } 
110     print "+ Ignoring parameter.\n"; 
111     $input = ''; 
112    } 
113    else { 
114     print "+ Using default value\n"; 
115     $input = $default; 
116    } 
117   } 

---

98  if($input eq ''){ 
99    if($_[2] eq 'NULL'){ 
100     if($_[1] eq 'y'){ 
101      print "! Mandatory parameter not filled in\n"; 
102      next; 
103     } 
104     else{ 
105      print "+ Ignoring parameter.\n"; 
106      $input = ''; 
107     } 
108    } 
109    else{ 
110     print "+ Using default value\n"; 
111     $input = $_[2]; 
112    } 
113   } 
114   elsif($input !~ $_[3] || $input =~ /'.+'/){ 
115     print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
116     next; 
117    } 
118   } 

Answer 1

यहाँ अराजकता के एक से थोड़ा अधिक पठनीय संस्करण है 'जवाब:

# Set sane variable names... 
my ($is_required, $default, $pattern) = @_ 

# Convert the external string convention for simpler evaluation... 
$default = undef if $default eq 'NULL' 

# Refuse problematic input before going any further... 
if ($input ne '' && $input !~ $pattern || $input =~ /'.+'/) { 
    print "! Format not respected. Match : /$pattern/ (without \' \')\n"; 
    next; 
} 


# If there was no input string... 
if($input eq '') { 

    # Set the default, if one was provided... 
    if($default) { 
     print "+ Using default value\n"; 
     $input = $default; 
    } 
    # otherwise, complain if a default was required... 
    else { 
     if($is_required eq 'y'){ 
      print "! Mandatory parameter not filled in\n"; 
      next; 
     } 
     print "+ Ignoring parameter (no input or default provided).\n"; 
    } 
} 

महत्वपूर्ण बिंदु हैं:

• आपसे किसी और की जरूरत नहीं है अगर आप के साथ वर्तमान पाश बाहर निकलने रहे हैं अगले
• असाधारण मामलों को पहले
• पर संभाला जाना चाहिए नामित चर का उपयोग करके पठनीयता में काफी सुधार

Answer 2

अगर बयान तो मुझे लगता है कि उन लोगों के साथ कुछ भी गलत नहीं है, तो आप तर्क नेस्ट की आवश्यकता है।

हालांकि, अगर आप सिर्फ एक छोटे से अधिक सफेद स्थान और

का उपयोग करना द्वारा

1. अपने कोड की पठनीयता में सुधार कर सकता है के बजाय अपने खुद के वैरिएबल का उपयोग कर @_

Isn 'पर सीधे ऑपरेटिंग तक यह थोड़ा और पठनीय नहीं है?

98  if ($input eq '') { 
99    if ($default eq 'NULL'){ 
100     if ($input eq 'y'){ 
101      print "! Mandatory parameter not filled in\n"; 
102      next; 
103     } 
104     else { 
105      print "+ Ignoring parameter.\n"; 
106      $input = ''; 
107     } 
108    } 
109    else { 
110     print "+ Using default value\n"; 
111     $input = $default; 
112    } 
113   } 
114   elsif ($input !~ $foo || $input =~ /'.+'/) { 
115     print "! Format not respected. Match : /$foo/ (without \' \')\n"; 
116     next; 
117    } 
118   } 

Answer 3

सामान्य अभ्यास आपके सरणी इंडेक्स के लिए स्थिरांक को परिभाषित करना है, और उन्हें सार्थक नाम देना है। जैसे:

use constant MANDATORY => 1, 
      DEFAULT => 2, 
      PATTERN => 3; 
... 
if($_[DEFAULT] eq 'NULL') { 
    ... 
} 

घोंसले के रूप में

जहां तक ​​- आप अक्सर (नेस्टिंग कम के स्तर पर रखने के अर्थ) मांगपत्र को कम करने की कोशिश करनी चाहिए, लेकिन कोड समझा जा सकता रखने की कीमत पर ऐसा कभी नहीं। मुझे घोंसले के स्तर के साथ कोई समस्या नहीं है, लेकिन यह आपके कोड का एक छोटा सा कट भी है। यदि यह वास्तव में एक मुद्दा है, तो आप अलग-अलग subroutines में शर्तों को तोड़ सकते हैं।

Answer 4

यह देखते हुए कि आप शायद नहीं तो बिल्कुल नहीं।

क्या बेहतर हो सकता है एक switch case है एक स्पेगेटी goto करेंगे,।

Answer 5

if($input ne '' && ($input !~ $_[3] || $input =~ /'.+'/)) { 
    print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
    next; 
} 
if($input eq '') { 
    if($_[2] eq 'NULL') { 
     if($_[1] eq 'y'){ 
      print "! Mandatory parameter not filled in\n"; 
      next; 
     } 
     print "+ Ignoring parameter.\n"; 
     $input = ''; 
    } else { 
     print "+ Using default value\n"; 
     $input = $_[2]; 
    } 
} 

Answer 6

यदि आप अन्य सभी को पसंद नहीं करते हैं तो आप निम्न को सरल बना सकते हैं।

if($input eq ''){ 
    $input = $_[2]; 
    $output = "+ Using default value\n"; 
    if($_[2] eq 'NULL'){ 
     $input = ''; 
     $output = "+ Ignoring parameter.\n"; 
     if($_[1] eq 'y'){ 
      $output = "! Mandatory parameter not filled in\n"; 
     } 
    } 
} 
elsif($input !~ $_[3] || $input =~ /'.+'/){ 
    $output = "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
} 
print $output; 

Answer 7

मुख्य चिंता कोड को पठनीय रखने के लिए है।

यदि आप कथन के साथ नेस्टेड के साथ पठनीय कोड प्राप्त कर सकते हैं, तो आगे बढ़ें। लेकिन हर समय सामान्य ज्ञान सक्रिय रखें।

Answer 8

मुझे लगता है आप इसे बाहर समतल तर्क संयोजन कर सकता है:

if(($input eq '')&&($_[2] eq 'NULL')&&($_[1] eq 'y')){ 
    print "! Mandatory parameter not filled in\n"; 
    next; 
} 

elsif(($input eq '')&&($_[2] eq 'NULL')){ 
    print "+ Ignoring parameter.\n"; 
    $input = ''; 
} 

elsif($input eq ''){ 
    print "+ Using default value\n"; 
    $input = $_[2]; 
    next; 
} 


elsif($input !~ $_[3] || $input =~ /'.+'/){ 
    print "! Format not respected. Match : /$_[3]/ (without \' \')\n"; 
} 

print $output; 

तो फिर तुम एक स्विच इस्तेमाल कर सकते हैं यह थोड़ा बेहतर बनाने के लिए।

Answer 9

मुझे लगता है कि घोंसले के संबंध में चिंताओं के लिए मुख्य (यदि न केवल) कारण एल्गोरिदम जटिलता है। अन्य मामलों में आपको पठनीयता और रखरखाव के बारे में चिंता करनी चाहिए, जिसे प्रोपोयर टिप्पणी और इंडेंटेशन के साथ संबोधित किया जा सकता है।

मैं हमेशा मेरा पुराने कोड, न केवल पठनीयता पर प्रतिक्रिया करने के लिए, लेकिन यह भी तकनीक पर पढ़ने के लिए maintanability में एक अच्छा व्यायाम लगता है ...

Answer 10

एक वैकल्पिक दृष्टिकोण है कि कभी कभी पठनीयता के साथ मदद करता है कुछ या सभी डाल करने के लिए है अच्छी तरह से नाम कोड संदर्भ में शाखाओं के। यहां विचार पर एक शुरुआत है:

$format_not_respected = sub { 
    return 0 if ...; 
    print "! Format not respected...."; 
    return 1; 
} 
$missing_mandatory_param = sub { 
    return 0 if ...; 
    print "! Mandatory parameter not filled in\n"; 
    return 1; 
} 

next if $format_not_respected->(); 
next if $missing_mandatory_param->(); 
etc...