पर्ल कैसे चल रही स्क्रिप्ट के साथ बातचीत करता है?

Question

मेरे पास एक पर्ल स्क्रिप्ट है जो कि रुचि रखने वालों के लिए Radmind नामक एक अलग उपयोगिता चलाती है) जिसमें फाइल सिस्टम को संपादित करने की क्षमता है। पर्ल स्क्रिप्ट इस प्रक्रिया से आउटपुट पर नज़र रखता है, इसलिए यह पूरे पूरे परिस्थिति में चल रहा होगा।

क्या होगा यदि स्क्रिप्ट द्वारा उपयोग की जाने वाली उपयोगिता स्क्रिप्ट फ़ाइल को संपादित करने का प्रयास करती है, यानी इसे एक नए संस्करण के साथ बदल दें? क्या पर्ल स्क्रिप्ट और किसी भी लिंक्ड लाइब्रेरी को इसके निष्पादन की शुरुआत में लोड करता है और तब स्क्रिप्ट फ़ाइल को अनदेखा करता है जब तक कि विशेष रूप से इसके साथ गड़बड़ न हो? या शायद, क्या सभी नरक टूट जाएंगे, और निष्पादन विफल हो सकता है या नहीं, इस पर निर्भर करता है कि नई फाइल किस प्रकार से चल रही है?

या शायद कुछ और पूरी तरह से? क्षमा करें अगर यह SuperUser — पर संबंधित है, तो मेरे लिए एक ग्रे क्षेत्र जैसा लगता है।

Answer 1

यह नहीं है काफी पावेल के जवाब राज्यों के रूप में सरल है, क्योंकि पर्ल वास्तव में एक स्वच्छ विभाजन नहीं है "सबसे पहले आप स्रोत संकलित करते हैं, फिर आप संकलित कोड चलाते हैं" [1], लेकिन मूल बिंदु खड़ा है: प्रत्येक स्रोत फ़ाइल को पूरी तरह से डिस्क से पढ़ा जाता है इससे पहले कि उस फ़ाइल में किसी भी कोड को संकलित या निष्पादित किया गया हो और उसके बाद के किसी भी बदलाव स्रोत फाई जब तक आप फाइल को दोबारा लोड करने और नए संस्करण के कोड को निष्पादित करने के लिए perl को विशेष रूप से निर्देशित नहीं करते हैं, तब तक चलने वाले कार्यक्रम पर ले का कोई प्रभाव नहीं पड़ेगा।

[1] BEGIN ब्लॉक, संकलन के दौरान कोड चलेंगे, जबकि इस तरह के eval और require के रूप में आदेशों रन-टाइम में अतिरिक्त कोड संकलन होगा

[2] अधिकांश eval या do, का उपयोग कर require और use जांच के बाद से होने की संभावना क्या फ़ाइल पहले ही लोड हो चुकी है और अगर इसे है तो इसे अनदेखा करें।

Answer 2

स्क्रिप्ट फ़ाइल को स्मृति में एक बार पढ़ा जाता है। इसके बाद आप फ़ाइल को किसी अन्य उपयोगिता से संपादित कर सकते हैं - या पर्ल स्क्रिप्ट से - यदि आप चाहें तो।

Answer 3

आपकी पर्ल स्क्रिप्ट पहले संकलित की जाएगी, फिर चलाएं; इसलिए चलने पर आपकी स्क्रिप्ट बदलना चलने वाले संकलित कोड को नहीं बदलेगा।

इस उदाहरण पर विचार:

#!/usr/bin/perl 

use strict; 
use warnings; 

push @ARGV, $0; 
$^I = ''; 

my $foo = 42; 
my $bar = 56; 

my %switch = (
    foo => 'bar', 
    bar => 'foo', 
); 

while (<ARGV>) { 
    s/my \$(foo|bar)/my \$$switch{$1}/; 
    print; 
} 

print "\$foo: $foo, \$bar: $bar\n"; 

और जब अनेक बार चलाने के परिणाम देख सकते हैं।

Answer 4

एक मजेदार प्रदर्शन के लिए, पर विचार

#! /usr/bin/perl 

die "$0: where am I?\n" unless -e $0; 

unlink $0 or die "$0: unlink $0: $!\n"; 

print "$0: deleted!\n"; 
for (1 .. 5) { 
    sleep 1; 
    print "$0: still running!\n"; 
} 

नमूना रन:

$ ./prog.pl 
./prog.pl: deleted! 
./prog.pl: still running! 
./prog.pl: still running! 
./prog.pl: still running! 
./prog.pl: still running! 
./prog.pl: still running!

Answer 5

जैसा कि अन्य ने कहा, स्क्रिप्ट स्मृति, संकलित और चलाने में पढ़ी जाती है। GBacon दिखाता है कि आप फ़ाइल को हटा सकते हैं और यह चलाएगा। नीचे दिया गया यह कोड दिखाता है कि आप फ़ाइल और do इसे बदल सकते हैं और नया व्यवहार प्राप्त कर सकते हैं।

use strict; 
use warnings; 
use English qw<$PROGRAM_NAME>; 

open my $ph, '>', $PROGRAM_NAME; 
print $ph q[print "!!!!!!\n";]; 
close $ph; 
do $PROGRAM_NAME; 

... ऐसा मत करो !!!

Answer 6

पर्ल स्क्रिप्ट सरल टेक्स्ट फाइलें हैं जो स्मृति में संकलित स्मृति में पढ़ी जाती हैं, और टेक्स्ट फ़ाइल स्क्रिप्ट को फिर से नहीं पढ़ा जाता है। (अपवाद मॉड्यूल हैं जो कुछ मामलों में संकलन और do और eval कथन के बाद व्याख्यात्मक दायरे में आते हैं ...)

एक अच्छी तरह से ज्ञात उपयोगिता है जो इस व्यवहार का शोषण करती है। सीपीएएन और इसके कई संस्करणों को देखें जो शायद आपके/usr/bin निर्देशिका में हैं। आपके सिस्टम पर पर्ल के प्रत्येक संस्करण के लिए एक सीपीएएन संस्करण है। सीपीएएन समझ जाएगा जब सीपीएएन का एक नया संस्करण उपलब्ध होगा, पूछें कि क्या आप इसे इंस्टॉल करना चाहते हैं, और यदि आप "वाई" कहते हैं तो यह नया संस्करण डाउनलोड करेगा और आप जिस डेटा को खोए बिना छोड़ देंगे, उसे खुद ही राहत दें।

इसका तर्क पालन करना मुश्किल नहीं है। पढ़ें/usr/bin/CPAN और फिर अपने सिस्टम पर $ Config :: Config {version} उत्पन्न होने वाले व्यक्तिगत संस्करणों का पालन करें।

चीयर्स।