पर्ल में प्रिंट फ़ाइलहेडल के रूप में मैं क्लास प्रॉपर्टी/वैरिएबल का उपयोग कैसे करूं?

Question

मैं के रूप में

open MYFILE, ">", "data.txt"; 
print MYFILE "Bob\n"; 

एक ही बात करना चाहता हूँ, लेकिन इसके बजाय वर्ग चर में

sub _init_tmp_db 
{ 
    my ($self) = @_; 

    open $$self{tmp_db_fh}, ">", "data.txt"; 
    print $$self{tmp_db_fh} "Bob\n"; 
} 

की तरह यह मुझे इस त्रुटि दे दी है: 'स्ट्रिंग पाया जहां ऑपरेटर की उम्मीद के पास "बॉब \ n"'

मुझे क्या करना चाहिए?

Answer 1

print manpage से

: किसी सरणी या, या सामान्य रूप में हैश में

आप भंडारण कर रहे हैं हैंडल जब भी आप किसी भी अभिव्यक्ति एक bareword संभाल तुलना में अधिक जटिल है या एक सादा, unsubscripted अदिश का उपयोग कर रहे इसे पुनर्प्राप्त करने के लिए चर, आपको को इसके बजाय फ़ाइल हैंडल मान लौटने वाले ब्लॉक का उपयोग करना होगा।

आप का उपयोग किया जाना चाहिए:

print { $$self{tmp_db_fh} } "Bob\n"; 

इस कोड use strict के तहत काम नहीं करेगा।

open my $fh, ">", "data.txt" or die $!; 
$$self{tmp_db_fh} = $fh; 
print { $$self{tmp_db_fh} } "Bob\n"; 

Answer 2

फ़ाइलहेडल केवल स्केलर हो सकते हैं।

लेकिन $$self{tmp_db_fh} या तो एक खुला filehandle (data.txt करने के लिए) तो यह काम करेगा है:

sub _init_tmp_db 
{ 
    my ($self) = @_; 

    my $filehandle = $$self{tmp_db_fh} ; 
    print $filehandle "Bob\n"; 
} 

या आप अंदर _init_tmp_db

sub _init_tmp_db 
{ 
    my ($self) = @_; 

    open my $filehandle , ">", "data.txt" or die "Cannot open data.txt" ; 
    print $filehandle "Bob\n"; 
} 

filehandle लेकिन $$self{tmp_db_fh} में एक स्ट्रिंग को उपलब्ध कराने को खोलने ('FILEHANDLE' की तरह) काम नहीं करेगा।

Answer 3

बजाय आप आईओ :: फ़ाइल मॉड्यूल चाहिए: यह सिर्फ एक my चर का उपयोग ठीक करने के लिए।

use IO::File; 
my $file = IO::File->new; 
$file->open("> data.txt"); 

print_something($file); 

sub print_something { 
    my ($file) = @_; 
    $file->print("hello world\n"); 
} 

या अपने उदाहरण समारोह में:

use IO::File; 
# ... 
sub _init_tmp_db 
{ 
    my ($self) = @_; 

    $self{tmp_db_fh} = IO::File->new; 
    $self{tmp_db_fh}->open(">", "data.txt"); 
    $self{tmp_db_fh}->print"Bob\n"; 
} 

(ध्यान दें, यदि आप अभी भी गैर कर सकते हैं -> आधारित कॉल भी, लेकिन मैं का उपयोग करके उपरोक्त लिखा और अधिक परंपरागत -> खुला() कॉल टाइप ।)

Answer 4

यह आसानी से एक फाइल संभाल के लिए एक चर बनाने के द्वारा हल किया जाता है:

sub _init_tmp_db { 
    my $self = shift; 

    my $fh; 
    open $fh, ">", "data.txt" 
    $self->{temp_db_fh} = $fh; 

    # Sometime later... 

    $fh = $self-{temp_db_hf}; 
    print $fh "Bob\n"; 
} 

यह एक मुद्दा है क्योंकि जिस तरह से print वाक्यविन्यास पार्स किया गया है और वाक्यविन्यास की प्रारंभिक ढलान है। print कथन में वास्तव में दो अलग-अलग प्रारूप हैं: प्रारूप # 1 यह है कि आप इसे मुद्रित करने के लिए सामान को पास कर रहे हैं। प्रारूप # 2 कहता है कि पहला आइटम फ़ाइल हैंडल हो सकता है, और शेष वह सामान है जिसे आप फ़ाइल हैंडल पर प्रिंट करना चाहते हैं। यदि print आसानी से निर्धारित नहीं कर सकता कि पहला पैरामीटर फ़ाइल हैंडल है, तो यह विफल हो जाता है।

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

print "This is my statement", file=file_handle; 

या

print "This is my statement" >> file_handle; 

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

---

आप वर्ग अपने शीर्षक में कहा। मुझे लगता है कि आप ऐसा करने के लिए एक पूरी तरह से ऑब्जेक्ट उन्मुख पैकेज लिखने में रुचि रखते हैं। यहां एक त्वरित उदाहरण है। write subroutine विधि में फ़ाइल नोटिस मैं एक चर में फ़ाइल हैंडल पुनर्प्राप्त करता हूं और print कथन में चर का उपयोग करता हूं।

#! /usr/bin/env perl 
# 
use strict; 
use warnings; 


####################################################### 
# MAIN PROGRAM 
# 
my $file = File->new; 

$file->open("OUTPUT") or 
    die "Can't open 'OUTPUT' for writing\n"; 

$file->write("This is a test"); 
# 
####################################################### 

package File; 
use Carp; 


sub new { 
    my $class = shift; 

    my $self = {}; 
    bless $self, $class; 

    return $self; 
} 

sub open { 
    my $self = shift; 
    my $file = shift; 

    my $fh; 
    if (defined $file) { 
     $self->{FILE} = $file; 
     open ($fh, ">", $file) and $self->_fh($fh); 
    } 
    return $self->_fh; 
} 

sub _fh { 
    my $self = shift; 
    my $fh = shift; 

    if (defined $fh) { 
     $self->{FH} = $fh; 
    } 
    return $self->{FH}; 
} 

sub write { 
    my $self = shift; 
    my $note = shift; 

    my $fh = $self->_fh; 
    print $fh $note . "\n"; 
    return 
}