Perl Language
फ़ाइल I / O (फ़ाइलें पढ़ना और लिखना)

पैरामीटर

टिप्पणियों

एक फ़ाइल से पढ़ना

my $filename = '/path/to/file';

open my $fh, '<', $filename or die "Failed to open file: $filename"; 
    
# You can then either read the file one line at a time...
while(chomp(my $line = <$fh>)) {
    print $line . "\n";
}

# ...or read whole file into an array in one go
chomp(my @fileArray = <$fh>); 

यदि आप जानते हैं कि आपकी इनपुट फ़ाइल UTF-8 है, तो आप एन्कोडिंग निर्दिष्ट कर सकते हैं:

open my $fh, '<:encoding(utf8)', $filename or die "Failed to open file: $filename";

फ़ाइल से पढ़ने के बाद, फ़ाइलहैंड को बंद किया जाना चाहिए:

close $fh or warn "close failed: $!";

यह भी देखें: एक चर में एक फ़ाइल पढ़ना

किसी फ़ाइल को पढ़ने का दूसरा और तेज़ तरीका फ़ाइल :: स्लॉपर मॉड्यूल का उपयोग करना है। यदि आप कई फ़ाइलों के साथ काम करते हैं तो यह उपयोगी है।

use File::Slurper;
my $file = read_text("path/to/file"); # utf8 without CRLF transforms by default
print $file; #Contains the file body

इसे भी देखें: [गालियों के साथ फाइल पढ़ना]

एक फ़ाइल में लिखें

यह कोड लिखने के लिए एक फ़ाइल खोलता है। यदि फ़ाइल नहीं खोली जा सकी तो एक त्रुटि देता है। साथ ही फाइल को अंत में बंद कर देता है।

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

# Open "output.txt" for writing (">") and from now on, refer to it as the variable $fh.
open(my $fh, ">", "output.txt")
# In case the action failed, print error message and quit.
or die "Can't open > output.txt: $!";

अब हमारे पास लिखने के लिए एक खुली फाइल तैयार है जिसे हम $fh माध्यम से एक्सेस करते हैं (इस चर को फाइलहैंडल कहा जाता है)। अगला हम print ऑपरेटर का उपयोग करके उस फ़ाइल में आउटपुट को निर्देशित कर सकते हैं:

# Print "Hello" to $fh ("output.txt").
print $fh "Hello";
# Don't forget to close the file once we're done!
close $fh or warn "Close failed: $!";

open ऑपरेटर के पास अपना पहला पैरामीटर के रूप में एक स्केलर चर (इस मामले में $fh ) है। चूंकि इसे open ऑपरेटर में परिभाषित किया गया है इसलिए इसे एक फ़ाइलहैंडल माना जाता है। दूसरा पैरामीटर ">" (इससे बड़ा) परिभाषित करता है कि फ़ाइल लिखने के लिए खोली गई है। अंतिम पैरामीटर डेटा को लिखने के लिए फ़ाइल का पथ है।

फ़ाइल में डेटा लिखने के लिए, print ऑपरेटर filehandle के साथ प्रयोग किया जाता है। ध्यान दें कि print ऑपरेटर में फ़ाइलहैंडल और स्टेटमेंट के बीच कोई कॉमा नहीं है, केवल व्हाट्सएप है ।

पढ़ने के लिए एक FileHandle खोलना

जेनेरिक ASCII टेक्स्ट फाइलें खोलना

open my $filehandle, '<', $name_of_file or die "Can't open $name_of_file, $!";

बाइनरी फ़ाइलें खोलना

open my $filehandle, '<:raw', 'path/to/file' or die "Can't open $name_of_file, $!";

UTF8 टेक्स्ट फाइलें खोलना

open my $filehandle, '<:raw:encoding(utf-8)', 'path/to/file' 
   or die "Can't open $name_of_file, $!";

फ़ाइल से पढ़ना और लिखना

पाठ फ़ाइलों को पढ़ने और लिखने से पहले आपको पता होना चाहिए कि किस एन्कोडिंग का उपयोग करना है। एन्कोडिंग पर अधिक जानकारी के लिए पर्ल यूनिकोड प्रलेखन देखें । यहां हम UTF-8 की सेटिंग को डिफॉल्ट एन्कोडिंग के रूप में दिखाते हैं और फंक्शन के लिए डिकोडिंग open । यह आपके कोड के शीर्ष के पास open प्रांगण का उपयोग करके किया जाता है (सही use strict; बाद use strict; और use warnings; यह उचित होगा:

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); 

open फंक्शन एक फाइलहैंडल बनाता है जो किसी फाइल से पढ़ने और / या लिखने के लिए उपयोग किया जाता है। open फ़ंक्शन पर हस्ताक्षर हैं

open(FILEHANDLE, MODE, FILEPATH) और यदि ऑपरेशन विफल हो जाता है तो एक गलत मान देता है। त्रुटि विवरण तब $! संग्रहीत किया जाता है $! ।

पढ़ना

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '<', $file_path) or die "Could not open file! $!";

while(my $row = <$file_handle>) {
    print chomp($row), "\n";
}

close $file_handle 
      or warn "Close failed!";

लिख रहे हैं

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '>', $file_path) or die "Could not open file! $!";

print $file_handle "Writing to a file";

close $file_handle 
      or warn "Close failed!";

चोंक पढ़ना

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

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

FILEHANDLE को एक खोला फ़ाइल हैंडल होना चाहिए, SCALAR ऑपरेशन के बाद पढ़ा गया डेटा रखेगा। LENGTH , OFFSET से शुरू होने वाले वर्णों की संख्या निर्दिष्ट करता है। फ़ंक्शन रीडर्स की संख्या देता है, 0 यदि फ़ाइल का अंत पहुँच गया था और त्रुटि के मामले में undef था।

read($file_handle, $data, 16, 0); 

$data में फ़ाइल की शुरुआत से 16 वर्ण पढ़ता है।

"ऑटोडी का उपयोग करें" और आपको फ़ाइल खोलने / बंद विफलताओं की जांच करने की आवश्यकता नहीं होगी

autodie आपको खुली / करीबी विफलताओं की स्पष्ट जांच किए बिना फाइलों के साथ काम करने की अनुमति देता है।

पर्ल 5.10.1 के बाद से, कोर पर्ल में autodie उपलब्ध है। उपयोग किए जाने पर, फ़ाइलें खोलने और बंद करने के दौरान पर्ल स्वचालित रूप से त्रुटियों की जांच करेगा।

यहाँ एक उदाहरण है जिसमें एक फ़ाइल की सभी पंक्तियों को पढ़ा जाता है और फिर एक लॉग फ़ाइल के अंत में लिखा जाता है।

use 5.010;    # 5.010 and later enable "say", which prints arguments, then a newline
use strict;   # require declaring variables (avoid silent errors due to typos)
use warnings; # enable helpful syntax-related warnings
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding
use autodie;  # Automatically handle errors in opening and closing files

open(my $fh_in, '<', "input.txt"); # check for failure is automatic

# open a file for appending (i.e. using ">>")
open( my $fh_log, '>>', "output.log"); # check for failure is automatic

while (my $line = readline $fh_in) # also works: while (my $line = <$fh_in>)
{
     # remove newline
     chomp $line;

     # write to log file
     say $fh_log $line or die "failed to print '$line'"; # autodie doesn't check print
}

# Close the file handles (check for failure is automatic)
close $fh_in;
close $fh_log;

वैसे, आपको तकनीकी रूप से हमेशा print स्टेटमेंट की जांच करनी चाहिए। बहुत से लोग नहीं करते हैं, लेकिन perl (पर्ल दुभाषिया) यह स्वचालित रूप से नहीं करता है और न ही autodie करता है ।

एक फ़ाइलहैंड रिवाइंड करें

कभी-कभी पढ़ने के बाद पीछे हटने की जरूरत होती है।

# identify current position in file, in case the first line isn't a comment
my $current_pos = tell; 

while (my $line = readline $fh)
{
    if ($line =~ /$START_OF_COMMENT_LINE/)
    {
        push @names, get_name_from_comment($line);
    }
    else {
        last; # break out of the while loop
    }
    $current_pos = tell; # keep track of current position, in case we need to rewind the next line read
}

# Step back a line so that it can be processed later as the first data line
seek $fh, $current_pos, 0;

पढ़ना और लिखना gzip संपीड़ित फ़ाइलें

एक gzipped फ़ाइल लिखना

एक gzipped फ़ाइल लिखने के use , मॉड्यूल IO::Compress::Gzip use करें IO::Compress::Gzip और IO::Compress::Gzip का एक नया उदाहरण बनाकर एक फाइलहैंडल बनाएं IO::Compress::Gzip इच्छित आउटपुट फ़ाइल के लिए IO::Compress::Gzip :

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Compress::Gzip;

my $fh_out = IO::Compress::Gzip->new("hello.txt.gz");

print $fh_out "Hello World!\n";

close $fh_out;

use IO::Compress::Gzip;

एक gzipped फ़ाइल से पढ़ना

एक Gzipped फ़ाइल से पढ़ने के लिए, use मॉड्यूल IO::Uncompress::Gunzip और उसके बाद का एक नया उदाहरण बनाने के द्वारा एक filehandle बनाने IO::Uncompress::Gunzip इनपुट फ़ाइल के लिए:

#!/bin/env perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Uncompress::Gunzip;

my $fh_in = IO::Uncompress::Gunzip->new("hello.txt.gz");

my $line = readline $fh_in;

print $line;

IO के लिए डिफ़ॉल्ट एनकोडिंग सेट करना

# encode/decode UTF-8 for files and standard input/output
use open qw( :encoding(UTF-8) :std ); 

यह pragma पढ़ने और लिखने के डिफ़ॉल्ट मोड (फाइल, मानक इनपुट, मानक आउटपुट और मानक त्रुटि) को बदलकर UTF-8 में बदल देता है, जो कि आम तौर पर नए एप्लिकेशन लिखते समय आप क्या चाहते हैं।

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

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