"var var = * $ self -> {class_var}" करने का क्या अर्थ है; "

Question

मैंने इसे खोजने की कोशिश की है, लेकिन कुछ भी नहीं आया है।

$var = *$self->{class_var}; 

क्या * इस स्थिति में क्या करता है:

मैं क्यों एक नीचे परिदृश्य में तारांकन डाल के रूप में बस उत्सुक हूँ?

अद्यतन

मैं नेट :: टेलनेट मॉड्यूल से ऊपर ले लिया और मैं बस इसे समझने की कोशिश कर रहा हूँ।

वास्तविक कोड है:

$s = *$self->{net_telnet}; 

मुझे आश्चर्य है, तो, पैकेज का नाम net_telnet है?

Answer 1

कोड के संक्षिप्त भाग से आप मानते हैं कि $self एक टाइपग्लोब रखता है। आप उप-तत्वों को स्पष्ट रूप से यूजीन वाई उल्लेखों के रूप में, या टाइपग्लोब पर किसी मानक मानक संदर्भ वाक्य का उपयोग करके स्पष्ट रूप से एक्सेस कर सकते हैं। (प्रतीक अलियासिंग के बाहर)

#!/usr/bin/perl 

use strict; 
use warnings; 

our %test = (class_var => "test class_var"); 
our @test = qw(one four nine); 

my $self = \*test; 
print "Self is '$self'\n"; 

my $var1 = *{$self}{HASH}{class_var}; 
print "Var1 is '$var1'\n"; 

my $var2 = *$self->{class_var}; 
print "Var2 is '$var2'\n"; 

my $var3 = ${*{$self}}{class_var}; 
print "Var3 is '$var3'\n"; 

my $var4 = ${*$self}{class_var}; 
print "Var4 is '$var4'\n"; 

my $x_scale = *$self{ARRAY}[0]; 
print "x_scale is '$x_scale'\n"; 

my $y_scale = *$self->[1]; 
print "y_scale is '$y_scale'\n"; 

my $z_scale = ${*$self}[2]; 
print "z_scale is '$z_scale'\n"; 

Typeglob संदर्भ सबसे अधिक बार आईओ स्लॉट जो एक वस्तु एक फ़ाइल हैंडल के रूप में इस्तेमाल किया जा करने की अनुमति देता के लिए उपयोग किया जाता है, लेकिन जब से typeglob अन्य चर स्लॉट्स चर के प्रत्येक प्रकार में से एक मानती है अतिरिक्त राज्य डेटा स्टोर करने के लिए इस्तेमाल किया जा सकता है।

टाइपग्लोब वैश्विक होने की आवश्यकता नहीं है, Symbol::gensym मूल रूप से अज्ञात एक टाइपग्लोब बना सकता है।

Answer 2

टाइपग्लब्स के साथ कुछ करने वाले किसी मामले की तरह दिखता है; उदाहरण के लिए * $ स्वयं एक फाइल हैंडल को लागू करने वाला उप-वर्ग हो सकता है
@ डेव शेरोहमैन, IO::Pipe के स्रोत पर एक नज़र डालें। यह कुछ अजीब कोड जो सवाल

Answer 3

यह काफी शायद एक filehandle वस्तु के साथ काम कर रहा है में typeglobs के साथ एक बहुत, थोड़ा खेलने में शामिल है। फ़ाइलहेडल स्वयं ग्लोब के एफएच स्लॉट में संग्रहीत है, लेकिन फाइलहेडल के बारे में मेटाडेटा ग्लोब के हैश स्लॉट में संग्रहीत है।

तो यह कह रहा है

$var = *{$self}{class_var} 

अर्थात एक typeglob रूप अपसंदर्भन $ स्वयं, और फिर एक हैश के रूप में उपयोग।

आप $ स्वयं नहीं कर सकते - क्योंकि यह एक हैश रेफरी नहीं है> {class_var}, यह एक GLOB रेफरी है।

use strict; 

my $fh;  

my $self = \*fh; 

*$self->{val} = 'foo'; 

मैं एक उदाहरण के रूप में बात $fh का इस्तेमाल किया है, लेकिन वास्तव में आईओ :: हैंडल (शायद) एक ग्लोब रेफरी बनाने के किसी अन्य तरीके का प्रयोग करेंगे। लेकिन कोड के इस स्निपेट के साथ लेकिन यह देखना चाहिए कि

print ref $self; 

कहते GLOB, आप अभी भी

print *$self->{val}; 

foo प्राप्त करने के लिए कर सकते हैं।

इसके अलावा यहां पढ़ने: http://perldoc.perl.org/perldata.html#Typeglobs-and-Filehandles

Answer 4

*$var वाक्य रचना आप नाम से वैश्विक चर का एक सेट करने के लिए पहुँच देता है। उदाहरण के लिए, $foo, @foo, %foo, और *foo के लिए:

package main; 
no strict; 
$foo = 'bar';  # global variable! 
@main::foo = qw(an array); 
%foo = ('hash' => 'table'); 
open foo, '>', '/tmp/foo'; 

$self = 'foo'; 

print "\$$self is ${*$self}\n"; # $foo 
print "\@$self is @{*$self}\n"; # @foo 
print "\%$self is {", 
    (map {$_, " => ", *$self->{$_}, ","} keys %{*$self}), 
    "}\n"; 
print "Performing operations on the $self filehandle:\n"; 
print {*$self} "hello world\n"; 
close *$self; 

open X, '<', '/tmp/foo'; 
print <X>; 
close X; 

---

 
$foo is bar 
@foo is an array 
%foo is {hash => table,} 
Performing operations on the foo filehandle: 
hello world 

बेशक

, संदर्भ और शाब्दिक चर, कुछ भी इस तरह कोड के साथ किया साथ इस आधुनिक समय में शायद एक में किया जा सकता है बेहतर तरीका।

Answer 5

%main::some_hash = (class_var => 'xyz'); 

my $self = *main::some_hash; 

print *$self->{class_var}, "\n"; # prints 'xyz' 

संक्षेप में, इस प्रतीक तालिका में एक हैश के लिए एक संदर्भ के आसपास पास करने का एक प्राचीन तरीका है। $self से पहले $self में एक टाइपग्लोब के रूप में मान को अस्वीकार करता है। ->{class_var} फिर टाइपशोब हैश के रूप में टाइप करता है, और class_var कुंजी को देखता है।

अद्यतन:

वर्ग पदानुक्रम के माध्यम से नीचे खुदाई पता चलता है कि वस्तु के साथ IO::Handle में बनाया जा रहा है:

sub new { 
    my $class = ref($_[0]) || $_[0] || "IO::Handle"; 
    @_ == 1 or croak "usage: new $class"; 
    my $io = gensym; 
    bless $io, $class; 
} 

Symbol::gensym एक पूरा typeglob, जिनमें से IO स्लॉट मुख्य रूप से प्रयोग किया जाता है देता है। हालांकि, चूंकि यह एक पूर्ण टाइपग्लोब है, इसलिए उप-मॉड्यूल उस तथ्य का शोषण कर रहे हैं और विभिन्न डेटा ग्लोब फ़ील्ड, जैसे HASH भाग में अपना डेटा संग्रहीत कर रहे हैं।