Powershell: शून्य-सशर्त सदस्य पहुंच के लिए चर नामों के आसपास {...} की आवश्यकता नहीं है

स्पष्ट करने के लिए, मील का पत्थर का मतलब यह है कि टीम को फीडबैक के आधार पर चर्चा करनी चाहिए, न कि हम यह बदलाव करने के लिए प्रतिबद्ध हैं।

@mklement0

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

उम्म्म - पावरशेल के लिए प्रारंभिक आधार भाषा पॉज़िक्स शैल थी जो $ का उपयोग करती है? निकास कोड qed '?' के लिए गैर-उद्धृत चर नामों में अनुमत है।

यह (सार्थक रूप से) पुराने संस्करणों पर नहीं चल सकता

ज़रूर यह कर सकता है:

PS>  $abc?=@{a=1; b=2; c=3}
PS>  $abc?.b                                                                                        1
PS>  2                      

ज़रूर यह कर सकता है:

यह अर्थपूर्ण ढंग से नहीं चल सकता _साथ में नए शब्दार्थ_ (अशक्त-सशर्त पहुंच) - बस इतना ही मैं कहना चाहता हूं।

हां, आपका उदाहरण वर्तमान में काम करता है, लेकिन _विभिन्न शब्दार्थों के साथ_ ( abc? _ जिसमें ? _ को चर नाम माना जाता है) - लेकिन बताए गए कारणों के लिए यह कोने का मामला बनाने के लिए छोड़ने लायक है ?. उम्मीद के

पॉवरशेल के लिए प्रारंभिक आधार भाषा पॉज़िक्स शेल थी जो निकास कोड के लिए $? का उपयोग करती है

$? POSIX जैसे गोले में एक _exception_ है; आप निम्न कार्य _not_ कर सकते हैं:

# bash, ksh, zsh, dash (all common /bin/sh implementations)
foo?='bar' # BOOM! E.g. "bash: foo?=bar: command not found"

(और, जाहिर है, कोई भी यह नहीं पूछ रहा है कि PowerShell में $? को समाप्त कर दिया जाए।)

और, निश्चित रूप से, यह उल्लेख किया जाना चाहिए, कि _all other_ एक ही स्थान में स्वचालित चर $? (यानी, $^ और $$ ) स्पष्ट रूप से विशेष हैं- टोकननाइज़र में केस किया गया। और, वास्तव में, ऐसा ही है $? , भले ही यह (वर्तमान में) होने की आवश्यकता नहीं है।

मुझे यह स्पष्ट प्रतीत होता है कि उस समय यह अपेक्षित था कि कोड लिखा गया था कि ? एक वैध पहचानकर्ता चरित्र नहीं होगा।

मैं केवल एक व्यक्ति के बारे में जानता हूं जिसने अपनी स्क्रिप्ट में चर नामों के अंत में ? का उपयोग किया है, और वह है @StartAutomating। चूंकि उसने वास्तव में उस वाक्य-विन्यास का उपयोग किया है, इसलिए मैंने उसका ध्यान इस चर्चा की ओर आकर्षित करना उचित समझा।

इसके अलावा @ vexx32 , $? विशेष आवरण होने का कारण यह है कि आप एक नाम के साथ एक चर नहीं बना सकते हैं जो ? शुरू होता है। उदाहरण के लिए $??? = 'foo' पार्स नहीं करेगा। परिवर्तनीय नाम अल्फ़ान्यूमेरिक वर्णों या अंडरस्कोर से शुरू होने चाहिए, और वर्तमान में इसमें अल्फ़ान्यूमेरिक वर्ण, अंडरस्कोर या प्रश्नवाचक चिह्न हो सकते हैं। मैं इस बात से सहमत हूं कि ?. को शून्य-सशर्त सदस्य एक्सेस ऑपरेटर के रूप में पार्स किया जाना चाहिए, लेकिन मैं स्पष्ट करना चाहता था कि टोकननाइज़र में ? विशेष-आवरण क्यों है।

इस चैट पर मेरा ध्यान आकर्षित करने के लिए धन्यवाद।

इसके लायक क्या है, मेरे पास कुछ विचार हैं:

1. हालांकि ये चर दुर्लभ हैं, कोई भी नहीं चाहता है कि जब बैक-कॉम्पैट उनकी स्क्रिप्ट को तोड़ दे तो व्हेक-ए-मोल खेलना चाहिए
2. गहराई से geeky लोगों को एक तरफ, मुझे उम्मीद है कि ${obj}?.Method() या $obj?.Method() थोड़ा ऊपर उठेगा। वेब पर एक दशक का मार्गदर्शन है कि कैसे वहां से नल का प्रबंधन किया जाए, और मुझे नहीं लगता कि बहुत से लोग if ($obj) {$obj.Method() } _just से v7 बैंडवागन_ प्राप्त करने के लिए स्विच कर रहे हैं।
3. इसके अतिरिक्त, अनपेक्षित चर नामों की समस्या वाले अधिकांश लोग ${} सिंटैक्स सीखते हैं (आप इसे पहले से ही अंडरस्कोर के साथ स्वाभाविक रूप से हिट करेंगे)। मुझे उम्मीद है कि "जो लोग इस सुविधा का उपयोग करना चाहते हैं" के वेन आरेख ओवरलैप "उन लोगों के लिए जो पहले से ही ${} सिंटैक्स जानते हैं" 100% के करीब होंगे
4. चूंकि कहा गया वाक्यविन्यास पूर्ण उप-अभिव्यक्ति के रूप में उतना शक्तिशाली नहीं है, और पूर्ण उप-अभिव्यक्तियाँ कोर और नहीं दोनों में काम करती हैं, मुझे उम्मीद है कि अधिकांश लोग आगे भी इसका उपयोग करना जारी रखेंगे।

तो, गणित चलाना, ऐसा करने के लिए _not_ के कई ठोस कारण हैं, और ऐसा करने का केवल एक अस्पष्ट कारण है (यह _might_ कुछ उपयोगकर्ताओं के लिए आसान हो सकता है)। के कम प्रसार को देखते हुए? परिवर्तनशील नामों में, आप नुकसान से अधिक लोगों की मदद कर सकते हैं, लेकिन मेरी राय में यह एक सिक्का-टॉस है।

लाभ की इस तरह की सिक्का-टॉस क्षमता को देखते हुए, मैं रॉबर्ट मैकनामारा को समझाऊंगा "अगर हम ऐसा करते हैं और अगर हम नहीं करते हैं, तो अगर हम नहीं करते हैं तो मैं रफ़ू हो जाऊंगा"।

मैं ऐसा करने का सुझाव देता हूं ताकि $obj?.Method() डिफ़ॉल्ट रूप से $<var i="6">obj</var> ?. <var i="9">Method</var>() रूप में काम करे, और केवल $<var i="11">obj?</var> . <var i="14">Method</var>() जब $obj दायरे में मौजूद नहीं है, लेकिन $obj? करता है और #requires ‑Version v7+ नहीं है।

@ एक्सई-बॉस, ऐसा लगता है कि इस विशेष नियम को बनाने के लिए बहुत सारे अपवाद हैं।

मैं इस विशेष नियम के मूल्य के बारे में अपने प्रश्न को दोहराता हूं।

इससे पहले, सवाल यह है कि "वेरिएबल सिंटैक्स के बारे में हम और क्या नहीं जानते हैं जिसे हम तोड़ सकते हैं?"

यदि सर्वसम्मति इसके लिए ${...} सिंटैक्स को बाध्य करने के लिए है, तो यहां वैकल्पिक सुविधाओं के समर्थन की सराहना की जाएगी, ताकि मेरे जैसे लोग जो इस सिंटैक्स का उपयोग करेंगे (मैं इसे _a लॉट_ का उपयोग करूंगा) शोर से बाहर निकल सकते हैं .

चूंकि हम यहां व्याख्या कर रहे हैं:
"तर्क स्पष्ट रूप से बताता है कि बहुतों की ज़रूरतें कुछ की ज़रूरतों पर भारी पड़ती हैं।" - स्पॉक

तो, गणित चलाना, ऐसा करने के लिए _not_ के कई ठोस कारण हैं, और ऐसा करने का केवल एक अस्पष्ट कारण है (यह _might_ कुछ उपयोगकर्ताओं के लिए आसान हो सकता है)।

@StartAutomating : कई कारण हैं, और वे ठोस हैं, अस्पष्ट नहीं हैं। साथ ही, इसका एक लक्ष्य कोड सरलता है। चर नामों को {} साथ लपेटना सीधे उस लक्ष्य के विरुद्ध काम करता है।

मैं इस पर @mklement0 और @KirkMunro के साथ हूं। व्यक्तिगत रूप से मुझे ${...}? सिंटैक्स अप्राकृतिक और अनावश्यक जटिल लगता है। हमारे पास पहले से ही ब्रेकिंग बदलाव हैं और इस मामले में स्पष्टता के बदले भुगतान करने के लिए यह छोटी कीमत है।

@StartAutomating

1. इसके अतिरिक्त, अनपेक्षित चर नामों की समस्या वाले अधिकांश लोग ${} सिंटैक्स सीखते हैं ( आप इसे पहले से ही अंडरस्कोर के साथ स्वाभाविक रूप से हिट करेंगे )। मुझे उम्मीद है कि "जो लोग इस सुविधा का उपयोग करना चाहते हैं" के वेन आरेख ओवरलैप "उन लोगों के लिए जो पहले से ही ${} सिंटैक्स जानते हैं" 100% के करीब होंगे

यह टिकता नहीं है। अंडरस्कोर चर नामों में मान्य वर्ण हैं।

@vexx32

मुझे यह स्पष्ट प्रतीत होता है कि उस समय कोड लिखे जाने की अपेक्षा की गई थी

नहीं।

चारों ओर वर्ण स्वैप करें? $foo.?Property गैर-संघर्ष दिखता है, क्योंकि प्रश्न चिह्नों से शुरू होने वाले संपत्ति के नामों को पहले से ही उद्धृत करने की आवश्यकता है:

PS C:\> $foo = [pscustomobject]@{'?'=1; '?name'=2}
PS C:\> $foo.?name
At line:1 char:6
+ $foo.?name
+      ~
Missing property name after reference operator.
    + CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
    + FullyQualifiedErrorId : MissingPropertyName
PS C:\> $foo.'?name'
2

@HumanEquivalentUnit , दुर्भाग्य से, यह लंबे समय से स्थापित ?. सिंटैक्स के साथ C# और कई अन्य भाषाओं में उपयोग किए जाने के साथ चिरस्थायी भ्रम को आमंत्रित करेगा (साथ ही, आपको अनुक्रमणिका के लिए एक वैकल्पिक रूप खोजने की आवश्यकता होगी ( ${arr}?[0] ) भी, और $arr[0]? जैसा कुछ टर्नरी ऑपरेटर के साथ भ्रम को आमंत्रित करेगा)

कोई साफ समाधान नहीं है।

1. अज्ञात संख्या में लोग उपयोग करते हैं? चर नामों के अंत में। हालांकि यह एक वैकल्पिक विशेषता है, कोई कह सकता है कि "यदि आप उन स्क्रिप्ट को चलाते हैं तो इसे चालू न करें" लेकिन इसे चालू करने वाले व्यक्ति को वर्तमान और भविष्य की स्क्रिप्ट की जांच करनी चाहिए जो उन्हें किसी भी स्रोत से मिलती है।
2. वैकल्पिक वाक्यविन्यास एक अच्छा विकल्प नहीं है क्योंकि यह सी # से कुछ-बहुत-शक्तियों का आयात नहीं कर रहा है
3. #requires के आधार पर व्यवहार बदलना किसी सहेजी गई स्क्रिप्ट के बाहर काम नहीं करता है, और जैसे ही कोई टैग सेट किए बिना किसी लंबी स्क्रिप्ट से कुछ कोड कॉपी करता है, वह विफल हो जाएगा।
   4. (dir *.ps2)?.count और (dir *.ps1)?.count यह दिखाते हैं कि यह ऑपरेंड को एक चर होने की आवश्यकता नहीं है।
   ($Host)?.toString() / ($null)?.toString() नाम के चारों ओर ब्रेसिज़ लगाने की आवश्यकता को हटा देता है। यह अभी भी अतिरिक्त कीस्ट्रोक्स है, लेकिन यह अधिक तार्किक और कम बदसूरत है।

1. #requires के आधार पर व्यवहार बदलना किसी सहेजी गई स्क्रिप्ट के बाहर काम नहीं करता है, और जैसे ही कोई टैग सेट किए बिना किसी लंबी स्क्रिप्ट से कुछ कोड कॉपी करता है, वह विफल हो जाएगा।

यह _any_ कोड पर लागू होता है जो उन सुविधाओं का उपयोग करता है जो पुराने संस्करणों में समर्थित नहीं हैं।
यदि यह प्रमुख चिंता थी, तो कोई भी नई भाषा सुविधा या नया cmdlet/cmdlet पैरामीटर कभी भी पेश नहीं किया जाएगा।

(उम्मीद है, पुराने कोड में आपके पास कम से कम Set-StrictMode -Version 1 प्रभाव में है, उस स्थिति में $var?.foo जोर से विफल हो जाएगा, क्योंकि var? नाम का कोई वैरिएबल मौजूद नहीं है)।

1. नाम के चारों ओर ब्रेसिज़ लगाने की आवश्यकता को हटा देता है।

(...) को {...} लिए प्रतिस्थापित करना केवल एक मामूली सुधार है।

जो भी अतिरिक्त सिंटैक्स का उपयोग किया जाता है, यहां समस्या अतिरिक्त सिंटैक्स के लिए _need_ है - किसी ऐसी चीज़ के लिए जो केवल _as-is_ काम करे - न केवल टाइपिंग की सुविधा के लिए बल्कि _sensible अपेक्षाओं को पूरा करने के लिए भी।

1. #requires के आधार पर व्यवहार बदलना किसी सहेजी गई स्क्रिप्ट के बाहर काम नहीं करता है, और जैसे ही कोई टैग सेट किए बिना किसी लंबी स्क्रिप्ट से कुछ कोड कॉपी करता है, वह विफल हो जाएगा।

यह _any_ कोड पर लागू होता है जो उन सुविधाओं का उपयोग करता है जो पुराने संस्करणों में समर्थित नहीं हैं।
यदि यह प्रमुख चिंता थी, तो कोई भी नई भाषा सुविधा या नया cmdlet/cmdlet पैरामीटर कभी भी पेश नहीं किया जाएगा।

मेरा मतलब यह बिल्कुल नहीं था। इसके अलावा सुझाव था कि यदि #requires निर्दिष्ट pwsh 7 है तो प्रसंस्करण भिन्न हो सकता है। एक नया व्यवहार तभी प्रकाशमान होता है जब आप #आवश्यकताएं डालते हैंअच्छा नहीं है।

(उम्मीद है, पुराने कोड में आपके पास कम से कम Set-StrictMode -Version 1 प्रभाव में है, उस स्थिति में $var?.foo जोर से विफल हो जाएगा, क्योंकि var? नाम का कोई वैरिएबल मौजूद नहीं है)।

मेरे अनुभव में सेट-स्ट्रिक्टमोड का ज्यादा उपयोग नहीं होता है। क्योंकि (ए) एक धारणा है कि इसके बिना डिफ़ॉल्ट "सही" है और (बी) उन चीजों का उपयोग करने की आवृत्ति जो इसके बंद होने पर निर्भर हैं, बहुत अधिक है। यह इन ऑपरेटरों के लिए एक आम उपयोग है। किसी भी मामले में समस्या पुराना कोड है जहां $var? मौजूद है और इसमें foo संपत्ति है, लेकिन अब कोड $var की तलाश में है ... संभवत: नई प्रसंस्करण एक त्रुटि का कारण बन सकती है यदि सख्त मोड सेट है क्योंकि $var मौजूद नहीं है ....

1. नाम के चारों ओर ब्रेसिज़ लगाने की आवश्यकता को हटा देता है।

(...) को {...} लिए प्रतिस्थापित करना केवल एक मामूली सुधार है।

हां। ($x) ${x} से थोड़ा बेहतर है लेकिन थोड़ा ही। ( Get-user "Bob")?.disable() से बेहतर है

$u = get-user "bob" 
($u)?.disable

जो भी अतिरिक्त सिंटैक्स का उपयोग किया जाता है, यहां समस्या अतिरिक्त सिंटैक्स के लिए _need_ है - किसी ऐसी चीज़ के लिए जो केवल _as-is_ काम करे - न केवल टाइपिंग की सुविधा के लिए बल्कि _sensible अपेक्षाओं को पूरा करने के लिए भी।

हां।
$var. foo व्हाइट-स्पेस कार्यों के साथ। ${foo} ?.bar() नहीं? किसी फ़ंक्शन या उपनाम नाम में अनुमति है (?. दोनों के लिए कानूनी है)। चीजों को तोड़े बिना मौजूदा सिंटैक्स नियमों में सी # सिंटैक्स के लैशिंग बिट्स हमेशा व्यावहारिक नहीं होते हैं कभी-कभी, "यह सी # में उपलब्ध है ..." वास्तव में "हां। आप जानते हैं कि सी # कहां है यदि आप इसे चाहते हैं"।
:-)

SemVer संगतता बनाए रखने के लिए, इसे एक प्रमुख रिलीज़ (अधिमानतः 7.0.0 ) में किया जाना चाहिए।

ऊपर मेरा सुझाव भी देखें ( https://github.com/PowerShell/PowerShell/issues/11379#issuecomment-566756120 )।

@ एक्सई-बॉस हां, यह आपकी टिप्पणी थी जिसका मैं जिक्र कर रहा था जब मैंने कहा था कि #requires के आधार पर यह अच्छा विचार नहीं हो सकता है।
और हाँ, यदि किसी को किसी मौजूदा स्क्रिप्ट को तोड़ना है तो वह समय है जब प्रमुख संस्करण बदलता है, इसलिए इसे जल्दी से करने की आवश्यकता है या V8 की प्रतीक्षा करें

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

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

मैंने अक्सर पावरशेल के सिंटैक्स से संबंधित कई निर्णय ऐसे लोगों के लिए अनजाने में पाए हैं जो प्राथमिक रूप से पावरशेल डेवलपर नहीं हैं। पिछली बार जब मैंने कुछ गंभीर के लिए पावरशेल का उपयोग किया था, तो मैं एक नल कोलेसिंग ऑपरेटर की कमी, या यहां तक ​​​​कि एक टर्नरी ऑपरेटर की कमी से चिंतित था, जिसके परिणामस्वरूप मैं स्टैक ओवरफ़्लो पर इस लोकप्रिय पावरशेल उत्तर को पोस्ट कर रहा

@StartAutomating ने कहा:

गहराई से geeky लोगों को एक तरफ, मुझे उम्मीद है कि ${obj}?.Method() या $obj?.Method() थोड़ा ऊपर उठेगा। वेब पर एक दशक का मार्गदर्शन है कि कैसे नल का प्रबंधन किया जाए, और मुझे नहीं लगता कि बहुत से लोग अगर ($obj) {$obj.Method() } से सिर्फ v7 बैंडवागन पर जाने के लिए स्विच कर रहे हैं

मैं सिर्फ n = 1 हूं, लेकिन एक गैर-पॉवरशेल डेवलपर के रूप में, मैं दृढ़ता से असहमत हूं। नई ? सिंटैक्स कुछ ऐसा है जिसके बारे में मुझे बहुत जल्दी पता चल जाएगा, यहां तक ​​​​कि कोई है जो शायद हर कुछ महीनों में एक बार पावरशेल को छूता है, और यह निश्चित रूप से विकल्पों के स्थान पर भविष्य में पावरशेल का उपयोग करके मेरे लिए बाधाओं को बढ़ाएगा। अगर मैं देखता हूं कि पीछे की संगतता के लिए कुछ पागल {} वाक्यविन्यास आवश्यक है, तो मैं अपनी आंखों को रोल करने जा रहा हूं और जो कुछ भी मैं पहले से उपयोग कर रहा था उस पर वापस जा रहा हूं।

मैं यहाँ पश्चगामी संगतता पर जोर नहीं समझता। पावरशेल कोर ने पहले से ही मेरी अधिकांश मौजूदा लिपियों को तोड़ दिया है क्योंकि उन्होंने .NET के उन हिस्सों का उपयोग किया है जो .NET कोर में नहीं हैं। (मैं इसके बारे में शिकायत नहीं कर रहा हूं---नेट कोर बहुत अच्छा है, लेकिन अगर आप पश्चगामी संगतता को तोड़ने जा रहे हैं, तो अब आपका मौका है।)

सबसे पहले, मेरा मानना ​​​​है कि मेरी प्रारंभिक प्रतिक्रिया ने गलतफहमी का एक भ्रम पैदा कर दिया है।

मेरा अनुमान था कि ${} पावरशेल डेवलपर्स_ के लिए अजीब नहीं होगा, क्योंकि उन्हें पहले से ही इस सिंटैक्स फॉर्म को जानना होगा यदि उन्होंने कभी एक चर के साथ एक चर एम्बेड किया था? या और एक स्ट्रिंग में अंडरस्कोर।

कई अनुस्मारकों के लिए धन्यवाद कि यह सिंटैक्स गैर-पॉवरशेल डेवलपर्स के लिए अजीब हो सकता है।

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

मेरी प्रतिक्रिया का तीसरा बिट अनुपात से बाहर उड़ा दिया गया लगता है। उन लोगों में से एक के रूप में बोलते हुए, जिन्होंने कभी-कभी $IsThisRight नाम के चर का उपयोग किया है? = टेस्ट-समथिंग, इस परिवर्तनशील प्रतिबंध के बारे में संभावित समाचार सुनने के लिए मेरी पहली प्रतिक्रिया थी "ओह ठीक है, मुझे लगता है कि मुझे कुछ चर का नाम बदलना होगा, वैसे भी मुझे इसके लिए उतना नहीं मिल रहा था।"

तो, थ्रेड को पुन: स्थापित करने और समाप्त करने का प्रयास करने के लिए:

1. आईएमएचओ, ${} शायद _मौजूदा_ पावरशेल डेवलपर्स के लिए सिंटैक्स के लिए अजीब नहीं होगा
2. यह सुविधा बढ़िया है यह सोचने के लिए आपका स्वागत है; मेरे लिए यह एक भाषा परिचित गेटवे दवा है, और मैं अत्यधिक अनुशंसा करता हूं कि इस धागे को पढ़ने वाले प्रत्येक व्यक्ति को यह सीखना चाहिए कि आईएफएस/फोरैच/व्हाइल्स इत्यादि को कैसे रॉक करना है।
3. प्रभावित लेखकों में से एक के रूप में, मुझे कुछ इतना महत्वपूर्ण मिशन नहीं मिल रहा है? मेरे चर के अंत में कि मैं अपना कोड बदलने का विरोध करूंगा।

या, पूरी तरह से संक्षिप्त होने के लिए:

आप चाहें तो यह बदलाव करें। इस दौड़ में मेरे पास छोटा घोड़ा है। यदि आप ऐसा करने का निर्णय लेते हैं, तो कृपया परिवर्तन को स्पष्ट रूप से प्रसारित करें ताकि कोई अन्य व्यक्ति जिसने चरों का नाम ? अनुसार अपडेट कर सकते हैं।

मेरी प्रतिक्रिया का दूसरा भाग मिश्रण में खो गया हो सकता है: क्योंकि नल-कोलेसिंग के अन्य विकल्प पावरशेल में अधिक समय से मौजूद हैं और व्यापक रूप से उपयोग किए जाते हैं, मुझे नहीं पता कि मौजूदा पावरशेल उपयोगकर्ताओं के साथ यह सुविधा कितनी बढ़ जाएगी।

मैं निश्चित रूप से इससे सहमत हूं, और मैं आपकी राय को खारिज नहीं करना चाहता। इस तरह के ब्रेकिंग परिवर्तन करना हमेशा कठिन होता है, खासकर जब विकल्प उन लोगों के लिए सहज हो सकता है जो पहले से ही भाषा के भारी उपयोगकर्ता हैं।

आप अंदर आना चाहते हैं और कहना चाहते हैं "यह एक चीज है जिसे मुझे पावरशेल का उपयोग शुरू करने की आवश्यकता है", और मैं आपकी राय के साथ बहस नहीं कर सकता (हालांकि मैं कह सकता हूं कि आप भाषा के पेड़ की तलाश में शांत सुविधाओं का जंगल खो रहे हैं परिचित)।

खैर, मुझे लगा कि अधिकांश गैर-पॉवरशेल डेवलपर्स वास्तव में इन वार्तालापों में भाग नहीं ले रहे हैं--यह शुद्ध संयोग है कि मैं इस पर ठोकर खा गया। पॉवरशेल का मेरा उपयोग संभवतः उन लोगों से बहुत अलग होगा जो पुस्तकालय और ओपन सोर्स टूल लिख रहे हैं। मुझे लगा कि मैं किसी ऐसे व्यक्ति का परिप्रेक्ष्य दूंगा जो पावरशेल का उपयोग फैंसी ढांचे के रूप में कम कर रहा है और जितनी जल्दी हो सके अजीब कार्यों को करने के लिए और अधिक। यह किसी अन्य राय को खारिज करने के लिए नहीं है - यह एक दृष्टिकोण से सिर्फ एक और राय है जो शायद यहां अक्सर नहीं देखी जाती है।

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

मेरी प्रतिक्रिया का तीसरा बिट अनुपात से बाहर उड़ा दिया गया लगता है। उन लोगों में से एक के रूप में बोलते हुए, जिन्होंने कभी-कभी $IsThisRight नाम के चर का उपयोग किया है? = टेस्ट-समथिंग, इस परिवर्तनशील प्रतिबंध के बारे में संभावित समाचार सुनने के लिए मेरी पहली प्रतिक्रिया थी "ओह ठीक है, मुझे लगता है कि मुझे कुछ चर का नाम बदलना होगा, वैसे भी मुझे इसके लिए उतना नहीं मिल रहा था।"

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

ऐसे परिदृश्य में जिसमें आप एक पूरी तरह से नए जनसांख्यिकीय-अर्थात गैर-विंडोज-केंद्रित डेवलपर्स को लक्षित करने का प्रयास कर रहे हैं-- जो पहले से मौजूद है, उसके साथ प्रतिस्पर्धा करने के लिए कुछ ब्रेकिंग परिवर्तन करना आवश्यक हो सकता है।

यदि आप ऐसा करने का निर्णय लेते हैं, तो कृपया परिवर्तन को स्पष्ट रूप से प्रसारित करें ताकि कोई अन्य व्यक्ति जिसने चरों का नाम ? अनुसार अपडेट कर सकते हैं।

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

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

तो आप सही भाषा में आए हैं! पावरशेल वाक्यात्मक चीनी के साथ सकारात्मक रूप से पवित्र है।

जो लोग नहीं जानते उन्हें शिक्षित करने के लिए, आप PowerShell में कई तरीकों से "नल कोलेस" कर सकते हैं:
~$ListWhereNotNull = $null, 1, 2, $null, 3 -ne $null # यह जांच करेगा कि प्रत्येक आइटम शून्य नहीं है, और 1,2,3 की सूची लौटाएं$FirstNonNull = @($null, 1, $null,2 -ne $null)[0] # यह पहला नॉन-नल लौटाएगा$lastNonNull = @($null, 1, 2, $null -ne $null)[-1] # यह ऋणात्मक अनुक्रमणिका का उपयोग करके अंतिम गैर-शून्य लौटाएगा$TheObjectPipelineWay = $null, 1, $null, 2 | चयन-वस्तु -प्रथम 1$TheAssigningForeachWay = foreach ($null में $आइटम, 1, 2, $null, 3, 4) {अगर ($आइटम-ने $null) {$आइटम;



अभी के लिए इतना ही काफी है, लेकिन इसे भाषा के वाक्य-विन्यास पर बात साबित करनी चाहिए जिसमें बहुत लचीलापन है। वे सभी डेमो पॉवरशेल 1.0 पर वापस काम करेंगे

हालांकि, इस विशेष मामले में, ऐसा लगता है कि कोर में संक्रमण के कारण बहुत सी पावरशेल स्क्रिप्ट टूटने के कगार पर हैं।

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

मैं अभी भी सिंटैक्स परिवर्तन के साथ किसी भी तरह से ठीक हूं: मैंने अभी महसूस किया कि नवीनतम उत्तर में दो दावों को संबोधित करने और बाहर बुलाए जाने की आवश्यकता है।

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

@StartAutomating : क्या आप कह रहे हैं कि मैं शूट नहीं कर सकता? क्योंकि मुझे लगता है कि अधिक चीनी के लिए अभी भी जगह है

जो लोग नहीं जानते उन्हें शिक्षित करने के लिए, आप PowerShell में कई तरीकों से "नल कोलेस" कर सकते हैं:

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

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

मैं इस संबंध में केवल अनुभव के आधार पर बोल रहा हूं, बजाय इसके कि वास्तव में उचित आंकड़े देखें और एकत्र करें। उदाहरण के लिए, प्री-कोर, मैं [System.Web.Security.Membership]::GeneratePassword(32, 6) साथ पासवर्ड जेनरेट कर सकता था, लेकिन कोर में System.Web उपलब्ध नहीं है। (मुझे पता है कि मैं शायद पुराने सिस्टम को लोड कर सकता हूं। एक देवकिट के लिए डॉकर रहस्यों का एक गुच्छा उत्पन्न करना एक त्वरित स्क्रिप्ट का उपयोग करने के लिए एक महान जगह की तरह लगता है, लेकिन यह आश्चर्यजनक रूप से बैश की तुलना में पावरशेल कोर में अधिक क्रिया है। बेशक, बैश के समाधान अक्सर बहुत बदसूरत लगते हैं।

पुन: सिंथेटिक चीनी, मेरा व्यंग्यात्मक दिमाग फिल्म "स्नैच" को उद्धृत करता है: "मैं पहले से ही काफी मीठा हूं"

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

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

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

@StartAutomating : क्या आप कह रहे हैं कि मैं शूट नहीं कर सकता? क्योंकि मुझे लगता है कि अधिक चीनी के लिए अभी भी जगह है

मैं हमेशा मुझे कुछ नई वाक्य रचना चीनी प्यार करता हूँ! मैं प्रोग्रामिंग भाषाओं का चयन करता हूं जैसे कि हैलोवीन पर एक बच्चा चाल-या-उपचार कर रहा है।

@Zenexer : मुझे वास्तव में Powershell पसंद है, मैं करता हूं। मैं काफी भाग्यशाली हूं कि पीएस को बड़े पैमाने पर और दैनिक रूप से काम पर कर रहा हूं। मुझे लचीलापन पसंद है, विशेष रूप से .NET के साथ सहजीवन, ओह यार! इसलिए मुझे इसकी दिशा की परवाह है और इसलिए ${...}? सिंटैक्स मुझे स्वीकार करना इतना कठिन है।

अच्छे अंक, लेकिन मैं कुछ बातें स्पष्ट कर दूं।

बेहतर या बदतर के लिए, पावरशेल ने आज तक सिमेंटिक वर्जनिंग का उपयोग नहीं किया है।
एक नया प्रमुख संस्करण केवल _new_ सुविधाएँ लेकर आया, जिसमें पिछड़ी संगतता के लिए एक आयरनक्लैड प्रतिबद्धता थी।
क्रॉस-प्लेटफ़ॉर्म जाने के कारण आवश्यकता के हिस्से में, कोर में ब्रेकिंग परिवर्तन रेंगने लगे।
प्रमुख संस्करण v7.0 को पश्चगामी-संगतता में _increase_ संकेत देने के लिए चुना गया था: Windows PowerShell के लिए व्यवहार्य प्रतिस्थापन प्रदान करने का प्रयास।

जबकि कई ऐतिहासिक समस्याओं को मौजूदा कोड को गंभीरता से तोड़े बिना ठीक नहीं किया जा सकता है और इसलिए इसे केवल वैकल्पिक (ऑप्ट-इन) सुविधाओं के रूप में पेश किया जा सकता है,
बकेट 3 ब्रेकिंग परिवर्तन हमेशा एक विकल्प होना चाहिए: एक सुधार / सुधार करें जिसमें मौजूदा कोड को तोड़ने की _potential_ हो, लेकिन व्यवहार में इसकी संभावना नहीं है; संतुलन पर, यह भाषा को बेहतर बनाने के लायक है।

जैसा कि ओपी में तर्क दिया गया था, हाथ में मामला मुझे एक बाल्टी 3 परिवर्तन के रूप में प्रभावित करता है; जबकि हम जानते हैं कि _some_ स्क्रिप्ट टूट जाएगी ( @StartAutomating को पता

यह दुर्लभ क्यों है?

क्योंकि चर नामों में ? का उपयोग करना अधिकांश लोगों के लिए पूरी तरह से नहीं होता है, और यदि ऐसा होता है, तो उन्हें _बिना {...} _ के काम करने की उम्मीद नहीं करनी चाहिए: यदि निम्नलिखित में से सभी केवल साथ काम करते हैं {...} , क्यों इसके लिए अलग होने की उम्मीद होती है ? : . , ; ( : , सब पर नहीं किया जा सकता है क्योंकि यह हमेशा की तरह व्याख्या की है एक ड्राइव विभाजक)

$var? या $va?r जैसे नामों को बिना {...} आवश्यकता के अनुमति देना एक अनुमति थी जिसने परेशानी के लिए कहा, और मुसीबत आ गई है: यह विकास के रास्ते में आता है भाषा, जैसा कि इस मामले में है।

सी # से प्रेरित 3 नई संबंधित विशेषताएं हैं (कम से कम वाक्य रचनात्मक रूप से संबंधित):

• टर्नरी कंडीशनल - 7.0 . में एक वास्तविक विशेषता होगी
  
  
  
  • (Get-Date).Second % 2 ? 'odd' : 'even'
  
  
• नल-कोलेसिंग ऑपरेटर - 7.0 . में एक वास्तविक विशेषता होगी
  
  
  
  • $var ?? 'default' और $var ??= 'default'
  
  
• नल-सशर्त ऑपरेटर - हाथ में समस्या - 7.0 . में एक _प्रयोगात्मक_ सुविधा होगी
  
  
  
  • $possiblyNull?.ToString()
  
  

उनमें से सभी के पास उनके सिंटैक्स के हिस्से के रूप में ? , और वे सभी विरासत के बोझ से प्रभावित हैं $var? पार्सिंग, हालांकि ?. सबसे स्पष्ट रूप से ऐसा है:

• जबकि आप तर्क दे सकते हैं कि $var?1:0 जैसे कुछ गोल्फरों को कोड करने के लिए रुचि रखते हैं, यह ठीक काम करेगा यदि ? में वाक्य रचनात्मक कार्य था - वर्तमान में आपको ? से पहले _space_ का उपयोग करना होगा

• इसके विपरीत, यह मुझे किसी के लिए $var??='bar' (शायद इससे कम $baz = $foo??$bar ) का प्रयास करने के लिए उचित लगता है, जिसके लिए वर्तमान में एक स्थान की भी आवश्यकता होती है।

यही है, अगर हम $var? की वर्तमान पार्सिंग के साथ चिपके रहते हैं, तो हम _three_ नई सुविधाओं को भारित कर रहे हैं (यद्यपि अलग-अलग डिग्री के लिए), जिनमें से 2 पहले से ही आम तौर पर उपलब्ध हैं (प्रयोगात्मक नहीं)।

{...} आवश्यकता वाली समस्या _not_ है, केवल टाइपिंग की असुविधा है: यह उतना ही है जितना कि _इसकी आवश्यकता की अपेक्षा नहीं करना_ पहली जगह में, और बाद में _इसकी आवश्यकता को भूल जाना_ (संभावित सूक्ष्म खराबी के साथ) - क्योंकि यह इतना प्रति-सहज ज्ञान युक्त।

@ एक्सई-बॉस, मैं @joneill से सहमत हूं कि संस्करण-सशर्त व्यवहार को लागू करना समस्याग्रस्त होगा। मुझे नहीं लगता कि इस मामले में पिछड़े-संगतता विशेष-आवरण वाले इंजन को भारित करने की आवश्यकता है।

@ mklement0: यह अप्राकृतिक / जवाबी सहज ज्ञान युक्त / आप-नाम-यह है। ब्रैकेट कठिन हैं, घुंघराले ब्रैकेट और भी कठिन हैं। इस मामले में उनकी कोई जरूरत नहीं है।

@ mklement0 चूंकि समझौता टूट रहा है ... मुझे लगता है कि यह एक अच्छा सारांश है।

पावरशेल में सी # संरचनाओं को जोड़कर मुझे अभी तक पूरी तरह से जीतना बाकी है। हमारे पास पहले से ही कई जगहों पर समस्या है कि कीबोर्ड पर पर्याप्त प्रतीक नहीं हैं। क्या ">" "इससे बड़ा" या "रीडायरेक्ट" है? है "=" असाइनमेंट या टेस्ट-समानता (विभिन्न भाषाओं का उपयोग: = असाइन करने के लिए या == समानता के लिए)। भाषाओं के बीच कूदने वाले लोग -eq या -gt का उपयोग करना भूल जाएंगे और हम इसके साथ फंस गए हैं... + अंकगणितीय जोड़, या स्ट्रिंग/सरणी संयोजन है। * गुणा और वाइल्ड कार्ड दोनों है। % मोडुलो है और forEach-object. लिए एक उपनाम है

गरीब ? Where-Object. लिए उपनाम है और एक स्वचालित चर का नाम है। लेकिन Get-Alias ? या Get-Variable ? ... और फिर यह वाइल्डकार्ड का काम करता है।

Get-PSdrive और आप देखते हैं कि "वेरिएबल" आदि में नाम के अंत में ":" नहीं है, एक नाम जोड़ने पर इसे एक ड्राइव के रूप में माना जाता है। जब तक निश्चित रूप से आपने "$drive="C" लिखा है और इसे "$drive:temp" साथ पालन करें, पावरशेल के लिए कोई भी नया (और कुछ पुराने हाथ, जब वे इसके बारे में नहीं सोच रहे हैं) यह जानकर चकित होंगे कि वे ' ve ने अभी एक नामित स्कोप "ड्राइव" का आविष्कार किया है।

तो इसके विपरीत ... कोई कह सकता है कि '":" और "?" के लिए और उपयोग के साथ एक नया सिंटैक्स बनाएं। क्या तुम पागल हो?'
IIRC, ट्विटर पर @BrucePay ने टर्नरी ऑपरेटर को "नॉट

अधिकतर लोग $PSEdition.length -gt 2 लिखेंगे
लेकिन $PSEdition. length-gt2 भी काम करता है (आप दो हिस्सों के बीच एक लाइन ब्रेक भी ले सकते हैं।) "।" "वर्तमान निर्देशिका", "इस दायरे में चलाएं" और "सदस्य" के रूप में भी अतिभारित है, हालांकि पीएस वी 1-वी 5 में मैं किसी भी ऑपरेटर के बारे में नहीं सोच सकता जिसके लिए अग्रणी स्थान की
$host.debuggerEnabled?0:1 ठीक है क्योंकि "?" एक संपत्ति के हिस्से के लिए _not_ ग्रहण किया गया
$IsCoreCLR?0:1 नहीं है क्योंकि "?" चर नाम का हिस्सा माना जाता है।

नल कोलेसिंग ऑपरेटरों के लिए भी यही सच है
$null?? "default" को जगह चाहिए $true.length?? "default" नहीं।

मूल उपयोग के मामले को मुद्दे के शीर्ष पर एक पल के लिए एक तरफ रख दें। उपरोक्त मामले बताते हैं कि कुछ ठीक से काम नहीं कर रहा है। यह तय किया जाएगा यदि परिवर्तनीय नाम "?" "।" वाले नामों की तरह लटके होने की आवश्यकता है। या "+" या ":" , और @StartAutomating जो "?" का मुख्य उपयोगकर्ता है नामों में सोचता है कि यह एक _ब्रेक है जिसे संभाला जा सकता है_। इससे पहले कि हम शून्य-सदस्यों तक पहुंचें, ऐसा लगता है कि 'इसे पहले से ही करने का एक तरीका खोजें'

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

आवश्यकता {...} के साथ समस्या केवल टाइपिंग की असुविधा नहीं है: यह पहले स्थान पर इसकी आवश्यकता की अपेक्षा न करने और बाद में इसकी आवश्यकता को भूल जाने के बारे में है (संभावित रूप से सूक्ष्म खराबी के साथ) - क्योंकि यह इतना प्रति-सहज।

यह एक अच्छी बात है और यह काफी हद तक मुझे व्यवहार में ${...?} बारे में परेशान करेगा। यहां तक ​​​​कि अगर मैं {} का उपयोग करना जानता हूं, तो एक मजबूत मौका है कि मैं अंततः भूल जाऊंगा, और इसके परिणामस्वरूप सूक्ष्म बग हो सकते हैं जो पहले स्पष्ट नहीं हैं, क्योंकि यह शायद अभी भी वाक्य रचनात्मक रूप से मान्य होगा। $var??='bar' इसका एक अच्छा उदाहरण है, हालांकि मैं आमतौर पर रिक्ति के बारे में बहुत सावधान हूं।

धन्यवाद, @joneill , यह एक अच्छा उदाहरण है कि कितने प्रतीक
अधिकांश भाग के लिए, एक बार जब आप सभी उपयोगों से अवगत हो जाते हैं, तो यह कोई समस्या नहीं है, निम्नलिखित कारणों से:

• विभिन्न संदर्भ (उदाहरण के लिए, * एक ऑपरेटर के रूप में बनाम * वाइल्डकार्ड चार के रूप में।)
  
  
  
  • ? लिए अलग-अलग संदर्भों में वास्तव में कुछ समान है, अमूर्तता के एक निश्चित स्तर पर: आप ? में Get-ChildItem | ? Target , $var?.Target , $? कल्पना कर सकते हैं। $var ?? 'none' क्योंकि सभी में एक प्रकार का _question_ शामिल है और इसलिए _test_ या _सशर्त व्यवहार_।
  
  
• समझदार बहुरूपी व्यवहार (उदाहरण के लिए, + स्ट्रिंग के साथ संयोजन का प्रदर्शन)।

एक समस्यात्मक उदाहरण & (कॉल ऑपरेटर बनाम बैकग्राउंड ऑपरेटर) है, जिसका उपयोग एक ही संदर्भ में विभिन्न शब्दार्थों के साथ किया जाता है, जो केवल इसके _position_ पर निर्भर करता है।

यह तय किया जाएगा यदि परिवर्तनीय नाम "?" "।" वाले नामों की तरह लटके होने की आवश्यकता है। या "+" या ":"

वास्तव में, और यह दोहराना होगा: चर नामों में ? का उपयोग करने की क्षमता दूर नहीं जाएगी - लेकिन आपको आगे जाकर ${var?} = @{ foo=1 }; ${var?}?.foo

जैसा कि आप प्रदर्शित करते हैं, किसी के दृष्टिकोण से समझदारी से _not_ ? वैध चार होने की अपेक्षा करता है। . डॉट-सोर्सिंग के लिए उचित अपवाद है; ? Where-Object उपनाम के बाद एक स्थान की आवश्यकता आश्चर्यजनक हो सकती है (उदाहरण के लिए, gci|?target काम नहीं करता है), लेकिन कमांड नाम _do_ को व्हाइटस्पेस के साथ उनके तर्कों से अलग करने की आवश्यकता है)।

. और एक सदस्य के नाम ( $obj. foo ) के बीच व्हॉट्सएप रखने में सक्षम होना मुख्य रूप से बहु-पंक्ति कथनों में समझ में आता है, हालांकि यकीनन अधिक पठनीय रूप - अन्य भाषाओं से परिचित - (भी) है व्हाइटस्पेस को _before_ . अनुमति दें:

# This does NOT work - the . must be *immediately after* the expression / member
(Get-Date)
  .ToUniversalTime()  
  .TimeOfDay

ऐसा करने में सक्षम होने से | को _next_ लाइन पर रखने की हाल ही में जोड़ी गई क्षमता को प्रतिबिंबित किया जाएगा:

 # Already works in PS Core
Get-Date
  | % ToUniversalTime
  | % TimeOfDay

हालांकि, यह . साथ डॉट-सोर्सिंग ऑपरेटर और . शुरू होने वाले कमांड नामों के साथ अनसुलझे अस्पष्टताओं को पेश करेगा - हालांकि संभावना नहीं है। (उदाहरण के लिए, . foo एक नई लाइन पर एक संपत्ति का उपयोग या एक कमांड हो सकता है जो foo नामक फ़ंक्शन या स्क्रिप्ट को डॉट-सोर्स करता है (जो $env:PATH ) ; .foo एक _command_ का नाम हो सकता है)।

@KirkMunro की मल्टी लाइन निरंतरता RFC, जबकि _commands_ को कई लाइनों में विस्तार करने की अनुमति देने पर ध्यान केंद्रित करते हुए, हमें अगला सबसे अच्छा समाधान देगा - देखें https://github.com/PowerShell/PowerShell-RFC/pull/179#issuecomment -498734875।

प्रायोगिक सुविधा डिफ़ॉल्ट रूप से चालू होने के लिए के रूप में: - लेकिन नहीं जारी उम्मीदवारों - सौभाग्य से, _preview_ रिलीज अब डिफ़ॉल्ट रूप से चालू _all_ प्रायोगिक सुविधाओं के लिए बारी; हालांकि, ध्यान दें कि यदि आपने कभी भी Enable-ExperimentalFeature या तो _बिना _ -Scope या -Scope CurrentUser साथ जो भी सुविधाएं सक्षम की हैं, तो इसे लगातार ओवरराइड किया जाता है।

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

मैं सहमत हूं कि ? को एक सामान्य चर नाम चरित्र के रूप में अनुमति देना जारी रखना उपयोगकर्ताओं के लिए सबसे अधिक भ्रमित करने वाला है, क्योंकि चरित्र का उपयोग अचानक चीजों को सफेद स्थान को संवेदनशील बनाता है, और ऐतिहासिक रूप से कम से कम, मुझे नहीं लगता कि चर नामों में _ever_ है अतीत में व्हाइटस्पेस-संवेदनशील रहा है।

उस अस्पष्टता का परिचय देना, मुझे लगता है, एक ब्रेकिंग परिवर्तन करने और एक चर नाम में उपयोग से ? को अस्वीकार करने की तुलना में अधिक समस्या है। ब्रेकिंग चेंज के साथ, हम लेखकों को सचेत करने के लिए आसानी से PSSA नियम बना सकते हैं कि सिंटैक्स की अब अनुमति नहीं है। हालांकि, रिवर्स इतनी आसानी से सच नहीं है, और ब्रेकिंग चेंज के विपरीत यह जरूरी नहीं कि गलती से निकल जाए; यह बहुत आसानी से उपयोगकर्ताओं के साथ गलती से गलत चर को चुपचाप संदर्भित कर सकता है, बिना यह जाने कि वे क्या कर रहे हैं।

@ पावरशेल/पॉवरशेल-समिति ने इस पर चर्चा की, हमने स्क्रिप्ट के पावरशेल कॉर्पस का विश्लेषण किया था और प्रश्न चिह्न के साथ समाप्त होने वाले चर नामों का काफी उपयोग किया गया था। जैसे, हम उन लोगों को तोड़ नहीं सकते हैं और पावरशेल चर नामों के आसपास ब्रेसिज़ एक मौजूदा भाषा विशेषता है जो चर नाम को अन्य वर्णों (जैसे एक स्ट्रिंग के भीतर) से अलग करती है।

हमने स्क्रिप्ट के पावरशेल कॉर्पस का विश्लेषण किया था और प्रश्न चिह्न के साथ समाप्त होने वाले चर नामों का काफी उपयोग किया गया था

धन्यवाद, @ स्टीवएल-एमएसएफटी - क्या आप कृपया इस विश्लेषण के परिणाम साझा कर सकते हैं?

हाँ, मैं उनमें से कुछ को देखने के लिए उत्सुक हूँ, क्योंकि मुझे पता है कि कुछ समुदाय के सदस्यों ने अपना विश्लेषण किया और उस तरह के परिणाम के करीब कुछ भी नहीं मिला।

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

मुझे एक प्रश्नवाचक चिह्न के साथ समाप्त होने वाली 8 फाइलों में 11 अद्वितीय चर नाम मिले ($? को छोड़कर जो 8846 बार दिखा)। 408,423 फाइलों में कुल 1,895,983, अद्वितीय चर थे। इसका मतलब है कि कॉर्पस में सभी अद्वितीय पावरशेल चर के 0.0006% में एक प्रश्न चिह्न के साथ समाप्त होने वाला एक चर नाम है।

यहाँ 8 फ़ाइलें और 11 अद्वितीय चर हैं:

File                 : C:\Temp\PowerShellCorpus\Github\alanrenouf_PowerActions\Kill-VM.ps1
QuestionMarkVars     : vParam?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\Github\anthonywlee_PowerShell\Send_Notification.ps1
QuestionMarkVars     : To?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\Github\aspear_My-PowerCLI-scripts\my-labotomize-vms.ps1
QuestionMarkVars     : vParam?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\Github\jlundstrom_Scripts\Powershell\7Zip SFX Creator\Build.ps1
QuestionMarkVars     : Title?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\Github\pslaughter_Working\Setup-Host.ps1
QuestionMarkVars     : HostIp?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\Github\stevenayers_PowerShell-Scripts\Random Functions\Add-OutlookConferenceRegionNumber.ps1
QuestionMarkVars     : {key1?, key2?, key3?, key4?}
QuestionMarkVarCount : 4

File                 : C:\Temp\PowerShellCorpus\Github\unixboy_powershell-stufff\stopvm.ps1
QuestionMarkVars     : vParam?
QuestionMarkVarCount : 1

File                 : C:\Temp\PowerShellCorpus\PowerShellGallery\PsHg\0.6.2\PsHg.psm1
QuestionMarkVars     : PsHg?
QuestionMarkVarCount : 1

यह रिपोर्ट तैयार करने के लिए उपयोग की जाने वाली स्क्रिप्ट है:

Get-ChildItem -Path C:\Temp\PowerShellCorpus -Include *.ps1, *.psm1 -File -Recurse | ForEach-Object -Parallel {
    try {
        $content = $PSItem | Get-Content

        $ast = [System.Management.Automation.Language.Parser]::ParseInput($content, [ref]$null, [ref]$null)
        $variables = $ast.FindAll({$args[0] -is [System.Management.Automation.Language.VariableExpressionAst ]}, $true)

        # First query because I forgot to exclude $? variables
        # $nonQuestionMark = $variables | Where-Object VariablePath -notmatch '\?$' | Select-Object -Unique
        # $QuestionMark = $variables | Where-Object VariablePath -match '\?$' | Select-Object -Unique

        $nonQuestionMark = $variables |
        Where-Object VariablePath -notmatch '\?$' |
        ForEach-Object { $_.VariablePath.UserPath.ToString() } |
        Select-Object -Unique

        $QuestionMark = $variables |
        Where-Object { $_.VariablePath -match '\?$' -and $_.VariablePath.UserPath -ne '?' } |
        ForEach-Object { $_.VariablePath.UserPath.ToString() } |
        Select-Object -Unique

        $output = [pscustomobject]@{
            File = $PSItem
            QuestionMarkVars = $QuestionMark
            QuestionMarkVarCount = $QuestionMark.Count
            NonQuestionMarkVars = $nonQuestionMark
            NonQuestionMarkVarCount = $nonQuestionMark.Count
        }

        $output
    }
    catch {
        throw
    }
}

मुझे बताएं कि क्या इस रिपोर्ट को तैयार करने के लिए इस्तेमाल की जाने वाली विधि में कोई समस्या है। यहाँ एक उदाहरण स्क्रिप्ट है जिसका उपयोग ऑडिट का परीक्षण करने के लिए किया जाता है।

$abc = 'test'
$isAwesome? = $true
$?

$test = {
    $?
    $isabc? = { $adce? = 'test' }
    ${def?} = 123
    ${is a bad var name?} = $isabc?
}

का परिणाम:

File                    : C:\temp\variable.ps1
QuestionMarkVars        : {isAwesome?, isabc?, adce?, def?, is a bad var name?}
QuestionMarkVarCount    : 5
NonQuestionMarkVars     : {abc, true, test}
NonQuestionMarkVarCount : 3

जैसा कि वे गणित की कक्षा में कहते हैं, "कृपया अपना काम दिखाएँ"

उत्कृष्ट खोजी कुत्ता ,

मुझे लगता है कि आप संभावित रूप से और भी अधिक मामलों को समाप्त कर सकते हैं, यह देखते हुए कि फॉर्म ${...} प्रस्तावित परिवर्तन के साथ काम करना जारी रखेगा - उदाहरण के लिए, यह केवल $isAwesome? हमें ${isAwesome?} बारे में चिंता करने की आवश्यकता नहीं है

आपकी उदाहरण फ़ाइल के साथ:

$variables.Extent.Text.Where({ $_ -match '(?<!\$)\?$' }) | Select-Object -Unique

हमें केवल मिलता है:

$isAwesome?
$isabc?
$adce?

अर्थात्, ${def?} और ${is a bad var name?} पर विचार करने की आवश्यकता नहीं है।

पुनश्च: पूरी स्क्रिप्ट को एक स्ट्रिंग के रूप में पढ़ने के लिए $PSItem | Get-Content -Raw का उपयोग करना शायद बेहतर है।

@ mklement0 यह सही है, मैंने उन मामलों को पोस्ट करने से ठीक पहले जोड़ा ताकि यह सुनिश्चित हो सके कि स्क्रिप्ट एक साथ घुंघराले ब्रेस नोटेशन के साथ चर को छोड़कर नहीं थी।

आपकी अनुशंसाओं के साथ स्क्रिप्ट को अपडेट करने के बाद परीक्षण फ़ाइल निम्न आउटपुट उत्पन्न करती है जैसे हम उम्मीद करते हैं।

File                    : C:\temp\variable.ps1
QuestionMarkVars        : {isAwesome?, isabc?, adce?}
QuestionMarkVarCount    : 3
NonQuestionMarkVars     : {abc, true, test}
NonQuestionMarkVarCount : 3

मैंने उन 8 फाइलों पर अद्यतन स्क्रिप्ट चलाई और उनमें से कोई भी घुंघराले ब्रेस नोटेशन का उपयोग नहीं कर रहा है, इसलिए परिणाम अभी भी 11 अद्वितीय चर प्रस्तावित परिवर्तन से प्रभावित होंगे।

अद्यतन स्क्रिप्ट:

Get-ChildItem -Path C:\Temp\PowerShellCorpus -Include *.ps1, *.psm1 -File -Recurse | ForEach-Object -Parallel {
    try {
        $content = $PSItem | Get-Content -Raw

        $ast = [System.Management.Automation.Language.Parser]::ParseInput($content, [ref]$null, [ref]$null)
        $variables = $ast.FindAll({$args[0] -is [System.Management.Automation.Language.VariableExpressionAst ]}, $true)

        $nonQuestionMark = $variables |
        Where-Object VariablePath -notmatch '\?$' |
        ForEach-Object { $_.VariablePath.UserPath.ToString() } |
        Select-Object -Unique

        $QuestionMark = $variables |
        Where-Object { $_.VariablePath -match '\?$' -and $_.VariablePath.UserPath -ne '?' -and $_.Extent.Text -match '(?<!\$)\?$' } |
        ForEach-Object { $_.VariablePath.UserPath.ToString() } |
        Select-Object -Unique

        $output = [pscustomobject]@{
            File = $PSItem
            QuestionMarkVars = $QuestionMark
            QuestionMarkVarCount = $QuestionMark.Count
            NonQuestionMarkVars = $nonQuestionMark
            NonQuestionMarkVarCount = $nonQuestionMark.Count
        }

        $output
    }
    catch {
        throw
    }
}

धन्यवाद, @ThomasNieto - मैं उम्मीद कर रहा था कि हम प्रतिशत को 0.0005% तक कम कर सकते हैं ... (सिर्फ मजाक कर रहे हैं)।

तो समिति ने एक अलग - निजी इस्तेमाल किया होगा? - कॉर्पस।

तो, इस मुद्दे को हाथ में लेने के अलावा, सवाल उठता है: क्या सार्वजनिक रूप से उपलब्ध कोष को अद्यतन करने की आवश्यकता है? क्या इसे आधिकारिक रूप से बनाए रखा गया है (वर्तमान में दिनांक 26 जुलाई 2017)?

@ स्टीवएल-एमएसएफटी, क्या आप कृपया स्पष्ट कर सकते हैं?

@ mklement0 मैं गोल हुआ इसलिए यदि आप थोड़ा बेहतर महसूस करना चाहते हैं तो यह वास्तव में 0.00058% है

https://github.com/PowerShell/PowerShell-RFC/pull/223#discussion_r318340339 में @adityapatwardhan ने उसी सार्वजनिक कोष का उपयोग करके एक विश्लेषण किया जिसका मैंने उपयोग किया और 62% के साथ एक प्रश्न चिह्न के साथ समाप्त होने वाले चर के साथ आया। मैंने इस पर कोई प्रतिक्रिया नहीं देखी कि वह उस प्रतिशत के साथ कैसे आया। क्या इस अनुरोध को निर्धारित करने के लिए पीएस समिति ने उस विश्लेषण का उपयोग किया था?

लिंक की गई टिप्पणी को देखते हुए, मुझे लगता है कि @adityapatwardhan क्या कह रहा है कि _उन सभी चरों में जिनके नाम में ? है_ 62% के नाम के _last_ वर्ण के रूप में ? ।

इसके विपरीत, (घुंघराले-ब्रेस-लेस) एंड-इन- ? चर (समग्र रूप से परिवर्तनीय उपयोग के प्रतिशत के रूप में) के वास्तविक प्रसार का आपका विश्लेषण अधिक प्रासंगिक लगता है।

इस बिंदु पर, ऐसा लगता है कि समिति केवल "हम नहीं चाहते" कह रहे हैं और यदि ऐसा है, तो यह सुविधा भी क्यों है यदि यह परिणाम के रूप में भद्दा और अनुपयोगी होने जा रहा है?

@ThomasNieto इसी तरह मैंने इन मुद्दों के आसपास कहीं एक विश्लेषण किया और आपके समान परिणाम प्राप्त किए।

@mburszley अपना विश्लेषण करने के लिए धन्यवाद। पिछले साल आपको मिले परिणामों की पुष्टि करने के लिए मैं एक और विधि (एएसटी बनाम रेगेक्स) का उपयोग करना चाहता था।

मैं आपको सुनता हूं, @mburszley , लेकिन फिर से:

समिति सिर्फ कह रही है "हम नहीं चाहते"

यदि यह वास्तव में एक _fiat_ निर्णय था - एक वास्तविक दुनिया के उपयोग के विश्लेषण पर आधारित नहीं है - यह बड़े पैमाने पर समुदाय के लिए अच्छा नहीं होगा, विशेष रूप से यह देखते हुए कि इस तरह के विश्लेषण में _कथित_ कारण एक आधार था।

इस प्रकार, हमें समिति को वास्तविक दुनिया के उपयोग विश्लेषण को दिखाने का मौका देना चाहिए - या यह पहचानने के लिए कि विश्लेषण कम हो गया है और निर्णय पर पुनर्विचार करें।

https://github.com/PowerShell/PowerShell/issues/11379#issuecomment-566756120 में मेरे सुझाव के बारे में क्या?

मैं ऐसा करने का सुझाव देता हूं ताकि $obj?.Method() डिफ़ॉल्ट रूप से $<var i="9">obj</var> ?. <var i="12">Method</var>() रूप में काम करे, और केवल $<var i="14">obj?</var> . <var i="17">Method</var>() जब $<var i="19">obj</var> दायरे में मौजूद नहीं है, लेकिन $<var i="21">obj?</var> करता है और #requires ‑Version v7+ नहीं है।

मुझे उम्मीद है कि यह अधिकांश पश्चगामी संगतता चिंताओं को संबोधित करेगा।

@ThomasNieto

@ mklement0 सही है, मेरा मतलब यह था कि ? का उपयोग करने वाले चर के बीच , 62% अंत में इसका उपयोग करते हैं।

यहां टिप्पणी में दिखाए गए परिणामों से लगता है कि सभी चर जो ? उपयोग करते हैं, अंत में इसका उपयोग करते हैं। इसलिए एक गैर-तोड़ने वाला परिवर्तन करने का प्रस्ताव।

यदि {..} को हटा दिया जाता है तो स्क्रिप्ट अभी भी पार्स होगी लेकिन शब्दार्थ अलग होगा, जो मेरी राय में बहुत खतरनाक है।

ज़रूर... लेकिन विश्लेषण से पता चलता है कि लगभग कोई भी उनका उपयोग नहीं कर रहा है।

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

मुझे एक गूढ़ वाक्य रचना की सिफारिश करने का कोई कारण नहीं दिखता है जब एक पहचानकर्ता चरित्र के रूप में ? वास्तव में दूर से महत्वपूर्ण मामलों में उपयोग नहीं किया जा रहा है।

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

क्या आप उन लोगों के बारे में भी चिंतित नहीं हैं जो ?. का उपयोग कर रहे हैं जिस तरह से वे C/C++/C# में करते हैं और बिना किसी संकेत के गलत परिणाम प्राप्त कर रहे हैं उन्होंने कुछ भी गलत किया है? उदाहरण के लिए:

PS> $res = "My length is 15"
PS> $res?.Length
0

निश्चित रूप से, सख्त-मोड इसे ढूंढ लेगा लेकिन मुझे नहीं पता कि बहुत से लोग सख्त मोड का उपयोग करते हैं। इसलिए, बहुत कम प्रतिशत स्क्रिप्ट को टूटने से बचाने के लिए, ऐसा लगता है कि हम ?. का उपयोग करके बहुत से लोगों को विफलता के लिए तैयार कर रहे हैं। मैं व्यापार-बंद के बारे में पागल नहीं हूँ। उस ने कहा, मैं निश्चित रूप से लोगों को तोड़ने से बचने की इच्छा को समझता हूं, भले ही यह बहुत कम संख्या में हो।

हो सकता है कि पावरशेल को Enable-ExperimentalFeature बराबर की आवश्यकता हो, इसे Enable-PSFeature Enable-ExperimentalFeature कहें, उन सुविधाओं के लिए जो अब प्रयोगात्मक स्थिति में नहीं हैं लेकिन डिफ़ॉल्ट रूप से चालू होने के लिए तैयार नहीं हैं। इस तरह के कोड के साथ निष्पादित होने वाली स्क्रिप्ट के लिए $?.GetType() आप चेतावनी देना शुरू कर सकते हैं कि भविष्य में यह टूट जाएगा और आपको इसके बजाय ${?}.GetType() उपयोग करना चाहिए। अलग-अलग स्क्रिप्ट इस सुविधा को #requires -version 7.1 -feature PSNullConditionalOperators साथ सक्षम कर सकती हैं। तब हो सकता है कि जब भी PS 8 हिट हो, तो सुविधा को डिफ़ॉल्ट रूप से सक्षम किया जा सकता है।

@rkeithhill का उदाहरण सीधे मुद्दे पर जाता है।
एक पल के लिए भूल जाइए कि आप आज पावरशेल के काम करने के तरीके के बारे में क्या जानते हैं। जब आप देखते है

PS> $res?.Length

यह _name, operator, name_ जैसा दिखता है - बेशक यह कौन सा है।
जो अधिक समझ में आता है: _"?" ऑपरेटर_ का हिस्सा है, या _"?" प्रथम नाम-तत्व_ का हिस्सा है?
यदि इन ऑपरेटरों की आवश्यकता है (और मुझे लगता है कि वे "पावरशेली नहीं हैं") तो यह किसी ऐसी चीज़ के बीच एक विकल्प है जिसका गलत तरीके से उपयोग किया जाएगा और थोड़ी मात्रा में टूट-फूट होगी।

मैं psScriptAnalyzer _now_ में नियम डालना शुरू करूंगा, यह कहने के लिए कि चर नामों में कुछ [कानूनी] वर्णों का उपयोग करना खराब शैली है।

मुझे Enable-feature पसंद नहीं है। कोई इसे स्क्रिप्ट में डालता है ताकि वे काम का उपयोग करना चाहते हैं, और नई स्क्रिप्ट के बाद चलने पर पुरानी स्क्रिप्ट टूट जाती है, (लेकिन बाकी समय काम करती है)। मैंने देखा है कि _थर्ड पार्टी स्क्रिप्ट X स्क्रिप्ट Y_ चलाने के बाद विफल हो जाती है क्योंकि Y सख्त मोड चालू करता है और X इसके बंद होने पर निर्भर करता है; दोनों लिपियों के लेखक मेरी बुरी किताबों में हैं।

मैं अब psScriptAnalyzer में नियम डालना शुरू करूंगा, यह कहने के लिए कि चर नामों में कुछ [कानूनी] वर्णों का उपयोग करना खराब शैली है।

यहाँ समस्या है: यदि आप जिस तरह से पॉवरशेल टोकन वैरिएबल को बदलते हैं, तो PSScriptAnalyzer उन्हें अलग तरह से भी देखेगा। यदि आपके पास $res? जैसा चर है, तो कुछ इस तरह देख रहे हैं:

{
$res?.Length
}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Expression.VariablePath.UserPath

आप को देंगे

res?

लेकिन, अगर आप पावरशेल को पार्स करने के तरीके को बदलते हैं, तो कहें, 7.2, तो आपको मिल जाएगा

अब PSScriptAnalyzer ? नहीं देख सकता, क्योंकि यह अब वेरिएबल नाम का हिस्सा नहीं है (परिभाषा के अनुसार, क्योंकि यह वह बदलाव है जिसके लिए हम परीक्षण करने का प्रयास कर रहे हैं)। ऐसा इसलिए है क्योंकि PSScriptAnalyzer एक PowerShell मॉड्यूल है और उसी पार्सर का पुन: उपयोग करता है जो PowerShell में शिप करता है। (और अगर यह इसे फिर से लागू करने की कोशिश करता है तो यह पूरी तरह से अप्राप्य और आपदा के लिए एक नुस्खा होगा)।

इसके आस-पास के तरीके हैं, जैसे कि समान निदान की आपूर्ति के लिए नए 7.2 तर्क का परीक्षण करने के लिए सशर्त रूप से PSScriptAnalyzer (और एक पूरी नई असेंबली शिपिंग) संकलित करना। लेकिन फिर आपने कुछ हद तक कॉस्मेटिक परिदृश्य की सेवा के लिए हर जगह जटिलता बढ़ा दी है (या वैकल्पिक रूप से अपनी परीक्षण सतह को कम कर दिया है)।

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

यह मूल रूप से पार्सर/टोकनाइज़र-स्तर के परिवर्तनों को इस तरह से एक और खतरनाक बनाता है। यहां तक ​​​​कि PSScriptAnalyzer को सही ढंग से सेवा देने के लिए पीछे की ओर झुकना चाहिए, जिसका अर्थ है कि उन्हें ऐसे भारी परिवर्तनों के खिलाफ तौला जाना चाहिए।

@rjmholt , जबकि मुझे लगता है कि हम सभी इस बात की सराहना कर सकते हैं कि इस तरह का बदलाव कितना मुश्किल है _in सिद्धांत_, इस विशेष मामले में इससे कोई फर्क नहीं पड़ता _in अभ्यास_, और मुझे नहीं लगता कि पीएसएसए नियम की भी आवश्यकता है:

• @ThomasNieto के विश्लेषण से पता चला है कि - अगर हम मानते हैं कि कॉर्पस सभी पावरशेल कोड का प्रतिनिधि है - तो _वस्तुतः कोई भी उन नामों के साथ चर का उपयोग नहीं करता है जो ? _ में समाप्त होते हैं।

• अगर मैं अनुमान लगाऊं, तो ज्यादातर लोग ऐसे चर नामों का उपयोग करने के लिए _थिंक_ भी नहीं करेंगे, क्योंकि वे उनसे काम करने की उम्मीद नहीं करेंगे (मुझे शामिल किया गया), और शायद इस अपवाद पर भी ध्यान नहीं दिया कि स्वचालित $? चर का गठन होता है (जिसका नाम समान रूप से POSIX- संगत शेल में अपवाद है जैसे bash )।

  • वास्तव में, @ThomasNieto के विश्लेषण को करीब से 8 फाइलों में से:
    
    
    
    • 5 में केवल _false सकारात्मक_ होते हैं, अर्थात् चर _strings_ के अंदर उपयोग करते हैं जैसे "Are you sure you want to kill $vParam?" - वास्तव में, ये उपयोग _broken_ हैं, और यह प्रकट करते हैं कि स्क्रिप्ट लेखकों ने _not_ ? होने की अपेक्षा की थी परिवर्तनीय नाम का हिस्सा।
    
    
    • उन फ़ाइलों में से 2 अब सार्वजनिक रूप से उपलब्ध नहीं हैं।
    
    
    • उनमें से केवल _1_ ? -अंत वाले चर का वास्तविक उपयोग है - _Boolean_ चर (जैसे, $key1? ) के रूप में, जो एक तरफ, इसलिए _not_ सदस्य-पहुंच ऑपरेटर के साथ संयुक्त हैं , . /cc @stevenayers.
    
    

उपरोक्त के आधार पर, यह मुझे एक पाठ्यपुस्तक बकेट 3 के रूप में प्रभावित करता है ग्रे क्षेत्र परिवर्तन, जो इसलिए _स्वीकार्य_ है - और मुझे लगता है कि इस परिवर्तन के _लाभ_ का तर्क दिया गया है।

_Documenting_ व्यवहार में परिवर्तन (तर्क के साथ) पर्याप्त होना चाहिए।

बेशक:

1. यह (ए) विश्लेषण सही होने और (बी) सार्वजनिक रूप से उपलब्ध कॉर्पस प्रतिनिधि होने पर आधारित है।

2. यह समिति के इस दावे के बिल्कुल विपरीत है कि "प्रश्न चिह्न के साथ समाप्त होने वाले चर नामों का काफी उपयोग किया गया था" (जो, निश्चित रूप से, केवल एक समस्या होगी यदि ऐसे चर नाम {...} में संलग्न नहीं हैं

इस धारणा पर आगे बढ़ते हुए कि 1. सत्य है (हमने 2 का समर्थन करने के लिए कुछ भी नहीं सुना है), हमारे पास दो विकल्प हैं:

• बैंड-सहायता को हटा दें और आगे बढ़ने वाले चर नामों में ? को केवल अस्वीकार करें, जब तक कि {...} में संलग्न न हो ( $? के स्पष्ट अपवाद के साथ) - यह गायब हो जाने वाले छोटे को तोड़ देगा उन लिपियों का अनुपात जो वर्तमान में उस पर निर्भर हैं।

  • यानी, $key1? जैसा कुछ जिसके बाद न तो . और न ही कोई अन्य ? ( $key1??'else' ) और न ही एक टर्नरी एक्सप्रेशन ( $key1?1:0 ) एक _parser त्रुटि_ का कारण होगा।
    
    
    
    • जैसा कि नल-कोलेसिंग और टर्नरी ऑपरेटर उदाहरण दिखाते हैं, वे भी इस परिवर्तन से लाभान्वित होंगे - वर्तमान में, आपको या तो _space_ - $key1 ?1:0 / $key1 ??'else' - या {...} - ${key1}?1:0 / ${key1}??'else'
    
    
  • _expandablestrings_ के अंदर, ? को अब एक (गैर- {...} -संलग्न) चर नाम का हिस्सा नहीं माना जाएगा, इसलिए हम वास्तव में _fix_ मौजूदा स्क्रिप्ट्स होंगे जिन्होंने गलती से स्ट्रिंग्स का उपयोग किया है जैसे कि "Are you sure you want to kill $vParam?" . मैं

• यदि हम वास्तव में महसूस करते हैं कि हमें मौजूदा लिपियों के लुप्त हो रहे छोटे अनुपात को तोड़ने से बचने की आवश्यकता है, तो हम @ExE-Boss द्वारा प्रस्तावित तर्क पर विचार कर सकते हैं, लेकिन मुझे नहीं लगता कि हम इस वैचारिक जटिलता को पेश करना चाहते हैं - अकेले कार्यान्वयन जटिलता (जो कि मैं वास्तव में बात नहीं कर सकता)।

@ स्टीवएल-एमएसएफटी

सितंबर समुदाय कॉल में इस मुद्दे पर चर्चा करने के लिए धन्यवाद (https://aka.ms/PSCommunityCall; इस लेखन के समय, सितंबर कॉल की रिकॉर्डिंग वहां पोस्ट नहीं की गई है, लेकिन https://aka.ms/JoinPSCall पर उपलब्ध है, अगली कॉल तक), 46:00 से शुरू होकर, https://github.com/PowerShell/PowerShell-RFC/issues/260 पर चर्चा के विषयों के लिए पूर्व आग्रह में @ThomasNieto के सुझाव के आधार पर:

(मैं रिकॉर्डिंग के प्रासंगिक हिस्से के लिए एक सीधा लिंक प्रदान करने की उम्मीद कर रहा था, लेकिन इसे YouTube पर पोस्ट किए जाने और https://aka.ms/PSCommunityCall से लिंक होने तक इंतजार करना होगा।)

रिकॉर्डिंग में आपकी टिप्पणियों के आधार पर:

• यह देखते हुए कि आपने इस पर फिर से जाने की इच्छा व्यक्त की है, कृपया इस मुद्दे को फिर से खोलें और इसे Review - Committee रूप में पुनः टैग करें।

• जहां तक ​​आपकी टिप्पणी का संबंध है कि चर नामों को घुंघराले ब्रेसिज़ में संलग्न करना एक पूर्व-मौजूदा विशेषता है और लोग इस मामले में _aesthetic_ आधार पर उनका उपयोग करने पर आपत्ति जताते हैं:

  • मुझे नहीं लगता कि यहां किसी को इस बात की जानकारी नहीं है कि {...} _can_ और कभी-कभी _must_ का उपयोग चर नामों को स्पष्ट करने के लिए किया जाता है।
  • यह _सौंदर्यशास्त्र_ के बारे में भी नहीं है, यह मुख्य रूप से _अपेक्षित व्यवहार नहीं प्राप्त करना_ इस तरह से है कि _चुपचाप विफल हो जाता है, क्योंकि _इस मामले में {...} का उपयोग करने की अपेक्षा नहीं की जाती है_; एक माध्यमिक चिंता टाइपिंग असुविधा है।

GitHub

पावरशेल/पावरशेल-आरएफसी

आरएफसी (टिप्पणियों के लिए अनुरोध) डिजाइन परिवर्तन और पावरशेल पारिस्थितिकी तंत्र में सुधार पर समुदाय प्रतिक्रिया के लिए दस्तावेज - पावरशेल/पावरशेल-आरएफसी

माइक्रोसॉफ्ट टीम

बातचीत में शामिल हों

मुझे चिंता है कि यह मुद्दा - अब अनिश्चित काल के लिए बंद अवस्था में प्रतीत होता है - दरार के माध्यम से गिर जाएगा, इसलिए मैंने इसे फिर से देखने के लिए एक अनुस्मारक के रूप में #14025 खोला है, और मैं उन सभी को आमंत्रित करता हूं जो वहां अपना समर्थन दिखाने के लिए इच्छुक हैं।