Powershell: सुझाव: अशक्त- coalescing, null-सशर्त पहुंच (null-soaking), null-conditional असाइनमेंट लागू करें

@ mklement0 ऐसा लगता है कि बिना ""?
शायद name() बदल जाए?

@iSazonov : अच्छी बात है, लेकिन यह केवल ? बिना काम करता है जब तक कि Set-StrictMode -Version 2 या अधिक न हो _not_ प्रभाव में है - मैंने यह स्पष्ट करने के लिए प्रारंभिक पोस्ट अपडेट किया है।

मुझे लगता है कि सिंथेटिक चीनी कुछ ऐसी शक्तियां हैं जो अन्य भाषाओं का आनंद ले सकती हैं। प्रस्ताव पर +1।

अन्य भाषाओं के निम्नलिखित नमूनों पर विचार करें:

a="${b:-$c}"
a = b || c;
a = b or c
a := b ? c
a = b ? b : c;

यहाँ तक की

a = b if b else c

से बेहतर है

if (b) { a = b } else { a = c }

और अक्सर बार आपको अतिरिक्त क्रिया के साथ स्पष्ट करने की आवश्यकता होती है

a = (यदि (b -n $ null) {b} और {c})

सभी को गंदा और धमाकेदार लगता है।

चारों ओर काम के रूप में आज खुद को ऐसा करते पाया।

`` `Powershell
$ शब्द = ($ null, "दो", "तीन")। जहाँ (($ _-$ $ null}, "पहले")
`` ``

मैं एक समान पैटर्न का उपयोग करता हूं:

$word = ($null, "two", "three" -ne $null)[0]

@kfsone आपके उदाहरण $a=(if ($b -ne $null) { $b } else { $c }) में एक छोटी सी त्रुटि है। यह $a=$(if ($b -ne $null) { $b } else { $c }) होना चाहिए हालांकि PowerShell का एकमात्र संस्करण जहां $( ) की आवश्यकता थी संस्करण 1 था। v2 पर, आप बस कर सकते हैं:

$a = if ($b) { $b } else { $c }

@bgshacklett क्या आपका मतलब $word=($null,'two')[$null -ne 'three'] ?

यह थोड़ा दुर्भाग्यपूर्ण है यह 6.1 से 6.2 से "भविष्य" तक चला गया है।

@ TheIncorrigible1 नहीं, यदि आप कॉपी और पेस्ट करते हैं जो मैंने ऊपर जोड़ा है, तो आपको यह देखना चाहिए कि $word का मूल्य "दो" पर सेट है। इस स्टैक ओवरफ्लो के उत्तर में और अधिक विवरण है जहां मैंने पहली बार पैटर्न देखा था:
https://stackoverflow.com/a/17647824/180813

जबकि गड़बड़ी हैक-अराउंड 20 साल पहले मुझे अपील की कि एक पंजीकृत और / या एक RIPE-DB उपयोगकर्ता या संगठन रिकॉर्ड के बारे में अपील की है, जो मैं शक्तियां से उम्मीद कर रहा हूं वह कुछ है जो मेरे सहयोगियों को भाषा का उपयोग करने के लिए प्रोत्साहित करता है बल्कि उनमें भय पैदा करें।

मेरा लिटमस टेस्ट यह है: क्या मैं इसे अपने टैबलेट के माध्यम से 3 बजे नए साल की सुबह पढ़ना चाहूंगा, जबकि फोन पर ceo के साथ मुझे रोते हुए बताया कि हम कितने मिलियन डॉलर एक सेकंड में खो रहे हैं।

(इसके अलावा: यह केवल एक वास्तविक अनुभव का एक ढीला अतिशयोक्ति था जब तक कि मैंने फेसबुक पर काम नहीं किया और एक त्वरित त्वरित रिसाव से वापस आया, यह बताया गया कि, 2 मिनट में मैं चला गया था, हॉलैंड की आबादी से अधिक लोगों ने एक खाली मिल गया था समाचार फ़ीड। यह मेरा कोड नहीं था और गलती बहुत विशिष्ट टेम्पलेट मामलों के लिए सी ++ मानक में रिटर्न एक्स बनाम रिटर्न (एक्स) के शब्दार्थ में एक मिनट का बदलाव था, और "क्या आप इस कोड को 2 मिनट के साथ पढ़ना चाहते हैं समय सीमा, एक पूर्ण मूत्राशय और आपके कंधे पर डच व्यक्ति की बिल्ली के चित्रों को पहने हुए हर खटिया का भाग्य ??? "शांत के रूप में ध्वनि नहीं थी"

हाँ। PS में कुछ साफ-सुथरी तरकीबें संभव हैं जो एक चुटकी में बड़ी हैं या अगर आपको एकमुश्त शॉर्टहैंड की जरूरत है।

बनाए रखने योग्य कोड के लिए, आदर्श रूप से हमारे पास C # जैसे स्पष्ट अशक्त-संचालक ऑपरेटर होने चाहिए। मेरे लिए मुख्य समस्या यह है - हम उन लोगों के लिए क्या उपयोग करते हैं? ? पहले से ही Where-Object (जितना मैं मिटना चाहूंगा, यह बहुत सामान्य उपयोग में है)। ध्यान रहे, % को ForEach-Object बदले दिया गया है, लेकिन यह मापांक कार्यों में बाधा नहीं है, इसलिए सिद्धांत रूप में कम से कम ? एक शून्य-संचालक ऑपरेटर होने के साथ-साथ संभावित रूप से भी संभव होगा। ठीक; इसे केवल ऐसे भावों के रूप में व्याख्यायित किया जाएगा, जहाँ Where-Object वास्तव में वैसे भी मान्य नहीं है।

@ vexx32 :

कम से कम _syntactically_ ?? ठीक होना चाहिए, क्योंकि हम _expression_ मोड के बारे में बात कर रहे हैं, जबकि ? , एक कमांड [उपनाम] के रूप में, केवल _argument_ मोड में मान्यता प्राप्त है।
निश्चित नहीं है कि प्रतीक का पुन: उपयोग भ्रम का कारण बनता है, लेकिन यह पहली बार नहीं होगा कि कोई प्रतीक विभिन्न संदर्भों में दोहरा कर्तव्य करता है।

आश्चर्यजनक रूप से, नल-भिगोने के लिए ?. और ?[] करना तकनीकी रूप से एक ब्रेकिंग परिवर्तन होगा, क्योंकि PowerShell वर्तमान में एक चर नाम में गैर-प्रारंभिक वर्ण के रूप में ? अनुमति देता है।

PS> $foo? = @{ bar = 1 }; $foo?.bar   # !! $foo? is a legal variable name
1

हालाँकि, मुझे उम्मीद है कि इसे एक बकेट 3: अनलकी ग्रे एरिया परिवर्तन माना जाएगा।

मैं यह नहीं कह सकता कि मैंने कभी किसी को उपयोग करते देखा है? एक चर नाम में ... न ही मैं, क्योंकि संभावना है कि यह गलत होगा। लेकिन हाँ, उम्मीद है कि पूरी तरह से प्रयोज्य होना चाहिए।

मुझे संदेह है कि इसे लाने में थोड़ी देर हो गई है, लेकिन बैश ने अपने पैरामीटर पैरामीटर सुविधाओं के साथ इस (और कुछ अन्य मामलों) को संभाला है: https://www.tldp.org/LDP/abs/html/parameter-substitution.html।

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

@bgshacklett :

हां, पैरामीटर प्रतिस्थापन शक्तिशाली है, लेकिन, दुर्भाग्य से, यह न केवल _learn_ के लिए एक भालू है, बल्कि _remember_ के लिए भी है।

तो जबकि बाश के _features_ अक्सर दिलचस्प होते हैं, उनका _syntactic form_ अक्सर आर्कन होता है, याद रखना मुश्किल होता है, और PowerShell के लिए एक अच्छा फिट नहीं है।

_Brace expansion_ (जैसे, a{1,2,3} में bash के विस्तार a1 a2 a3 ) एक दिलचस्प सुविधा जिसका अभिव्यक्ति मैं PowerShell में देखने के लिए अच्छा लगेगा का एक उदाहरण है, लेकिन PowerShell उपयुक्त साथ वाक्यविन्यास - # 4286 देखें

मैं पूरी तरह से सहमत। मैंने इसे एक उदाहरण के रूप में अधिक सामने लाया कि कैसे इस मुद्दे को एक सटीक समाधान की तुलना में कहीं और हल किया गया है।

संभवतः विचार करने के लिए एक अन्य ऑपरेटर है:

$x ?= 12

अगर यह सेट नहीं है (मौजूद नहीं है) तो $x सेट होगा। यह "इनिशलाइज़र पैटर्न" का हिस्सा है, जो पारंपरिक भाषाओं में आम नहीं है, लेकिन (डायनामिक रूप से स्कोप्ड) भाषाओं के लिए गोले, उपकरण बनाना, आदि। यह एक स्क्रिप्ट के लिए बहुत आम है जो डिफ़ॉल्ट रूप से सेट होती है यदि उपयोगकर्ता ने इसे निर्दिष्ट नहीं किया है। । (हालांकि वास्तव में पैरामीटर इनिशियलाइज़र बहुत व्यापक हैं।)

गुणों के लिए इसका विस्तार:

$obj.SomeProperty ?= 13

यदि यह मौजूद नहीं था, तो एक नोट संपत्ति SomeProperty को इनिशियलाइज़ करेगा और जोड़ेगा।

और - मनोरंजन के लिए - -or का उपयोग करके एक चर को शुरू करने पर एक और भिन्नता:

$x -or ($x = 3.14) > $null

$x ?= 12 एक महान विचार की तरह लगता है।

यह मेरे लिए हुआ है कि हम शायद न केवल contain_ के लिए अगर एलएचएस नहीं _exist_ करता है, लेकिन यह भी अगर यह _does मौजूद हैं, लेकिन होता है इन ऑपरेटरों के सभी आवेदन करना चाहिए $null (साथ [System.Management.Automation.Internal.AutomationNull]::Value की तरह व्यवहार $null इस संदर्भ में

नोट प्रॉपर्टी SomeProperty को जोड़ें और आरंभ करें

उस नस में, $obj.SomeProperty ?= 13 मेरे लिए समझ में आता है _only_ अगर .SomeProperty मौजूद है और $null , तो यह देखते हुए कि आप नियमित रूप से असाइनमेंट के साथ भी संपत्ति नहीं बना सकते हैं (इसके विपरीत, _hasthables_ के लिए) निहित प्रविष्टि निर्माण समझ में आता है)।

चर्चा किए गए सभी ऑपरेटरों को एलएचएस को सख्त-मोड अस्तित्व की जाँच से छूट देने की आवश्यकता होगी।

मैं पीछे क्यों StrictMode एक संपत्ति जो मौजूद नहीं है तक पहुँचने से आप बंद हो जाता है के इरादे / तर्क के बारे में सोच रहा हूँ। क्या $x.pretnd जैसे टाइपो को पकड़ने का इरादा है? क्या assert(x != null) जैसी धारणाओं की जाँच करने का इरादा है? क्या आपके कोड में गलती से $null प्रचार करने का इरादा है?

null-soaking (।) मददगार है, स्पष्ट इरादे का संकेत देने के लिए संक्षिप्त रूप में $ null को अनदेखा करें।

क्या ऐसा नहीं है जो . सिग्नल पहले से ही नॉनस्ट्रिक्ट मोड में है? यदि आप सख्त होना चाहते थे, तो आप .Name मौजूदा के लिए जाँच कर सकते थे, पहले जाँच नहीं करके, आपने पहले ही स्पष्ट इरादे का संकेत दिया था कि जाँच आपके लिए महत्वपूर्ण नहीं थी।

यदि स्ट्रिक्टमोड का एक उद्देश्य है, जहां एक गैर-मौजूद संपत्ति तक पहुंचना और $null करना मना है, तो वही तर्क ?. लागू नहीं होगा, और उसी कारण के लिए समान अपवाद को फेंक देना चाहिए । यदि नहीं, तो क्यों नहीं?

अशक्त करने के साथ, आप लिख सकते हैं:

$result = Invoke-RestMethod -Uri 'https://example.org/api/test'
$test = $result?.Name

क्या यह जल्दी से अनुशंसित या मुहावरेदार हो जाएगा हमेशा हर संपत्ति के संदर्भ के लिए ?. उपयोग करें, क्योंकि यह " . जैसा व्यवहार करता है, और सख्ती से उपयोग करने वाले लोगों के लिए अपवाद नहीं फेंकेंगे"?

क्या चर सेटिंग्स के साथ एक विन्यास योग्य कड़ेपन की वास्तविक इच्छा है, ताकि उदाहरण के लिए आप अपनी लिपि # StrictMode SkipMemberExistenceCheck के शीर्ष पर एक घोषणा कर सकें, या unstrict code ब्लॉक को इंगित करने के लिए एक एस्केप हैच विशेषता आम तौर पर? [मुझे लगता है कि इच्छा सी # शैली वाक्यविन्यास है, लेकिन आप जानते हैं कि मेरा क्या मतलब है]

विचारों के लिए धन्यवाद, @HumanEquivalentUnit

क्या $x.pretnd जैसे टाइपो को पकड़ने का इरादा है?

मैं डिजाइन के इरादे से बात नहीं कर सकता, लेकिन यही मेरे लिए समझ में आता है - Set-StrictMode -Version 1 _variables_ (केवल) के लिए क्या अनुरूप है।

चर के साथ यह उनके _existence_ के बारे में है, न कि यह कि क्या मूल्य $null , और संपत्ति के अस्तित्व की जाँच उसी पैटर्न का अनुसरण करती है।

मुझे लगता है कि यह निकटतम डायनेमिक स्क्रिप्टिंग भाषा के रूप में त्रुटियों को खोजने के लिए मिल सकती है जो एक संकलित संकलित भाषा _compile time_ पर रिपोर्ट करेगी।

क्या ऐसा नहीं है। पहले से ही गैर-संकेत मोड में संकेत? यदि आप सख्त होना चाहते थे, तो आप जाँच कर सकते थे। पहले नाम मौजूद था

हां, लेकिन गैर-सख्त मोड में आप उपर्युक्त अस्तित्व की जांच से गुजरते हैं, और मैन्युअल रूप से परीक्षण स्पष्ट रूप से काफी बोझिल है - और एक अंतर्निहित सुविधा की तुलना में धीमी गति से।

पहले जाँच न करके, आपने पहले ही स्पष्ट इरादे का संकेत दे दिया था कि जाँच आपके लिए महत्वपूर्ण नहीं थी।

मुद्दा यह है कि, Set-StrictMode -Version 2 या उच्चतर के साथ, आपको मिलता है:

• सदस्य अस्तित्व की जाँच का लाभ _by default_
• ऑप्ट आउट करने का विकल्प, _ .? साथ, संक्षिप्त रूप से मांग

आप अपनी स्क्रिप्ट # StrictMode SkipMemberExistenceCheck के शीर्ष पर घोषणा कर सकते हैं, या unstrict code एक ब्लॉक को इंगित करने के लिए एक एस्केप हैच विशेषता हो सकती है

संबंधित: Set-StrictMode की वर्तमान गतिशील स्कोपिंग समस्याग्रस्त है; एक _lexical_ सख्त मोड लागू करने के लिए की आरएफसी मसौदा @lzybkr देखें: https://github.com/PowerShell/PowerShell-RFC/blob/master/1-Draft/RFC0003-Lexical-Strict-Mode.md

डिफ़ॉल्ट रूप से सदस्य अस्तित्व की जाँच का लाभ

PS में कोड होता है जो सदस्य की जाँच करता है, और जब वे मौजूद नहीं होते हैं तो $ null रिटर्न देते हैं। यह डिफ़ॉल्ट रूप से एक लाभ है, जिसे आप अपने स्वयं के सदस्य अस्तित्व परीक्षण को $x.psobject.properties... साथ लिखने से भी बच सकते हैं यदि आप चुनते हैं। स्ट्रिक्टमोड उस लाभ को दूर ले जाता है और अस्तित्व परीक्षण लिखने में बाधा उत्पन्न करता है। तब वास्तव में एक सदस्य अस्तित्व परीक्षण लिखने का एक अच्छा तरीका देने के बजाय, ?. आपको हमेशा . प्राप्त करने के लिए एक संक्षिप्त समाधान प्रदान करेगा। और अगर यह मायने रखता है कि सदस्य मौजूद है, तो आपको अभी भी अलग से कोड करना होगा।

लेकिन यह मुझे विधि कॉल के बारे में क्या पूछता है:

$x.pretend     -> $null
$x.pretend()   -> Exception MethodNotFound
$x?.pretend  -> $null
$x?.pretend()   -> ____ what goes here? $null?

set-strictmode -version 2
$x.pretend -> Exception PropertyNotFoundStrict
$x.pretend()  -> Exception MethodNotFound
$x?.pretend  -> $null
$x?.pretend()   -> ____  ?

अर्थात ?. नॉन-कड़ाई में प्रॉपर्टी लुकअप के लिए . के समान व्यवहार करेंगे, लेकिन गैर-सस्पेंसोड में विधि कॉल के लिए . अलग व्यवहार करेंगे, जिससे यह अति सूक्ष्म हो और न हो एक ड्रॉप-इन प्रतिस्थापन। क्या इसका मतलब यह है कि ?. का उपयोग करते समय आपके पास यह बताने का कोई तरीका नहीं होगा कि क्या कोई विधि लागू की गई थी, या कुछ भी नहीं हुआ था? गुणों को गेट्टर विधियों द्वारा समर्थित किया जा सकता है, लेकिन मुझे लगता है कि गेटर्स के लिए आंतरिक राज्य को म्यूट करने के लिए डॉटनेट में यह सम्मेलन नहीं है, लेकिन विधि कॉल को म्यूट करने के लिए सामान्य है। ?. आपको कोई विचार नहीं होगा यदि आपने किसी वस्तु की स्थिति को उत्परिवर्तित किया हो?

मुझे आश्चर्य है कि क्या आप वांछित लाभ प्राप्त कर सकते हैं, और बेहतर, ?? कर सकते हैं संभाल करने के लिए PropertyNotFoundException और MethodNotFound अपवाद सीधे बाईं ओर की अभिव्यक्ति से (लेकिन अन्य तरीकों के अंदर उठाए गए अपवाद नहीं), साथ ही $ को संभालना। nulls, और ?. बिलकुल नहीं है। जैसे

$varThatMayBeNull ?? $fallbackValue # null-coalescing
#
$varThatMayBeNull.Name ?? $fallbackvalue    # catching PropertyNotFoundStrict exception
$varThatMayBeNull.Name ??  # default fallback is $null
$varThatMayBeNull.Method() ??  # catching MethodNotFound Exception

# and potentially addressing the index case too
$varThatMayBeNull.first.second[3].Method() ??  # catching MethodNotFound Exception, or index not found Exception

और फिर, ?. बजाय एक सदस्य को कॉल करना या किसी संपत्ति तक पहुंचना, यह पूछने का एक संक्षिप्त तरीका हो सकता है कि क्या कोई सदस्य मौजूद है, एक [बूल] लौटा रहा है।

?? और ?. समान सिंटैक्स जोड़ के साथ आप कम भ्रमित ओवरलैप के साथ अधिक स्थितियों को संभाल सकते हैं।

स्ट्रिक्टमोड उस लाभ को छीन लेता है और अस्तित्व परीक्षण लिखने की बाधा छोड़ देता है

एक व्यक्ति की बाधा दूसरे व्यक्ति का लाभ है:
यह सब इस बात पर निर्भर करता है कि आप क्या चाहते हैं _by default_:

• यदि आपको विश्वास है कि आपके कोड में कोई _typos_ नहीं हैं - हर तरह से, _default_ व्यवहार (सख्त मोड बंद) का लाभ उठाएं - और आपको .? (_property और एक्सेस के लिए) की कोई आवश्यकता नहीं होगी - देखें अगली टिप्पणी फिर से _method कॉल_ और _indexing_)।

  • _Personal_ नोट पर: मैं _variable_ नामों में टाइपोस से बचने के लिए Set-StrictMode -Version 1 का उपयोग करता हूं, लेकिन मुझे -Version 2 या अधिक कष्टप्रद है, मुख्यतः # 2798 (जो एक बग जो स्वतंत्र है) के कारण यह प्रस्ताव)।

• यदि आप यह सुनिश्चित करना चाहते हैं कि आपने (a) आपने प्रॉपर्टी के नाम और / या (b) को गलत नहीं किया है, तो आपका कोड गलती से डेटा प्रकारों पर काम नहीं करता है, जो आपके द्वारा संचालित करने के लिए है, संस्करण 2 या उच्चतर के लिए सख्त मोड सेट करें। ।

  • वास्तव में, कि _currently_ इसे इन चेकों के __ के लिए बोझिल बनाता है _ _ माँग_,
  • जो ठीक-ठीक क्यों है, अशक्त-सशर्त पहुंच की शुरुआत यहां प्रस्तावित की जा रही है: मांग को चुनने के लिए इसे _easy_ बनाने के लिए।

स्पष्ट रूप से एक सदस्य की उपस्थिति के लिए परीक्षण वास्तव में एक अलग उपयोग का मामला है जो प्रभाव में सख्त मोड के बावजूद एक आवश्यकता हो सकती है।

_Method call_ के लिए, जो ओपी कवर नहीं करता है:

_Method कॉल_ (उदाहरण के लिए, $varThatMayBeNull.Method() ) और _indexing_ (जैसे, $varThatMayBeNull[$index] ) दो मामले हैं जहां सख्त मोड बंद या संस्करण 1 पर लाभान्वित हो सकता है, यह देखते हुए कि दोनों मामले वर्तमान में _vvariably_ त्रुटि का कारण बनते हैं एक्सेस किया जा रहा मूल्य $null ।

वाक्यविन्यास विधियों के गुणों के लिए समान होगा - $varThatMayBeNull?.Method() - और अनुक्रमण के लिए अनुरूप - $varThatMayBeNull?[$index] - जैसा कि C # में।

_Uddate_: यदि अनुगामी अशक्त है, तो अनुक्रमणिका का दूसरा पहलू है, लेकिन दिए गए अनुक्रमणिका में तत्व मौजूद नहीं है (उदाहरण के लिए, $arr = 0,1; $arr[2] )। सख्त मोड संस्करण 2 या नीचे के साथ, यह $null मूल्यांकन करता है, लेकिन संस्करण 3 या उच्चतर में यह एक त्रुटि का कारण बनता है, और इस त्रुटि से भी बाहर निकलने में सक्षम होना अच्छा होगा। हालांकि, इस मामले के लिए वाक्यविन्यास एक चुनौती प्रस्तुत करता है - अद्यतन ओपी देखें, जो वर्तमान में शायद [...?] का प्रस्ताव करता है।

और, हाँ, मैं $null लिए भी इस तरह के एक्सेस को डिफ़ॉल्ट बनाऊंगा, यहां तक ​​कि तरीकों के लिए भी - फिर, आप _explicitly_ सिग्नल कर रहे हैं कि यदि ऑब्जेक्ट एक्सेस किया जा रहा है तो यह कुछ भी नहीं करने के लिए ठीक है $null या यदि ऐसा कोई ऐरे तत्व मौजूद नहीं है।

ध्यान दें कि C # के दूसरे अर्थ में कोई अशक्त-अनुक्रमण नहीं है।

यह अशक्त-सशर्त अनुक्रमण है, बस यह बिलकुल पसंद नहीं है कि आप कैसे प्रस्ताव कर रहे हैं। सी # की अनुमति देता है (मुझे पूरा यकीन है, कम से कम ...) array?[0] जो सामान्य रूप से "अशक्त सरणी / संग्रह" मुद्दे को दरकिनार करता है और बस शून्य देता है।

लेकिन हाँ, मैं मानता हूँ कि यह एक अच्छा विचार है। यह हमें अपवाद हैंडलिंग से बचाता है, और यह कोड को बहुत स्पष्ट और संक्षिप्त रखता है।

@ vexx32 , जो कि null-conditional indexing का _one_ पहलू है: यदि array array?[0] null , तो अनुक्रमण कार्रवाई को अनदेखा किया जाता है - C # में भी, जैसा कि आप राज्य करते हैं।

मैं (अद्यतन: _also_) शून्य-सशर्त अनुक्रमण के _other_ पहलू के बारे में बात कर रहा था: वह मामला जहां array array?[0] _not_ null लेकिन यह सूचकांक 0 पर तत्व है

यह बाद की बात है कि C # को मेरी जानकारी में नजरअंदाज नहीं किया जा सकता है, फिर भी मुझे लगता है कि यह उपयोगी होगा।

क्या आप इन दो पहलुओं को अलग नाम देने के लिए शब्दावली के बारे में सोच सकते हैं?

एक और जावास्क्रिप्ट इश्यू का कोड $_.Description[0].Text से $_?.Description[0?]?.Text जो मुझे लगता है कि बहुत सुंदर नहीं है; और मेरे अन्य सुझाव कि कैसे ?? व्यवहार कर सकता है, इसे $_.Description[0].Text ?? जाएगा, जो कि विषय के रूप में अच्छा है, और - यदि संभव हो तो लागू करें - श्रृंखला में किसी भी लुकअप बिंदु पर विफलताओं को संभालना सभी एक बार में , और फिर भी आपको यह चुनने देता है कि आप डिफ़ॉल्ट रूप से क्या करना चाहते हैं, और इसमें केवल $null तक सीमित होने के बजाय एक अलग कमबैक होगा।

एक तरफ के रूप में, क्या यह ?. सिंटैक्स में स्थिर गुणों और विधियों के लिए एक एनालॉग है, अर्थात $t = [int]; $t::MaxValu; $t::Pars("1") , क्या यह ?: या ?:: ?

निर्दिष्ट एक से अधिक सूचकांक के साथ सरणी अनुक्रमण के लिए वांछित व्यवहार क्या होगा? $array[0,4?,1,2] जहां हर एक को विफल होने की अनुमति दी जा सकती है, या $array[0,4,1,2?] केवल पूरे बहुत से सफल या असफल होने की अनुमति है?

मुझे पहले एक कदम वापस लेना है, क्योंकि मुझे एहसास है कि मैंने उन पहलुओं को स्वीकार कर लिया है जो अलग होने के लायक हैं, कम से कम वैचारिक रूप से:

• _Null-value_-सशर्त सदस्य या इंडेक्स एक्सेस, जैसा कि C #:

  • यदि किसी मूल्य को एक्सेस किया जा रहा है, तो यह $null , इसके सदस्यों या इंडेक्स तक पहुँचने के प्रयासों को अनदेखा करें और $null मूल्यांकन करें।

• _Member-अस्तित्व_ सशर्त सदस्य या PowerShell के लिए अनुक्रमणिका अभिगम:

  • यदि कोई मान एक्सेस किया जा रहा है तो _non- $null _ है, गैर-मौजूदा _members_ (गुण, विधि कॉल, अनुक्रमण) तक पहुंचने के प्रयासों को अनदेखा करें जो मौजूद नहीं हैं।

नोट: संक्षिप्तता के लिए, मैं _member_ का उपयोग कर रहा हूँ, कुछ हद तक यहाँ भी संग्रह की होने वाली वस्तुओं के _elements_ को समाहित करता है, जो कि डॉट नोटेशन के बजाय _indexing_ के साथ एक्सेस किए जाते हैं।

यदि आप आश्वस्त हैं कि आपके कोड में कोई टाइपोस नहीं हैं - हर तरह से, डिफ़ॉल्ट व्यवहार का लाभ उठाएं (सख्त मोड बंद) - और आपको इसकी कोई आवश्यकता नहीं होगी? (संपत्ति के उपयोग के लिए

@ mklement0 मुझे लगता है कि आप " अपने कोड को बेहतर बनाने के लिए सख्त मोड का उपयोग करने वाले एक व्यक्ति " के दृष्टिकोण से चर्चा कर रहे हैं और मैं इस दृष्टिकोण से " कोई और मेरे कोड को कड़े शब्दों में चला सकता है, क्या बदलाव मेरे कोड को उनके लिए भी काम करेंगे?" "और यह मुझे अलग तर्क के नीचे ले जा रहा है। साथ ?. इसके बारे में उसका उपयोग करना चाहते तो सुविधाजनक होगा . और मेकअप कोड भी StrictMode कि मैं भी इसे हर जगह आदतन उपयोग कर सकते हैं में काम; मैं कुछ भी नहीं खोता और संगतता हासिल करता हूं। मुझे डर है कि सभी PowerShell कोड उस तरह से बदसूरत हो जाएंगे क्योंकि यह अधिक मामलों में "काम करता है"।

लेकिन यह एक ड्रॉप-इन रिप्लेसमेंट नहीं है, क्योंकि यह साइलेंस नॉन-कड़ाई में विधि कॉल लुकअप को विफल कर देता है, और साइलेंस में प्रॉपर्टी लुकअप को विफल कर देता है - यह सदस्य लुकअप के लिए एक असाधारण बारीकियों, एक अविश्वसनीय रूप से सामान्य ऑपरेशन को जोड़ता है। यह किसी को भी मदद नहीं करता है जो उस बॉयलरप्लेट को आसान बनाकर सख्त जांच से लाभ उठाना चाहता है। यह पर्याप्त स्थितियों में पर्याप्त लोगों की मदद नहीं करता है, यह जटिलता के लिए जोड़ता है। और कोड को अधिक संगत बनाने के लिए यह बहुत सुविधाजनक है, मुझे नहीं लगता कि "इसे अनदेखा करें यदि आप इसे नहीं चाहते हैं" तो इसे खाड़ी में पकड़ना काफी मजबूत है।

PowerShell ऐसी चीज़ों को कर सकता है जो C # नहीं करता है, जैसे स्वचालित चर सेट करना, या अपवाद रखने के लिए एक मिसाल रखना और पर्दे के पीछे चुप हो जाना। एक बेहतर दृष्टिकोण होना चाहिए, जो सदस्य लुकअप को जटिल नहीं बनाता है, लेकिन सख्त सुरक्षा जांच बॉयलरप्लेट को सरल बनाता है ताकि जो लोग चेक का उपयोग करना चाहते हैं उनके पास आसान जीवन हो और जो लोग चेक से परेशान थे उनके पास आसान जीवन भी हो।

@HumanEquivalentUnit इन चीजों को कैसे चुप

$prop = $item?.Method().PropIwant ?? 'PropActionFailed'

वी

$prop = if ($null -ne $item) {
    $propIwant= $item.Method().PropIwant
    if ($null -eq $propIwant) {
        'PropActionFailed'
    }
    else {
        $propIwant
    }
}

और यह मामला असामान्य नहीं है। या आप सिर्फ $ErrorActionPreference = 'Stop' फेंक दें और पूरी तरह से try/catch में पूरी चीज़ को लपेटें ताकि नल की जाँच आसान हो जाए जो एक खराब पैटर्न (अपवाद-चालित तर्क) है।

इसके अलावा, यह भाषा का भविष्य है, ऐसा नहीं है कि हम 5.1 पर वापस जा रहे हैं और चीजों को बदल रहे हैं। यदि आप अधिक गोद लेने वाले चाहते हैं, तो आपको कोड पढ़ना आसान बनाने की आवश्यकता है, जो मुझे लगता है कि यह सुझाव देता है।

@ mklement0 मुझे लगता है कि आप "अपने कोड_ को बेहतर बनाने के लिए सख्त मोड का उपयोग करने वाले व्यक्ति" से चर्चा कर रहे हैं और मैं इस दृश्य से "_someone मेरे कोड को कड़ेपन में चला सकता हूं, क्या बदलाव मेरे कोड को उनके लिए भी काम करेंगे?" _ "

क्या हम "सेट-ओयूओ पाइपफेल" (बैश सख्त मोड) समकक्ष के बारे में बात कर रहे हैं?

a- चर लुक-अप की सीमा (हालांकि मैं यह नहीं देखता कि आपको क्यों लगता है कि सदस्य लुकअप पर एक सरल अशक्तता एक बुरी बात होगी, वास्तविक सदस्य लुकअप if (result is null) से अधिक महंगा है)
b- पार्सर को कोडर / कोडब्लॉक पर [Strict] का उपयोग करें उन्हें इस तरह का व्यवहार करने के लिए पार्सर को बताएं,
c- स्ट्रिक्टनेस स्कोप पर आधारित है: जो कोड सख्त नहीं है, वह सख्त नहीं है।

यदि मैंने सख्त कोड लिखा है जो आपके उपयोग करने पर विफल हो जाता है, तो हम में से एक ने गलती की। या तो मैंने कोड में एक लापता चर का उल्लेख किया जिसका मैंने कभी परीक्षण नहीं किया है या आपने मेरी बुरी तरह से डिज़ाइन की गई एपीआई को गलत समझा है जो उन चर के अस्तित्व पर निर्भर करता है जो मेरे फ़ंक्शन में पारित नहीं हुए हैं और आप एक चर को आबाद करने में विफल रहे हैं जिसकी मुझे उम्मीद है .. ।

# Their code
Function Log($Message) { Write-Host $Massege }  # not strict

# My code
[Strict]
Function DebugMsg
{
  Param([String] $Message)
  if ($DEBUG) { Log Host $Message }
}

# Your code
DebugMsg "Hello"  # you didn't define DEBUG, and by saying strict I expressed a contract whereby the variable MUST be defined.

"लॉग" फ़ंक्शन को सख्त चिह्नित नहीं किया गया था, इसलिए यह टाइपो के बारे में शिकायत नहीं करता है

🤔 अब जब आप इसका उल्लेख करते हैं, तो एक [Strict()] विशेषता एक _awesome_ तरीका होगा जो स्कोप-प्रतिबंधित तरीके से सख्त मोड को लागू करेगा। कि सख्त मोड मुद्दों पर उस अन्य मुद्दे के धागे में उल्लेख किया जाना चाहिए, मैं इसे खोदता हूँ और यहाँ वापस लिंक करता हूँ ...

@ TheIncorrigible1 " यह इन चीजों को चुप कैसे करता है? " गैर-सख्त मोड में $null.x चुप है, $null.x() एक अपवाद है। ?. चर्चा के साथ, $null?.x चुप है, $null?.x() चुप है।

तो आपके पास . जो कि C # के ?. तरह काम करता है, सिवाय सख्त-मोड में जहां यह अपवादों को फेंकता है। फिर आपके पास एक ?. जो C # के ?. जैसे सख्त मोड में काम करता है और जैसे PowerShell का . गैर-सख्त मोड में काम करता है, लेकिन जो PowerShell के . अलग तरीके से काम करता है विधि कॉल के लिए ?. स्पष्ट रूप से बेहतर है और उन परिदृश्यों में अधिक उपयोगी है)।

आपको पहले की तुलना में अपवाद हैंडलिंग और अशक्त चेक का भार लिखना होगा: इसके बजाय: $prop = $item?.Method().PropIwant ?? 'PropActionFailed'

आपका तरीका कॉल फेंक सकता है, या $ null वापस कर सकता है और PropIWant गायब हो सकता है, आपको अभी भी लिखना होगा:

$prop = try {
    $item?.Method()?.PropIwant ?? 'PropActionFailed'  
} catch [someMethodException] {
    'PropActionFailed'
}

मेरे प्रस्तावित ?? (यदि यह निर्माण करना संभव था) के साथ, और ?. की कोई आवश्यकता नहीं है, और यह आपके द्वारा परवाह किए जाने के मामले में विधि अपवादों के संभावित मामलों को शामिल करता है "सफलता या नहीं" और कोई विस्तृत त्रुटि हैंडलिंग नहीं है।

$prop = $item.Method().PropIWant ?? 'AnythingFailed'

यदि आप अधिक गोद लेने वाले चाहते हैं, तो आपको कोड पढ़ने में आसान बनाने की आवश्यकता है, जो मुझे लगता है कि यह सुझाव देता है।

PowerShell में आप कितनी बार . टाइप करते हैं? आप कितनी बार नए उपयोगकर्ताओं को यह समझाना चाहते हैं कि . और ?. बीच क्या अंतर है और उन्हें बताएं कि उन्हें हर बार . हमेशा टाइप करने पर अंतर होगा ?

"ओह, यह कैसे हुआ?" "वेल इन C # . ने लापता सदस्यों के लिए एक अपवाद फेंक दिया, इसलिए उन्होंने ?. आविष्कार किया, जो कि अच्छा नहीं था। इसलिए उन्होंने डिफ़ॉल्ट रूप से PowerShell में . फेंकता नहीं है। तब उन्होंने सख्त मोड का आविष्कार किया, जो . C # की तरह व्यवहार करता है और फेंकता है, लेकिन केवल उस संदर्भ में, लेकिन मैन्युअल रूप से सदस्यों की जांच करने का तरीका वास्तव में चिंताजनक और परेशान करने वाला था और कोई भी इसे टाइप नहीं करना चाहता था; उस समस्या को सिर-पर संबोधित करने और कड़ेपन से लाभान्वित करने के लिए और अधिक सुविधाजनक बनाने के बजाय, उन्होंने उस बात को चकमा दिया और आपके द्वारा पूछे गए कड़ेपन से डरकर बाहर निकलने के बजाय सी # ?. , जो कि हल्के से सुविधाजनक है आपके लिए, लेकिन बाकी सभी के लिए बेकार है। और आपके पास अभी भी कोई सदस्य अस्तित्व परीक्षण नहीं है, और कड़ाई से लाभ अभी भी चिंताजनक और परेशान है, लेकिन कम से कम आपको यह नहीं भुगतना पड़ता है क्योंकि 'सफ़मोड' में 'नॉर्ममोड' पलायन हैच है अभी"। Ick।

यदि मैंने सख्त कोड लिखा है जो आपके उपयोग करने पर विफल हो जाता है, तो हम में से एक ने गलती की।

हालाँकि मैं यह नहीं देखता कि आप यह क्यों सोचते हैं कि सदस्य लुकअप पर एक साधारण अशक्तता एक बुरी बात होगी, वास्तविक सदस्य लुकअप अगर (परिणाम शून्य है) की तुलना में अधिक महंगा है

मुझे नहीं लगता कि यह बुरा होगा, पीएस गैर-सख्ती पहले से ही है, और मुझे लगता है कि प्रस्तावित ?. लिए एक वांछनीय विकल्प होगा - बहुत अलग, अधिक परिस्थितियों में उपयोगी।

लेकिन ध्यान दें कि PS में आप कुछ कर सकते हैं C # नहीं:

(1..3)[1kb..100kb]

और गैर-कड़ाई में कोई अपवाद नहीं। संख्याएं बदलें और देखें कि इसमें कितना समय लगता है; प्रदर्शन को देखते हुए और मुझे लगता है कि यह मनमाना वस्तुओं में अनुक्रमित करने के लिए पर्दे के पीछे काम करना चाहिए, ऐसा लगता है कि वास्तव में हमारी सुविधा के लिए ~ 100,000 अपवाद उठाए और खामोश किए जा रहे हैं। PS हमेशा "जितना संभव हो उतना तेज़ नहीं होना चाहिए, उपयोगकर्ता की पसंद पर असुविधा को धक्का दे", और मुझे इसके बारे में पसंद है।

@HumanEquivalentUnit हर भाषा में कई विशेषताएं हैं जिनका उपयोग आप अपने करियर में कभी नहीं कर सकते हैं और यदि आपको शैली पसंद नहीं है, तो यह ठीक है, आपको उन सुविधाओं का उपयोग करने की आवश्यकता नहीं है। मैं यह नहीं देखता कि आप सख्त मोड क्यों लिख रहे हैं; यह लिपियों में एक अच्छा अभ्यास है इसलिए आप होशपूर्वक समस्याओं से निपटने की बजाय भाषा को निगलने दें (और संक्षेप में, हर जगह खाली कैच ब्लॉक होने का मतलब है)। फिर से, आप अभी भी सुविधाओं का उपयोग नहीं करने के लिए स्वागत कर रहे हैं (जैसे मैंने कभी Out-Default उपयोग नहीं किया है)।

इसके अलावा, ऑपरेटर ? , ?. ; यह इंडेक्स एक्सेस के साथ भी काम करेगा।

आगे की चर्चा के लिए जमीनी कार्य करना जारी रखने के लिए, मुझे संक्षेप में बताएं कि मौजूदा सख्त मोड अशक्त-मूल्य-सशर्त और सदस्य-अस्तित्व-सशर्त पहुंच ( ऊपर दी गई शर्तों) को कैसे प्रभावित करते हैं:

नीचे दिए गए कॉलम Set-StrictMode सेटिंग्स का प्रतिनिधित्व करते हैं, और कॉलम मान इंगित करते हैं:

• 👍 ... अनुमति दी
• 🚫 ... निषिद्ध (कथन-समाप्ति त्रुटि का कारण बनता है)

एक तरफ: तथ्य यह है कि त्रुटियाँ केवल _statement-_ हैं, _script_-terminating नहीं, PowerShell की त्रुटि हैंडलिंग के आसपास बड़ी चर्चा से संबंधित हैं - https://github.com/PowerShell/PowerShell/Docs/issues/1583 देखें।

• _Null-value_-सशर्त पहुंच - $obj _itself_ $null :

निर्माण | -ऑफ | -विरोध 1 | -विरोध 2 | -विस्तृत 3+
---------- | ---- | ---------- | ---------- | ------------
$ obj | 👍 | 🚫 | 🚫 | 🚫
$ obj.Prop | 👍 | 👍 | 🚫 | 🚫
$ obj [42] | 🚫 | 🚫 | 🚫 | 🚫
$ obj.Method () | 🚫 | 🚫 | 🚫 | 🚫

यह उत्सुक है कि -Off और -Version 1 , $obj.Prop की अनुमति है, जबकि $obj[42] नहीं है।

• _Member-अस्तित्व_-सशर्त पहुंच - $obj गैर- $null , लेकिन जिस सदस्य / तत्व को एक्सेस किया जा रहा है, वह मौजूद नहीं है:

निर्माण | -ऑफ | -विरोध 1 | -विरोध 2 | -विस्तृत 3+
---------- | ---- | ---------- | ---------- | ------------
$ obj.Prop | 👍 | 👍 | 🚫 | 🚫
$ obj [42] (इंडेक्सेबल) | 👍 | 👍 | 👍 | 🚫
$ obj [42] (गैर-अनुक्रमित) | 👍 | 👍 | 🚫 | 🚫
$ obj.Method () | 🚫 | 🚫 | 🚫 | 🚫

यह उत्सुक है कि स्वाभाविक रूप से अनुक्रमित वस्तुएं (उदाहरण के लिए, सरणियां) -Version 2 साथ भी किसी न किसी तत्व तक पहुंच की अनुमति देती हैं, जबकि स्केलर - जहां पावरशेल संग्रह के साथ एकीकृत हैंडलिंग के लिए अनुक्रमण क्षमता प्रदान करता है - नहीं।

अशक्त-भिगोने ( अशक्त-सशर्त या सी # में एल्विस ) ऑपरेटर लगभग अनिवार्य है जब StrictMode नवीनतम में चल रहा है और एक संपत्ति है कि हो सकता है पर पहुँचने का प्रयास या नहीं हो सकता मौजूद हैं। वर्तमान में आपको इस तरह बेवकूफाना चाल का सहारा लेना होगा:

function Get-OptionalPropertyValue($object, [string] $propertyName) {
    if (-not ([bool] (Get-Member -InputObject $object -MemberType Properties -Name $propertyName))) {
        return $null
    }

    $object.$propertyName
}

$value = Get-OptionalPropertyValue $foo "bar" # if $foo.bar exists, $value will contain its data; else $value will be $null

जब आप _really_ बस लिखने में सक्षम होना चाहिए:

$value = $foo?.bar # if $foo.bar exists, $value will contain its data; else $value will be $null

कृपया लोग, यदि आप इस प्रस्ताव को लागू करने और केवल संपत्तियों के लिए केवल अशक्त हो सकते हैं, तो इससे बहुत सारे लोगों को इतना दर्द होगा।

मैं इस पर एक नज़र रखना शुरू कर दिया और कुछ समस्याओं को पाया।

आओ हम ?? और ?=

$x ?= 1 और $x ?? 1 सीधे लगते हैं। लेकिन, जब से वे ऑपरेटर हैं हमें $x?=1 और $x??1 का समर्थन करने की आवश्यकता है।

उस समस्या के साथ $x? और $x?? दोनों PowerShell में वैरिएबल नामों को मान्य करते हैं। प्रतिज्ञा करने का एकमात्र तरीका ${x}?=1 और ${x}??1 ।

और सशर्त सदस्य के लिए अधिक ?. और ?[] का उपयोग करना होगा, हमें ${x}?.name और ${x}?[0] ।
इनके लिए, $x ?.name और $x ?[0] का समर्थन नहीं किया जाएगा।

दूसरा विकल्प एक ब्रेकिंग परिवर्तन को लागू करना ? अनुमति नहीं है।

तुम क्या सोचते हो? @ mklement0

/ cc @rjmholt @ daxian-dbw @JamesWTruher

मैंने कभी भी विशेष रूप से _leded_ नहीं किया है और न ही यह समझा है कि ? एक वैध चर नाम क्यों है। यह $Safe? जैसे नामों के लिए दरवाजा खोलता है जो आम तौर पर $IsSafe रूप में लिखे जाने पर आमतौर पर अधिक स्पष्ट और कम अजीब होते हैं।

मुझे लगता है कि बदलाव को आने में काफी समय लग गया है।

यह $ सेफ जैसे नामों के लिए दरवाजा खोलता है? जो आमतौर पर अधिक स्पष्ट और कम अजीब है जब $ IsSafe के रूप में वैसे भी लिखा जाता है

दिलचस्प रूप से मैंने विपरीत भावना व्यक्त की। यह एक क्लासिक योजना / रूबी परंपरा है।

if ($questionMark?)
{
    Write-Host "That's silly!"
}

क्या टर्नरी ऑपरेटर के पास यह समस्या नहीं थी, जहां रिज़ॉल्यूशन के लिए ऑपरेटर के चारों ओर रिक्त स्थान की आवश्यकता होती थी या चर नाम के चारों ओर घुंघराले ब्रेसिज़ की आवश्यकता होती थी ताकि इसके लिए ? साथ समाप्त होने वाले चर के साथ ठीक से काम कर सकें?

मुझे उम्मीद है कि इन ऑपरेटरों को पेश किए जाने के साथ, PowerShell सिंटैक्स में ऑपरेटर के हिस्से के रूप में ? को पहचानने को प्राथमिकता देगा जैसे $x?[0] , ऐसे उपयोगकर्ता जो ? में समाप्त होने वाले चर नामों का उपयोग करते हैं ? को इस सिंटैक्स का उपयोग करना होगा (चूंकि रिक्त स्थान इस मामले में अमान्य होगा): ${x?}?[0] । $x?.Name और ${x?}?.Name ।

दूसरा विकल्प यह है कि ब्रेकिंग चेंज को लागू किया जाए और अनुमति नहीं दी जाए? चर नाम में बिल्कुल।

A यह देखते हुए कि यह एक प्रमुख संस्करण परिवर्तन (6 से 7) है, मुझे लगता है कि यह एक ब्रेकिंग परिवर्तन के लायक है। काश GitHub के पास बेहतर कोड खोज होती, यह देखने के लिए कि पीएस चर के कितने उदाहरण हैं जो ? साथ समाप्त होते हैं। मुझे संदेह है कि यह इतना प्रभावशाली नहीं होगा लेकिन यह अच्छा होगा कि इसे GitHub के खिलाफ सत्यापित किया जाए। PowerShell का उपयोग करने के 14 वर्षों में, मैंने कभी भी एक चर नाम में ? का उपयोग नहीं किया है, लेकिन शायद यह सिर्फ मेरे लिए है। :-)

यह जहाज बहुत पहले ही रवाना हो चुका है, और आज स्क्रिप्ट में ? साथ समाप्त होने वाले चर को देखकर मुझे आश्चर्य नहीं होगा।

इस बिंदु पर अगर हम बस एक परिवर्तनीय नाम के हिस्से के बजाय एक ऑपरेटर के हिस्से के रूप में ? पार्सिंग को प्राथमिकता देते हैं, तो इन नए ऑपरेटरों की बात आती है, जो लोग ? में समाप्त होने वाले चर नामों का उपयोग करेंगे। इन ऑपरेटरों के साथ उन चर का उपयोग करने के लिए {} या रिक्त स्थान (जहां रिक्त स्थान की अनुमति है) का उपयोग करें।

इस संदर्भ में "वह जहाज रवाना हो गया" वाक्यांश सुनना अजीब है। यह एक _मेजर संस्करण_ परिवर्तन है। मुझे लगता है कि यह यहाँ बदलने के लिए अनुचित नहीं है।

@rkeithhill मैंने इसे व्यक्तिगत सामान में इस्तेमाल किया है, लेकिन सोचा कि यह सहयोगी काम के लिए अस्पष्ट होगा क्योंकि यह प्रोग्रामर के लिए एक ऐसी सहज ज्ञान युक्त चीज़ है जो चर नामों के हिस्से के रूप में प्रतीक के समान है (चर के रूप में इमोजी का उपयोग करने के समान)

@KirkMunro "प्राथमिकता वाले पार्सिंग" कीड़े के लिए एक खुले दरवाजे की तरह लगता है।

@ vexx32 : ब्रेकिंग चेंज के लिए यह अनुचित नहीं है क्योंकि यह एक प्रमुख संस्करण परिवर्तन है; हालाँकि, इस तरह के ब्रेकिंग परिवर्तन के लिए बार बहुत अधिक होना चाहिए, और मुझे नहीं लगता कि यह उस बार को पास करने के करीब आता है, क्योंकि उपयोगकर्ता ? में समाप्त होने वाले चर का उपयोग कर सकते हैं जब तक वे {} उपयोग करते हैं चर नाम की पहचान करने के लिए

ध्यान दें कि आपके पास एक संपत्ति का नाम हो सकता है जो ? में समाप्त होता है। वर्तमान में यदि आप उद्धरणों में नाम लपेटे बिना PowerShell में ऐसी संपत्ति देखने का प्रयास करते हैं, तो आपको एक पार्सर त्रुटि मिलेगी।

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

PS C:\> $o = [pscustomobject]@{
    'DoesItBlend?' = $true
}
PS C:\> $o.DoesItBlend?
At line:1 char:15
+ $o.DoesItBlend?
+               ~
Unexpected token '?' in expression or statement.
+ CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : UnexpectedToken

PS C:\> $o.'DoesItBlend?'
True

मुझे थोड़ी हैरानी हुई कि आज पार्स क्यों नहीं किया जाता (वह परसेज़ क्यों नहीं है?), लेकिन इस तरह के गुणों के लिए, आपको उन नामों को उद्धरणों में संलग्न करने की आवश्यकता होती है, जिस स्थिति में आप एक टर्नरी, अशक्त के साथ उद्धरण का पालन कर सकते हैं। -कॉलेजिंग, आदि स्थानों के बिना ऑपरेटर और यह ठीक काम करेगा। मुझे यह सिंटैक्स ${x?}?.name , और मैं इस रुख के साथ ठीक हूं कि यदि आप चाहें तो इस तरह के वैरिएबल / प्रॉपर्टी के नाम का उपयोग कर सकते हैं, लेकिन ऐसे नामों के लिए अतिरिक्त सिंटैक्स या रिक्ति की आवश्यकता हो सकती है जो टर्नरी या नल के साथ काम करते हैं। - * ऑपरेटरों।

@KirkMunro कुछ भी नहीं लोगों को चर-सीमा का उपयोग करने से रोकता है अगर वे गूढ़ चर नाम चाहते हैं। मैं अन्य लोगों से सहमत हूं कि मुझे आश्चर्य है कि वर्तमान में उस व्यवहार का वर्तमान उपयोग क्या है।

पावरशेल 7 पर लोग पहले से ही उत्साही हैं और ब्रेकिंग परिवर्तनों के बारे में जानते होंगे। जो लोग नहीं हैं, वे अभी भी <= v5.1 का उपयोग कर रहे हैं और लंबे समय तक जारी रहेंगे; जब तक msft इसे विंडोज 10 (कभी नहीं) से हटा देता है।

@KirkMunro ज़रूर, लेकिन इसे मानक अनुमेय चर वर्णों से हटाने से उपयोगकर्ताओं को वैसे भी चर नाम के रूप में ${Valid?} करने से रोका नहीं जा सकता। चूँकि उन्हें इन संचालकों के साथ ऐसा करना होगा, इसलिए मुझे लगता है कि यह बेहतर होगा कि इसके अनुरूप होना चाहिए, बजाय इसके कि ? एक ऐसा पात्र बन जाए, जो कभी-कभी एक चर नाम का हिस्सा माना जाता है।

यह पहले से ही _is_ एक ब्रेकिंग परिवर्तन होने जा रहा है, और मुझे लगता है कि यह कम से कम इसके बारे में सुसंगत होना चाहिए और किसी अन्य स्तर की अस्पष्टता का परिचय देने के बजाय सभी तरह से जाना चाहिए। 🙂

@adityapatwardhan मुझे लगता है कि भाषा के लिए ? को एक वैध चर चरित्र के रूप में निकालना बेहतर होगा। यह आसानी से एक परिचित वाक्यविन्यास में नल-सोख / -कलेरास और टर्नरी ऑपरेटरों दोनों को सक्षम करेगा जो स्क्रिप्ट संलेखन प्रक्रिया में बहुत सारे एर्गोनॉमिक्स जोड़ते हैं।

@KirkMunro "प्राथमिकता वाले पार्सिंग" कीड़े के लिए एक खुले दरवाजे की तरह लगता है।

@ Thecorrigible1 : कोई भी कोड बग के लिए दरवाजा खोल सकता है अगर इसे ठीक से लागू नहीं किया गया है। मैं सिर्फ एक साधारण एकल-वर्ण लुकहैड के बारे में बात कर रहा हूं, अगर यह पता चलता है कि पॉवरशेल टर्नरी या नल- * ऑपरेटर में चलता है, जब यह एक चर नाम को पार करता है जो कि चर सीमा में संलग्न नहीं है और एक ? वर्ण का सामना करता है। यह जटिल नहीं है, और किसी भी अन्य कोड परिवर्तन की तुलना में अधिक बग के लिए दरवाजा नहीं खोलता है।

पावरशेल 7 पर लोग पहले से ही उत्साही हैं और ब्रेकिंग परिवर्तनों के बारे में जानते होंगे। जो लोग नहीं हैं, वे अभी भी <= v5.1 का उपयोग कर रहे हैं और लंबे समय तक जारी रहेंगे; जब तक msft इसे विंडोज 10 (कभी नहीं) से हटा देता है।

@ TheInrigrigible1 : आपके पास उस कथन का क्या आधार / सबूत है? PowerShell 7 पूर्वावलोकन में है, इसलिए आज यह केवल उत्साही लोगों द्वारा उपयोग किया जाता है। वह दे दिया गया। पूर्वावलोकन से परे, यदि PowerShell 7 या बाद में सम्मोहक सुविधाएँ प्रदान करता है जो कंपनियों को चाहिए, जबकि उन्हें जिस कार्यक्षमता की आवश्यकता होती है, उसका समर्थन करते हुए वे उन संस्करणों का उपयोग करेंगे। यह विशेष रूप से सच है अगर OS ​​के साथ PowerShell 7 स्थापित हो जाता है। केवल इस बात पर कि उत्साही लोग खेल में आते हैं, उन संगठनों में हैं जिन्हें पॉवरशेल 7 की मेज पर लाने के लिए व्यावसायिक आवश्यकता नहीं है।

यह पहले से ही एक ब्रेकिंग परिवर्तन होने जा रहा है, और मुझे लगता है कि यह कम से कम इसके बारे में सुसंगत होना चाहिए और अस्पष्टता के एक और स्तर को पेश करने के बजाय सभी तरह से जाना चाहिए। 🙂

@ vexx32 इसे ?? थे, तो यह एक ब्रेकिंग परिवर्तन होगा, लेकिन इसकी संभावना एक चर होने की तुलना में बहुत अधिक दूरस्थ है जिसका नाम एक एकल ? में समाप्त होता है। इसके अलावा, null- * ऑपरेटर्स का परिचय आज भी ? को एक मानक अनुमेय चर चरित्र ब्रेक स्क्रिप्ट के रूप में समर्थन करते हुए कैसे होगा?

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

मैं चर नामों में कभी भी ? का उपयोग नहीं करता, न ही मैं कुछ लोगों से उम्मीद करता हूं, हालांकि, क्योंकि यह एक स्क्रिप्ट में बहुत अच्छी तरह से पढ़ सकता है, और PowerShell 7 के लिए प्रवेश के लिए अनावश्यक बाधाओं को लगाता है, बस गोद लेने को धीमा कर देता है, खासकर जब PowerShell के साथ काम करने वाले कई लोग डेवलपर्स नहीं हैं जो ब्रेकिंग परिवर्तनों के माध्यम से काम करने के अधिक आदी हैं।

वैसे भी, इस प्रक्रिया को धीमा करने का मेरा इरादा नहीं है - बल्कि इसके विपरीत। लेकिन मैंने अपने विचारों और अनुभव को साझा किया है, इसलिए मैं आगे इस पर कोई टिप्पणी नहीं करूंगा कि हमें यहां एक ब्रेकिंग बदलाव के लिए धक्का देना चाहिए या नहीं।

इस आकस्मिक उदाहरण पर विचार करें:

$ValueIsValid? = @( $true, $false, $false, $true )

$ValueIsValid?[0]
# old behaviour? gets `$true`
# new behaviour? gets nothing, because the `?[0]` is interpreted as a null-conditional access.

यह व्यवहार प्रस्तावित परिवर्तनों के साथ _already_ तोड़ देगा। मैं एक भ्रामक विराम की तुलना में एक सुसंगत, स्वच्छ विराम पसंद करूंगा, जिसे सभी संभावित अपवादों को सूचीबद्ध करने के लिए एक आधे-पृष्ठ स्पष्टीकरण की आवश्यकता है और जब ? अचानक वैध नहीं है, और जहां यह अभी भी है।

@KirkMunro यदि PowerShell 7 या बाद में सम्मोहक सुविधाओं की पेशकश करता है जो कंपनियों को चाहिए, जबकि उन्हें जिस कार्यक्षमता की आवश्यकता होती है, उसका समर्थन करते हुए वे अपने संस्करणों का उपयोग करेंगे। यह विशेष रूप से सच है अगर OS ​​के साथ PowerShell 7 स्थापित हो जाता है।

कुछ फॉर्च्यून 50 में काम करने के साथ कुछ कर्मचारी ठिकानों की संख्या हजारों में थी, यहां तक ​​कि ओएस पर डिफ़ॉल्ट से दूर होना एक चुनौती थी (यानी, v5.x पर जा रहा है)। मैंने अभी तक किसी भी स्थान को कोर को अपनाने के लिए नहीं देखा है; बल्कि वे क्रॉस-अनुकूलता के लिए केवल पायथन में चले जाएंगे। विंडोज वैकल्पिक सुविधाओं को सक्षम करना भी एक बहुत ही कम काम था।

मुझे लगता है कि कंपनियां अपनी समस्याओं को हल करने के लिए नई तकनीक या भाषा संस्करणों की तलाश में अपने कर्मचारियों और उनके कर्मचारियों के ज्ञान के आधार पर काम करती हैं। कुछ पूरी तरह से v2 पर रहने वाली सामग्री होगी और कभी भी Win10 / Server16 cmdlets को छूना नहीं होगा जो जीवन को नाटकीय रूप से आसान बनाते हैं।

इस सबके साथ मेरा कहना यह है कि ये सुविधाएँ शून्य में नहीं हैं। यदि आप एक भाषा को अधिक एर्गोनोमिक बनाते हैं, तो यह उन लोगों द्वारा अधिक से अधिक गोद लेने को देखेगा जो उपकरण में रुचि रखते हैं ताकि वे तेजी से होने वाली समस्याओं को हल कर सकें। (देखें: C # और अधिक / बेहतर भाषा सुविधाओं के साथ लोकप्रियता में वृद्धि)

? में समाप्त होने वाले चर के बारे में - जो स्वचालित चर $ के कारण एक महत्वपूर्ण ब्रेकिंग परिवर्तन हो सकता है

@lzybkr मुझे संदेह है कि इससे निपटने के लिए सबसे अच्छा मामला एक विशेष मामला है जैसे पहले से ही $^ और $$ ।

@lzybkr @ Thecorrigible1 जहाँ तक मुझे याद है, उन चर का _all_ स्पष्ट रूप से tokenizer में विशेष रूप से आवरण है। $^ _already_ एक मान्य चर नाम नहीं है। टोकनर में उन सभी के लिए विशेष मामले हैं जो मानक चर नामों की तलाश शुरू करते हैं।

यहाँ एकमात्र उपाय ¿ :

मूर्खतापूर्ण $? ¿= 1

मैं स्टीव स्टीव, मैं दृढ़ता से इस पर भीड़ भीड़ में हूँ।

$silly?‽=1

@lzybkr - मेरे ज्ञान में $? $$ और $^ विशेष तरीके से व्यवहार किया जाता है।

https://github.com

संक्षेप में, हमारे पास ये चार विकल्प हैं

• बिग ब्रेकिंग परिवर्तन - चर नामों में ? अनुमति न दें।
• एक ऑपरेटर के रूप में ?. प्राथमिकता दें। इसका अर्थ है कि ? साथ समाप्त होने वाले चर नाम ${variablename} सिंटैक्स का उपयोग करना चाहिए। फिर भी एक परिवर्तन।
• पुराने व्यवहार को प्राथमिकता दें। इसका मतलब है ?. और ?[] , ${variablename}?.property उपयोग करना चाहिए। कोई ब्रेकिंग परिवर्तन नहीं है, लेकिन नए ऑपरेटरों को अनाड़ी बना देता है।
• नए ऑपरेटरों को लागू न करें।

मैं व्यक्तिगत रूप से, 1 और अंतिम को पसंद नहीं करता हूं।

यह एक प्रमुख संस्करण परिवर्तन है। मुझे लगता है कि यह यहाँ बदलने के लिए अनुचित नहीं है।

मुझे लगता है कि बनाने के लिए एक महत्वपूर्ण बिंदु यह है कि विंडोज पॉवरशेल को बदलने के लिए तत्परता को इंगित करने के लिए प्रमुख संस्करण को बढ़ाया जा रहा है, जो यह कहना है कि यह संगतता को दर्शाता है, टूटना नहीं। मूल घोषणा से :

ध्यान दें कि प्रमुख संस्करण का अर्थ यह नहीं है कि हम महत्वपूर्ण परिवर्तन कर रहे हैं।

क्या विकल्प 1 और 2 समान नहीं हैं? या वैरिएबल को अभी भी ? का उपयोग करने की अनुमति होगी, इस मामले में कि उनके पीछे कोई अशक्त-सहवर्ती या टर्नरी ऑपरेटर नहीं है?

यदि ऐसा है, तो मुझे लगता है कि हमें बहुत अधिक बैकट्रैकिंग के बिना टोकन / पार्सिंग लॉजिक को संभालने में बहुत परेशानी हो सकती है। जब चर ? साथ समाप्त होते हैं, तो प्रदर्शन में गिरावट हो सकती है।

यह देखते हुए कि मैं जो देख सकता हूं, विकल्प 2 सामान्य पसंद प्रतीत होता है, मुझे वास्तव में यकीन नहीं है कि मैं यहां परिवर्तन को बदलने की अनिच्छा को समझता हूं। इस तरह से ऐसा करना सक्रिय रूप से ? का उपयोग चर नामों में वैसे भी कर देगा, बस उन परिदृश्‍यों को शुरू करने से जो चर नाम को शामिल किए बिना उपयोग करने योग्य नहीं हैं।

मुझे लगता है कि यह एक बहुत ही मामूली बदलाव है क्योंकि परिवर्तन बदलते रहते हैं, और एक चर नाम में इस्तेमाल नहीं की जा सकने वाली स्थिरता में एक विराम है, शायद मेरी राय में सबसे बुरा विकल्प है।

इन चीजों में स्पष्ट नियम होने चाहिए जो बहुत सारी स्थितियों में लागू होते हैं। वर्तमान में, यह मामला है। हम यहाँ पानी को मैला करने और व्यवहार को स्पष्ट करने का प्रस्ताव दे रहे हैं। मुझे इसमें से कुछ भी अच्छा नहीं दिखाई दे रहा है, सिवाय इसके कि शायद चर नाम ? कम उपयोग किए जाएं क्योंकि वे कुछ परिदृश्यों में उपयोग करना कठिन हैं - जो (प्रभावी रूप से) हमें विकल्प 1 में वापस लाता है। डिफ़ॉल्ट रूप से, लगभग ... इसलिए मुझे अब ब्रेक नहीं लेने और अस्पष्ट व्यवहार से बचने का कोई विशेष कारण नहीं दिखता है।

@ vexx32 1 और 2 के बीच थोड़ा अंतर है।

# 1 के लिए हम सभी नामों को एक साथ चर नामों में उपयोग करने के लिए ? को अस्वीकार करते हैं। इसका मतलब है $x? = 1 , $x?? = 1 $x?x?x = 1 पार्स नहीं होगा।

# 2 के लिए, $x? = 1 अभी भी मान्य है लेकिन $x?.name ${x}?.name बराबर है। यह केवल अंत में ? साथ परिवर्तनीय नामों को तोड़ता है, जो सदस्यों तक पहुंच रहे हैं। तो, $x? = 1 , $x?? = 1 $x?x?x = 1 अभी भी मान्य होंगे।

हाँ, मैं वहाँ पर टोकन के बारे में थोड़ा चिंतित हूँ। दोनों संभावनाओं को लागू करने और एक स्क्रिप्ट पर कुछ बेंचमार्क करने के लायक हो सकता है जो समान रूप से भारी समान चर नाम का उपयोग करता है।

मेरी प्राथमिकता निश्चित रूप से विकल्प 1 है ... एक बार का ब्रेकिंग चेंज, कम से कम मेरे लिए है, इस तरह से विसंगतियों से निपटने के लिए अधिक बेहतर तरीका है कि भविष्य में किस तरह से पार्स किया जा सकता है।

यदि ऐसा है, तो मुझे लगता है कि हमें बहुत अधिक बैकट्रैकिंग के बिना टोकन / पार्सिंग लॉजिक को संभालने में बहुत परेशानी हो सकती है। जब चर समाप्त हो जाते हैं, तो यह प्रदर्शन में गिरावट ला सकता है?

मैं इस संभावना के बारे में इस चिंता को साझा करता हूं। एक कभी-कभी-विभाजक के रूप में ? होने से मुझे भाषा में एक दांतेदार रेखा की तरह महसूस होता है।

यदि ऐसा है, तो मुझे लगता है कि हमें बहुत अधिक बैकट्रैकिंग के बिना टोकन / पार्सिंग लॉजिक को संभालने में बहुत परेशानी हो सकती है। जब चर समाप्त हो जाते हैं, तो यह प्रदर्शन में गिरावट ला सकता है?

यह इस बात पर निर्भर करता है कि आप इसे कैसे लागू करते हैं। जब तक आप टोकन के बजाय लुकहेड दृष्टिकोण लेते हैं और फिर बैक-अप दृष्टिकोण होता है, आपको ठीक होना चाहिए। आप आगे देख सकते हैं कि जब आप एक चर नाम में ? का सामना करते हैं तो कौन से वर्ण होते हैं, और आप आगे क्या है, इसके आधार पर चर टोकन को "रैप" कैसे करना चाहते हैं, इस पर निर्णय लें। यह बहुत ज्यादा परेशानी की बात नहीं है और इसके लिए पीछे हटने की आवश्यकता नहीं है या ध्यान देने योग्य प्रदर्शन में गिरावट आई है।

@ पावरशेल / पावरशेल-समिति ने आज इसकी समीक्षा की, हमारे पास कुछ विचार हैं:

• कोई फर्क नहीं पड़ता कि हम क्या करते हैं, हम अपनी लिपियों के हमारे विश्लेषण का कुछ विश्लेषण करने जा रहे हैं कि लोग कितनी बार चर नामों में ? का उपयोग करते हैं
• हम में से कुछ की एक परिकल्पना है (जो अन्य लोग मान्य करना चाहते हैं) जो उपयोगकर्ता अपने चर नामों में ? का उपयोग कर रहे हैं वे कम उन्नत उपयोगकर्ता हो सकते हैं (जैसा कि हम इस कमरे में सहमत हैं कि हम इससे दूर रहेंगे क्योंकि संभावित समस्याएं जो उत्पन्न हो सकती हैं)। दूसरी ओर, यहां वर्णित कार्यक्षमता का उपयोग करने वाला कोई भी व्यक्ति थोड़ा अधिक जटिल वाक्यविन्यास (जैसे ${foo}?.bar ) को समझने में सक्षम होगा। इसलिए, हम विकल्प 3 को पसंद करते हैं क्योंकि यह इन कम अनुभवी उपयोगकर्ताओं पर परिवर्तन से बचता है। (लेकिन फिर, हम इसे पहली गोली के अनुसार मान्य करेंगे।)
• @ daxian-dbw ने सभी चर संदर्भों को खोजने के लिए इसे कठिन बनाने के बारे में एक अच्छा बिंदु उठाया जब स्क्रिप्टर्स $foo और ${foo} उपयोग मिश्रण कर रहे हैं। हालाँकि, हम इस बात पर सहमत थे कि इसे टूलींग (वीएस कोड पॉवरशेल एक्सटेंशन की तरह) में तय किया जा सकता है, और

सभी चर संदर्भों को खोजना कठिन है जब स्क्रिप्टर्स $ फू और $ {फू} के उपयोग को मिला रहे हैं

यह इस बात पर निर्भर करता है कि एएसटी वैरिएबल नाम को अलग करता है या नहीं, इसके आधार पर यह ब्रेसिज़ को देखता है। मुझे संदेह है कि कोई भी उपकरण जो PowerShell AST का उपयोग करता है उसे यहां ब्रेसिज़ से कोई परेशानी नहीं होगी।

लेकिन रेगेक्स के लिए, इसका निश्चित रूप से मतलब है कि आपको अधिक जागरूक होना होगा: varname -> \{?varname\}?

@rjmholt मैंने यहाँ पर एक विश्लेषण किया। एक त्वरित ब्रेकडाउन: 22,000,000+ चर नामों (अद्वितीय नहीं) के साथ लगभग 400,000 लिपियों में से, केवल ~ 70 अद्वितीय चर थे जो ? साथ समाप्त हुए।

धन्यवाद, @mburszley - मेरे लिए यह एक बनाता है कि बाल्टी 3: संभावना ग्रे क्षेत्र परिवर्तन, और की आवश्यकता के साथ बोझ उपयोगकर्ता {...} अत्यधिक दुर्भाग्यपूर्ण है, समानांतर के लिए दुर्भाग्यपूर्ण जरूरत $(...) चारों ओर exit / return / throw && || ।

उस मुद्दे से तर्क उधार लेने के लिए:

यदि हम चर नामों के आसपास {...} का उपयोग करने के लिए मजबूर करते हैं, तो आप ?. उपयोग कर सकते हैं:

• नए उपयोगकर्ता {...} आवश्यकता की उम्मीद नहीं करेंगे और आवश्यक रूप से नहीं जान पाएंगे कि _it_ क्या है जब निम्नलिखित विफल रहता है (संभवतः _undetected_, जब तक कि Set-StrictMode -Version 2 या उच्चतर प्रभाव में न हो): $o = [pscustomobject] @{ one = 1 }; $o?.one

• एक बार भी उपयोगकर्ता _do_ को {...} की आवश्यकता के बारे में पता है:

  • वे इस अवसर पर इसका उपयोग करना भूल जाएंगे, क्योंकि इसके लिए प्रति-सहज आवश्यकता है।
  • जब वे याद करते हैं, तो यह प्रतीत होता है कि कृत्रिम आवश्यकता निराशा का एक निरंतर स्रोत होगी, खासकर जब से {...} टाइप करना मुश्किल है।

इस मुद्दे को निर्धारित के रूप में चिह्नित किया गया है और 1 दिन के लिए कोई गतिविधि नहीं हुई

@rjmholt , आपको https://github.com/PowerShell/PowerShell/issues/10967#issuecomment -561843650 से उद्धृत कर रहा है:

जिस तरह से हम मौजूदा वैध सिंटैक्स को पार्स करते हैं उसे तोड़ने का सही तरीका नहीं था। फिर से, वहाँ एक बदलाव नहीं है, हम में से एक बड़ी संख्या में जंगली कार्यक्रमों का समर्थन करने का निर्णय ले रहे हैं - हमने उन मामलों में कई बदलाव किए हैं, जहां हमने सोचा था कि पेशेवरों ने विपक्ष को बाहर कर दिया है (ऐसा नहीं है कि मैं व्यक्तिगत रूप से सहमत हूं उन सभी के साथ, या यह कि वे दूसरों को सही ठहराते हैं या नहीं करते हैं)। मुद्दा यह है कि टोकनर या पार्सर के कुछ पहलू को बदलने का मतलब है कि दो पॉवरशेल संस्करण अब कुछ स्क्रिप्ट के लिए एक ही एएसटी उत्पन्न नहीं करेंगे, इसलिए दो पॉवरशेल्स एक ही स्क्रिप्ट को अलग तरह से "देखेंगे"। इसका मतलब है कि हम सिंटैक्स को भी उसी तरह नहीं पढ़ सकते हैं, इसलिए कोई PSScriptAnalyzer नियम नहीं है जिसे आप इसके बारे में संभावित मामलों को लेने के लिए लिख सकते हैं; PSScriptAnalyzer एक PowerShell संस्करण से अगले तक एक अलग वाक्यविन्यास देखेगा।

C # के विपरीत, PowerShell एक अलग सिंटैक्स को बाद के निष्पादन के लिए एक संगत प्रारूप में संकलित नहीं कर सकता है, जिसका अर्थ है कि एक सिंटैक्टिक परिवर्तन रनटाइम के लिए सीमित है। एक बार पावरशेल एक सिंटैक्टिक ब्रेक कर देता है, हम विभिन्न संस्करणों के खिलाफ काम करने वाली स्क्रिप्ट की संख्या को कम कर सकते हैं, जिसका अर्थ है कि उपयोगकर्ताओं को दो स्क्रिप्ट लिखने के लिए मजबूर किया जाता है, जो शेल और स्क्रिप्टिंग भाषा के लिए एक गंभीर मुद्दा है। पॉवरशेल को एक स्क्रिप्ट के अंदर तर्क के साथ सभी मतभेदों को मोड़ने के लिए पर्याप्त रूप से गतिशील माना जाता है, लेकिन सिंटैक्स एक गैर-समझौतावादी स्थिर चीज़ है जो हमारे पास है। और वाक्यविन्यास में बदलाव करना जहां पहले और बाद में मान्य है, विशेष रूप से खतरनाक है, क्योंकि इसका पता लगाने का कोई सरल तरीका नहीं है, इसके लिए कोई चेतावनी नहीं है और दोनों परिवेशों में इसे निष्पादित करने के बाद भी, उपयोगकर्ताओं को पता नहीं चल सकता है कि एक अलग व्यवहार हुआ।

सामान्य तौर पर, मैं सराहना कर सकता हूं कि इस तरह के परिवर्तन बहुत समस्याग्रस्त हो सकते हैं और केवल तभी किया जाना चाहिए जब पेशेवरों ने विपक्ष को पछाड़ दिया, एक महत्वपूर्ण कारक यह है कि मौजूदा कोड कितना टूटता है।

हम विभिन्न संस्करणों के खिलाफ काम कर सकने वाली लिपियों की संख्या को कम कर देते हैं
अर्थ उपयोगकर्ताओं को दो स्क्रिप्ट लिखने के लिए मजबूर किया जाता है

हम यहां एक _new_ सिनेटिक फीचर के बारे में बात कर रहे हैं ( ?. ), इसलिए परिभाषा स्क्रिप्ट जो इसका उपयोग करती हैं _cannot_ (सार्थक रूप से) पुराने संस्करणों पर चलती हैं - जब तक कि आप विशेष रूप से उन शर्तों को नहीं जोड़ते हैं जो विरासत-संस्करण-संगत-संगत पथ प्रदान करते हैं, लेकिन लगता है कि शायद ही इसके लायक है - आप तो बस विरासत सुविधाओं के साथ रहना होगा।

हां, पुरानी लिपियों में $var?.foo की व्याख्या जो एक चर नाम के रूप में $var? , लेकिन:

• ? को कभी भी एक पहचानकर्ता के भाग के रूप में अनुमति नहीं दी जानी चाहिए _woutout ने इसे {...} _ में संलग्न किया।

• चूंकि ऐसा करने में सक्षम होना अप्रत्याशित है और शायद कई लोगों के लिए भी _unknown_, ऐसे चर नाम जंगली में अत्यधिक दुर्लभ हैं, व्यक्तिगत अनुभव से बोलते हुए, लेकिन @mburszley का विश्लेषण अधिक मूर्त प्रमाण प्रदान करता है ।

  • यहां तक ​​कि रूबी केवल पहचानकर्ताओं के _end_ पर ? (और ! ) की अनुमति देता है, और वहाँ केवल _method_ पहचानकर्ता हैं, और मुझे संदेह है कि अधिकांश रूबी उपयोगकर्ताओं को पता है कि उन्हें अन्य भाषाओं का समर्थन नहीं करना चाहिए वही चीज़।

तो, व्यावहारिक रूप से बोल:

• मौजूदा कोड का अधिकांश हिस्सा प्रभावित नहीं होगा - एक टोकन जैसे $var?.foo बस का सामना नहीं करना पड़ेगा।

• यदि आप नए शब्दार्थों के साथ $var?.foo लिखते हैं, तो हाँ, पुराने संस्करणों पर चलने का परिणाम अलग-अलग व्यवहार में हो सकता है (स्पष्ट तरीके से टूटने के बजाय), इस बात पर निर्भर करता है कि क्या सख्त मोड प्रभाव में है - लेकिन _you हमेशा होना चाहिए वैसे भी अपने कोड को चलाने के लिए आवश्यक न्यूनतम संस्करण को लागू करें। वैसे भी ( #requires -Version , मॉड्यूल-प्रकट कुंजी)।

सभी में, मेरे लिए यह एक बाल्टी 3 परिवर्तन का एक स्पष्ट मामला है: एक तकनीकी रूप से तोड़ने वाला परिवर्तन जो वास्तविक लाभों की पेशकश करते समय बहुत कम मौजूदा कोड को तोड़ता है (या, अप्रत्याशित रूप से, अप्रत्याशित व्यवहार के कारण बारहमासी सिरदर्द से बचता है)।

@ mklement0 हम

अच्छा लगता है, @ स्टीवएल-एमएसएफटी - कृपया # 11379 देखें।

मैं यहां सभी को फिर से समर्थन (या, हांफना, गैर-समर्थन) दिखाने के लिए प्रोत्साहित करता हूं।