पर्ल मॉड्यूल क्लास विधि बनाम सामान्य सबराउटिन

Question

तो मैं सोच रहा था कि एक मानक मॉड्यूल से पर्ल क्लास विधि और सामान्य सबराउटिन के बीच उपयोग में कोई अंतर है या नहीं। क्या आप एक बार एक दूसरे का उपयोग करेंगे? इस उदाहरण के लिए, मुझे लगता है कि किसी भी मॉड्यूल में कोई ऑब्जेक्ट विधियां मौजूद नहीं हैं।

त्वरित थोड़ा मुख्य यहाँ वर्ग:

#!/usr/local/bin/perl 

use strict; 
use warnings; 

use Foo; 
use Bar; 

my $arg1 = "blah"; 
my ($str1, $str2); 

$str1 = Foo::subroutine($arg1); 
$str2 = Bar->subroutine($arg1); 
exit(0); 

पैकेज फू पकड़ होगा मेरी साधारण सबरूटीन कॉल

use strict; 
use warnings; 

package Foo; 

sub subroutine { 
    my $arg = shift; 
    my $string = "Ordinary subroutine arg is $arg\n"; 
    return $string; 
} 
1; 

पैकेज बार मेरी कक्षा विधि कॉल

use strict; 
use warnings; 

package Bar; 

sub subroutine { 
    my $class = shift; 
    my $arg = shift; 
    my $string = "Class method arg is $arg\n"; 
    return $string; 
} 
1; 

आम तौर पर अगर मैं पकड़ होगा मैं पर्ल कोड लिख रहा हूं, मैं बस क्लास विधि विकल्प का उपयोग करूंगा (जैसे बार एक्सपैम्प के साथ ले), लेकिन मैंने एक पूर्व सहकर्मी से कुछ कोड पढ़ने के बाद इस सवाल पर विचार करना शुरू किया जो फू उदाहरण में वाक्यविन्यास का उपयोग करता था। दोनों एक ही चीज को स्वाभाविक रूप से करते हैं, लेकिन आंखों से मिलने से कहीं अधिक लगता है।

Answer 1

सामान्य सबराउटिन के साथ स्वाभाविक रूप से गलत कुछ भी नहीं है। वे ऐसा करते हैं जो उन्हें बहुत अच्छी तरह से करने के लिए डिज़ाइन किया गया है।

दूसरी तरफ के तरीके, सभी चीजें और अपनी कक्षा से प्राप्त होने वाली किसी भी कक्षा के साथ अच्छी तरह से खेलते हैं।

तो अपने आप से पूछना:

• आप उम्मीद कर रहे हैं/की अनुमति/लोगों को प्रोत्साहित करने के वर्ग है कि अपने मॉड्यूल से विरासत में लिखने के लिए?
• क्या आपका मॉड्यूल एक अधिक जटिल डेटा संरचना को परिभाषित करता है जो किसी ऑब्जेक्ट के रूप में अच्छी तरह से काम करता है?

या

• अपने मॉड्यूल उपयोगिताओं कि मौलिक डेटा प्रकार पर काम का एक पुस्तकालय है?

दोनों के लिए इस दुनिया में कमरे के बहुत सारे है, लेकिन आप अपने आप को (और अधिक सामान्यतः $self या) मॉड्यूल भर पाते हैं, जैसा कि आप Bar में किया था, $class अनदेखी, तो शायद आप बहुत दूर डिजाइन द्वारा चले गए हैं उन्हें विधियों के रूप में। सबसे महत्वपूर्ण बात यह है कि जो भी आपके मामूली ओओ "क्लास" से प्राप्त करने का प्रयास करता है, उसे एक अजीब आश्चर्य मिलेगा जब आपकी विधियां दो वर्गों के बीच अंतर नहीं बता सकतीं ...

Answer 2

यह कोड प्रतिमान का एक प्रश्न है।

आपके कोड के लिए एक गैर ऑब्जेक्ट उन्मुख दृष्टिकोण के साथ बिल्कुल कुछ भी गलत नहीं है। यह काम करता है, और यह अच्छी तरह से काम करता है।

हालांकि, ऑब्जेक्ट ओरिएंटेशन उन लाभों का एक समूह प्रदान करता है जो विचार करने योग्य हैं - और यदि वे कुछ चाहते हैं, तो ओओ रूट पर जाएं।

विशेष रूप से - वस्तुएं encapsulation प्रदान करती हैं। यह मेरे लिए मॉड्यूल लिखना और इसे उपयोग करने के लिए बहुत आसान बनाता है।आप ऊपर

require LWP::UserAgent; 

my $ua = LWP::UserAgent->new; 
$ua->timeout(10); 
$ua->env_proxy; 
$ua->agent('Mozilla/5.0'); 

my $response = $ua->get('http://search.cpan.org/'); 

if ($response->is_success) { 
    print $response->decoded_content; # or whatever 
} 
else { 
    die $response->status_line; 
} 

अब, के सभी विरासत में मिला सबरूटीन्स के माध्यम से कर सकता है: एक उदाहरण के लिए कहते हैं, LWP::UserAgent को देखो। - किसी भी तरह लौटने, एक की सफलता/असफल/परिणाम 'सहित -

• एक उप कि सभी मापदंडों आप की जरूरत ले लिया बिल्ड शायद: लेकिन अगर आप एक से अधिक पृष्ठों के कई फ़ेच करना चाहता था, आप या तो करना होगा एक सरणी में?
• अन्यथा आपके बाहरी मॉड्यूल में 'राज्य' छिपा हुआ है।

ओओ बस ऐसा करने का एक साफ और समझने योग्य तरीका है। (ओओ करने के अन्य लाभ भी हैं, जो मुझे यकीन है कि आप Google कर सकते हैं)।

Answer 3

निर्णायक यह है कि आपका Module एक ऑब्जेक्ट उन्मुख मॉड्यूल है या नहीं।

• तो Module बस सबरूटीन्स का एक संग्रह के लिए एक कंटेनर है, तो मैं इसे Exporter का उपयोग करें और बुला नाम अंतरिक्ष में अपनी सबरूटीन्स के एक सबसेट आयात करने के लिए अवसर प्रदान करते हैं की उम्मीद करेंगे। एक उदाहरण है, List::Util

• दूसरी ओर है अगर वहाँ एक निर्माता Module::new है, और इरादा है तो आप (तरीकों के साथ में सरल सबरूटीन्स मिश्रण नहीं करना चाहिए शायद निजी सबरूटीन्स को छोड़कर, OO तरीके से उपयोग करने के लिए है कि मॉड्यूल आंतरिक रूप से उपयोग करता है)। एक उदाहरण LWP::UserAgent

तो मैं सूत्रों इनमें से एक या अन्य, और नहीं के बीच में एक मिश्रण की तरह लिखे जाने की उम्मीद होती है। निस्संदेह ऐसी परिस्थितियां होती हैं जहां अंगूठे का नियम अनदेखा किया जाना चाहिए, लेकिन इस मामले में कुछ भी ध्यान नहीं आता है।

Foo.pm

use strict; 
use warnings; 

package Foo; 

use Exporter 'import'; 
our @EXPORT_OK = qw/ subroutine /; 

sub subroutine { 
    my ($arg) = @_; 
    "Ordinary subroutine arg is $arg\n"; 
} 

1; 

Bar.pm

use strict; 
use warnings; 

package Bar; 

sub new { 
    my $class = shift; 
    bless {}, $class; 
} 

sub subroutine { 
    my $class = shift; 
    my ($arg) = @_; 
    "Class method arg is $arg\n"; 
} 

1; 

main.pl

#!/usr/local/bin/perl 

use strict; 
use warnings; 

use Foo 'subroutine'; 
use Bar; 

my $arg1 = "blah"; 

print subroutine($arg1); 
print Bar->subroutine($arg1); 

उत्पादन

Ordinary subroutine arg is blah 
Class method arg is blah