डिफ़ॉल्ट चर $_ पर्ल में

सभी चर में पर्ल प्रोग्रामिंग भाषा के होते हैं, जो एक ही मूल्य के साथ शुरू, डॉलर के $. उदाहरण के लिए, आप कर सकते हैं एक चर बनाएँ $str या $var.

पर्ल में वहाँ है एक विशेष चर $_. वहाँ रहे हैं कई स्थानों में प्रोग्रामिंग भाषा पर्ल जहां यदि आप नहीं स्पष्ट रूप से निर्दिष्ट चर, चर का उपयोग किया जाएगा $_. वहाँ रहे हैं कुंजी शब्दों है कि मूल्यों को पढ़ने से यह चर है, और वहाँ रहे हैं उन जो मूल्यों के सेट में चर. लेकिन इस चर में बचाने के लिए अपने दम पर मूल्य.

कीवर्ड पढ़ा है कि मूल्य से $_

एक उदाहरण के रूप में, एक खोजशब्द है कि पढ़ता के मूल्य डिफ़ॉल्ट चर नेतृत्व print. यदि आप निर्दिष्ट print के बिना तर्क है, स्क्रीन प्रिंट होगा सामग्री का एक चर $_.

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

$_ = 'Hello';

print;

सबसे पहले, हम में बचाया एक चर $_ लाइन 'Hello'(ध्यान दें हम इस्तेमाल नहीं किया है कुंजी शब्द my).

और फिर हम उपयोग print, लेकिन यह नहीं भेज किसी भी तर्क. में इस का उपयोग print की सामग्री प्रदर्शित करता है एक चर $_. print; के रूप में ही है print $_;

परिणाम — कार्यक्रम प्रदर्शित करेगा पाठ Hello.

कीवर्ड print, say के बिना इस्तेमाल किया जब तर्क का इस्तेमाल किया जाता है डिफ़ॉल्ट चर $_. यह दिलचस्प है कि कुंजी शब्द warn का उपयोग करते समय कोई तर्क के साथ चर $_ का उपयोग नहीं करते.

एक और उदाहरण का उपयोग करते समय डिफ़ॉल्ट चर है एक नियमित अभिव्यक्ति है । आदेश में लागू करने के लिए एक नियमित अभिव्यक्ति के लिए एक चर आप की जरूरत लिखने के लिए $str =~ /.../. और अगर आप सिर्फ लिखने /.../में, यह है के रूप में एक ही $_ =~ /.../.

यहाँ है एक छोटे से कोड उदाहरण:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

$_ = 'Hello';

if (/ll/) {
    print 'yes';
} else {
    print 'no';
}

हालत if (/ll/) { जाँच करें कि क्या चर $_ दो पत्र l में एक पंक्ति. क्योंकि लाइन में'Hello' वहाँ रहे हैं इन दो अक्षरों, तो कोड चलाता है print 'yes';, प्रदर्शित करता है जो पाठ yes पर स्क्रीन.

कीवर्ड डाल दिया है कि मूल्य में $_

सबसे अक्सर इस्तेमाल किया है कि कुंजी शब्द में परिवर्तन चर के मूल्य $_ है foreach. यहाँ है एक उदाहरण कोड:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;
use feature qw(say);

foreach ('one', 'two', 'three') {
    say;
}

यहाँ पाश के शरीर foreach किया जाता है 3 बार प्रत्येक आइटम के लिए सूची से 'one', 'two', 'three'. इससे पहले कि प्रत्येक निष्पादन पाश के शरीर में चर $_ में रखा गया है, अगले तत्व सूची से. तो आप रिकॉर्ड कर सकते हैं इस चक्र के साथ एक स्पष्ट संकेत का क्या मूल्य में रखा जाना चाहिए एक चर $_: foreach $_ ('one', 'two', 'three') {

और फिर हम उपयोग say; , जो एक ही है के रूप में say $_;.

एक और तरीका करने के लिए जगह में है एक मूल्य का एक चर $_ का उपयोग करने के लिए while (<>) {. यहाँ कोड है:

#!/usr/bin/perl

while (<>) {
    print " * $_";
}

इस कोड पढ़ता है STDIN और outputs के प्रत्येक लाइन के रूप में एक markdown सूची. यहाँ का एक उदाहरण है कैसे काम करने के लिए इस कोड के साथ कंसोल में:

$ perl -e 'print "1\n2\n3\n"' | perl script.pl
 * 1
 * 2
 * 3

सबसे पहले, हम पर्ल odnotrahniki, प्रदर्शित करता है जो तीन लाइनों, प्रत्येक पंक्ति आंकड़ा है । और फिर हम पर पुनः निर्देशित इस आउटपुट के इनपुट के लिए एक स्क्रिप्ट है कि हम सिर्फ लिखा था. पाश के शरीर while (<>) { किया जाता है की प्रत्येक पंक्ति के लिए इनपुट, और इस स्ट्रिंग में रखा गया है चर $_.

उदाहरण

यहाँ का एक और उदाहरण है कोड है, जो सक्रिय रूप से इस्तेमाल किया डिफ़ॉल्ट चर $_:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

my @arr = map { ucfirst } grep { /^.{3}\z/ } ('one', 'two', 'three');

print Dumper \@arr;

यदि आप इस कार्यक्रम को चलाने के लिए, यह स्क्रीन पर दिखाई देगा:

$VAR1 = [
          'One',
          'Two'
        ];

तो, यहाँ क्या हो रहा है. अभिव्यक्ति में है जो एक काम है, मानों की सरणी के लिए @arr आप की जरूरत करने के लिए सही से पढ़ने के लिए छोड़ दिया है ।

  • सबसे पहले, हम की एक सूची की पहचान तीन तार ('one', 'two', 'three')
  • तो, हम इस्तेमाल किया कीवर्ड grep करने के लिए इस सूची में. grep स्थानों में से प्रत्येक तत्व मूल सूची करने के लिए एक चर $_ और चेक लिखा है, जो घुंघराले कोष्ठक में. अगर इस परीक्षा में सच रिटर्न, तो grep के मूल्य देता है सूची. इस उदाहरण में, घुंघराले कोष्ठक होते हैं, एक नियमित अभिव्यक्ति है कि लागू किया जाता है करने के लिए डिफ़ॉल्ट चर. यह नियमित रूप से अभिव्यक्ति को संतुष्ट करना होगा केवल तार से मिलकर बनता है कि वास्तव में तीन अक्षर. परिणाम के grep की एक सूची है दो तार ('one', 'two').
  • एक सूची के दो तत्वों में गिर map. इस खोजशब्द डालता है प्रत्येक सूची में आइटम डिफ़ॉल्ट चर और निष्पादित कोड में लिखा है कि घुंघराले कोष्ठक. परिणाम देता है जो कोड की एक सूची मद है कि रिटर्न map. इस उदाहरण में हम इस समारोह का उपयोग करें lcfirst, जो रिटर्न एक स्ट्रिंग जिसका पहले अक्षर पूंजीकृत है. यदि इस समारोह में निर्दिष्ट नहीं करते हैं, एक तर्क है, तो यह काम करता है के साथ डिफ़ॉल्ट चर.

सरकारी दस्तावेज

यहाँ एक टुकड़ा के उत्पादन perldoc perlvar समर्थक चर $_:

    $_      The default input and pattern-searching space. The following
            pairs are equivalent:

                while (<>) {...}    # equivalent only in while!
                while (defined($_ = <>)) {...}

                /^Subject:/
                $_ =~ /^Subject:/

                tr/a-z/A-Z/
                $_ =~ tr/a-z/A-Z/

                chomp
                chomp($_)

            Here are the places where Perl will assume $_ even if you don't
            use it:

            *  The following functions use $_ as a default argument:

               abs, alarm, chomp, chop, chr, chroot, cos, defined, eval,
               evalbytes, exp, fc, glob, hex, int, lc, lcfirst, length, log,
               lstat, mkdir, oct, ord, pos, print, printf, quotemeta,
               readlink, readpipe, ref, require, reverse (in scalar context
               only), rmdir, say, sin, split (for its second argument),
               sqrt, stat, study, uc, ucfirst, unlink, unpack.

            *  All file tests ("-f", "-d") except for "-t", which defaults
               to STDIN. See "-X" in perlfunc

            *  The pattern matching operations "m//", "s///" and "tr///"
               (aka "y///") when used without an "=~" operator.

            *  The default iterator variable in a "foreach" loop if no other
               variable is supplied.

            *  The implicit iterator variable in the "grep()" and "map()"
               functions.

            *  The implicit variable of "given()".

            *  The default place to put the next value or input record when
               a "", "readline", "readdir" or "each" operation's result
               is tested by itself as the sole criterion of a "while" test.
               Outside a "while" test, this will not happen.

            $_ is a global variable.

            However, between perl v5.10.0 and v5.24.0, it could be used
            lexically by writing "my $_". Making $_ refer to the global $_
            in the same scope was then possible with "our $_". This
            experimental feature was removed and is now a fatal error, but
            you may encounter it in older code.

            Mnemonic: underline is understood in certain operations.

संबंधित विषयों

अन्य लेख