पर्ल में हैश कुंजी के रूप में "स्थिर" का उपयोग करने का कोई तरीका है?

हैश कुंजी के रूप में निरंतर उपयोग करने का कोई तरीका है?

उदाहरण के लिए:

use constant X => 1;

my %x = (X => 'X');

उपरोक्त कोड कुंजी के रूप में "एक्स" के साथ हैश और कुंजी के रूप में 1 नहीं बनाएगा। जबकि, मैं स्थिर एक्स के मूल्य को कुंजी के रूप में उपयोग करना चाहता हूं।

0

9 उत्तर

=> operator interprets its left side as a "string", the way qw() does.

उपयोग करने का प्रयास करें

my %x = ( X, 'X');
0
जोड़ा

टिप्पणी @shelfoo (प्रतिष्ठा अभी तक सीधे टिप्पणी जोड़ने के लिए पर्याप्त उच्च नहीं है!)

डेमियन Conway द्वारा पर्ल बेस्ट प्रैक्टिस के बारे में पूरी तरह से सहमत हैं ... इसकी अत्यधिक अनुशंसित पढ़ाई।

हालांकि कृपया पीबीपी मॉड्यूल अनुशंसा टिप्पणी पढ़ें जो उपयोगी "इरेटा" है यदि आप इन-हाउस स्टाइल गाइड के लिए पीबीपी का उपयोग करने की योजना।

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

Your problem is that => is a magic comma that automatically quotes the word in front of it. So what you wrote is equivalent to ('X', 'X').

सबसे आसान तरीका केवल अल्पविराम का उपयोग करना है:

my %x = (X, 'X');

Or, you can add various punctuation so that you no longer have a simple word in front of the =>:

my %x = ( X() => 'X' );
my %x = ( &X => 'X' );
0
जोड़ा

निरंतर उपयोग करें pragma कोई तर्क लेने के लिए प्रोटोटाइप प्रोटोटाइप बनाता है। जबकि यह दिखता है सी-स्टाइल निरंतर की तरह, यह वास्तव में एक सबराउटिन है जो निरंतर मान देता है।

The => (fat comma) automatically quotes left operand if its a bareword, as does the $hash{key} notation.

यदि निरंतर नाम का आपका उपयोग एक शब्दकोष जैसा दिखता है, तो उद्धरण तंत्र में लाया जाएगा और आप इसके मूल्य के बजाय कुंजी के रूप में इसका नाम प्राप्त करेंगे। इसे रोकने के लिए, उपयोग को बदलें ताकि यह एक शब्द न हो। उदाहरण के लिए:

use constant X => 1;
%hash = (X() => 1);
%hash = (+X => 1);
$hash{X()} = 1;
$hash{+X} = 1;

प्रारंभकर्ताओं में, आप इसके बजाय सादे कॉमा का भी उपयोग कर सकते हैं:

%hash = (X, 1);
0
जोड़ा

लात मारने से शब्दकोष उद्धरण तंत्र को रोकने के लिए $ हैश {CONSTANT ()} या $ हैश {+ CONSTANT} का उपयोग करें।

From: http://perldoc.perl.org/constant.html

0
जोड़ा

use constant actually makes constant subroutines.

जो भी आप चाहते हैं उसे करने के लिए, आपको स्पष्ट रूप से उप को कॉल करने की आवश्यकता है:

use constant X => 1;

my %x = ( &X => 'X');

या

use constant X => 1;

my %x = ( X() => 'X');
0
जोड़ा

एक तरीका एक्स को एक्स (एक्स) के रूप में समाहित करना है:

my %x ( (X) => 1 );

Another option is to do away with '=>' and use ',' instead:

my %x ( X, 1 );
0
जोड़ा

एक और विकल्प है कि निरंतर प्रगति का उपयोग न करें और डेमियन कॉनवे द्वारा पर्ल बेस्ट प्रैक्टिस में सिफारिशों के अनुसार रीडोनली पर फ़्लिप करें।

मैंने यह महसूस करने के बाद थोड़ी देर पहले स्विच किया कि निरंतर हैश रेफ सिर्फ हैश के निरंतर संदर्भ हैं, लेकिन हैश के अंदर डेटा के बारे में कुछ भी नहीं करते हैं।

रीडोनली सिंटैक्स "सामान्य दिखने" चर बनाता है, लेकिन वास्तव में निरंतरता या पठनीयता को लागू करेगा। आप इसका उपयोग कर सकते हैं जैसे कि आप किसी अन्य चर को कुंजी के रूप में करेंगे।


use Readonly;

Readonly my $CONSTANT => 'Some value';

$hash{$CONSTANT} = 1;

0
जोड़ा
यह कोई कोर मॉड्यूल नहीं है।
जोड़ा लेखक ceving, स्रोत

अन्य लोगों ने आपके प्रश्न का उत्तर दिया है। साथ में लिया गया, ये समस्या का एक बहुत पूर्ण स्पष्टीकरण और अनुशंसित कामकाज पैदा करते हैं। मुद्दा यह है कि पर्ल प्रगामा "निरंतर उपयोग" वास्तव में आपके वर्तमान पैकेज में एक सबराउटिन बनाता है जिसका नाम प्रज्ञा का पहला तर्क है और जिसका मूल्य अंतिम है।

पर्ल में, एक बार subroutine घोषित किया जाता है, इसे माता-पिता के बिना बुलाया जा सकता है।

Understanding that "constants" are simply subroutines, you can see why they are not interpolated in strings and why the "fat comma" operator "=>" which quotes the left-hand argument thinks you've handed it a string (try other built-in functions like time() and keys() sometime with the fat comma for extra fun).

सौभाग्य से, आप माता-पिता या एम्परसेंड सिगिल जैसे स्पष्ट विराम चिह्न का उपयोग करके निरंतर आह्वान कर सकते हैं।

हालांकि, मुझे आपके लिए एक सवाल है: आप हैश कुंजी के लिए स्थिरांक का उपयोग क्यों कर रहे हैं?

मैं कुछ परिदृश्यों के बारे में सोच सकता हूं जो आपको इस दिशा में ले जा सकते हैं:

  1. आप नियंत्रण चाहते हैं कि कौन सी कुंजी हैश में हो सकती है।

  2. आप बाद में इन परिवर्तनों के मामले में कुंजी का नाम सारण करना चाहते हैं

नंबर 1 के मामले में, स्थिरांक शायद आपके हैश को नहीं बचाएंगे। इसके बजाए, उस वर्ग को बनाने पर विचार करें जिसमें सार्वजनिक सेटर्स और गेटर्स हैं जो केवल हैश के लिए दृश्यमान हैश को पॉप्युलेट करते हैं। यह समाधान की तरह एक बहुत ही अन-पर्ल है, लेकिन बहुत आसानी से करना है।

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

उम्मीद है कि यह आपके समय के लिए मदद करता है और धन्यवाद।

0
जोड़ा