नेस्टेड डेटा संरचना का निर्माण करते समय कठिनाई

Question

एक एपीआई के लिए एक JSON संदेश बनाने की कोशिश करते हुए, मैंने खुद को कुछ ऐसा करने के लिए संघर्ष करते हुए पाया जो मैंने सोचा था कि यह सरल होगा। मुझे निम्न जैसा संदेश बनाने की आवश्यकता है:

{ "list": [ { "foo": 1, "bar": 2 } ] }

हालाँकि, मेरा पहला प्रयास काम नहीं आया:

say to-json { foo => [ { a => 1, b => 2 } ] };
# {"foo":[{"a":1},{"b":2}]}

चीजों को सरल बनाने की कोशिश ने मुझे और उलझन में डाल दिया:

say { foo => [ { a => 1 } ] };
# {foo => [a => 1]}
# Note that this is not JSON, but I expected to see curly braces

फिर मैंने कुछ अस्थायी चर का उपयोग करने की कोशिश की, और यह काम किया:

my @list = { a => 1 };
say to-json { foo => @list };
# {"foo":[{"a":1}]}

my %hash = ( a => 1 );
say to-json { foo => [ %hash ] };
# {"foo":[{"a":1}]}

यहाँ क्या चल रहा है?

और क्या कोई ऐसा तरीका है जिससे मैं एक अतिरिक्त अस्थायी चर के बिना अपना वांछित उत्पादन प्राप्त कर सकता हूं?

Comments

say to-json { foo => [ { a => 1 } ] };कुछ की तरह उत्पादन करना चाहिए {"foo":[{"a":1}]}, नहीं {"foo":["a":1]}। उत्तरार्द्ध एक टाइपो है, है ना? यदि नहीं, तो क्या say $*PERL.compiler.version;कहता है?

— raiph

हम्म, हाँ, तुम सही हो। मुझे लगता है कि जब मैं सामान बाहर करने की कोशिश कर रहा था तो मैंने चीजों को गलत समझा। यहां तक ​​कि say to-json { foo => [ a => 1 ] }आउटपुट {"foo":[{"a":1}]}भी जो जानता है कि मैंने जो टाइप किया है, अगर मैंने कभी किया है। मेरी गलती!

— जजा

Answer 1

आपने एकल तर्क नियम की खोज की है । Raku में कई निर्माणों के साथ प्रदान किए गए तर्क को प्रभावित करेगा। इसमें [...]सरणी संगीतकार शामिल है। यही कारण है कि जब हम कहते हैं:

say [1..10];

हमें एक ऐसा सरणी मिलता है जिसमें 10 तत्व होते हैं, न कि 1. हालांकि, इसका मतलब यह भी है कि:

say [[1,2]];

Iterates [1,2], और इस प्रकार परिणाम [1,2]- जैसे कि आंतरिक सरणी नहीं थी। एक Hash, अपने जोड़े के लिए iterates इस प्रकार:

{ foo => [ { a => 1, b => 2 } ] }

वास्तव में उत्पादन:

{ foo => [ a => 1, b => 2 ] }

अर्थात्, सरणी में जोड़े हैं। JSON सीरियलाइज़र तब प्रत्येक जोड़ी को एक-तत्व ऑब्जेक्ट के रूप में क्रमबद्ध करता है।

इसका समाधान एकल-तत्व पुनरावृत्ति उत्पन्न करना है। Infix ,ऑपरेटर वह है जो सूचियों का निर्माण करता है, इसलिए हम इसका उपयोग कर सकते हैं:

say to-json { foo => [ { a => 1, b => 2 }, ] };
#                        note the , here ^

फिर एकल तर्क को पुनरावृत्त किया जाना हैश के साथ एक 1-तत्व सूची है, और आपको वह परिणाम मिलता है जो आप चाहते हैं।

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

Comments

दूसरा तरीका एक स्केलर में आइटम करना है: {foo => [$ {a => 1, b => 2}]}

— जकार