पॉवरशेल में गोल्फ के लिए टिप्स


45

विंडोज पॉवरशेल में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं जो सामान्य रूप से कोड समस्याओं को लागू कर सकते हैं जो पावरशेल के लिए कम से कम कुछ हद तक विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)। कृपया प्रति उत्तर एक टिप पोस्ट करें।

- मार्कोग के सवाल से लगभग शब्दशः ।


3
जब मैंने "पॉवरशेल गोल्फ" शुरू किया तो यह पहली हिट थी!
मैट

जवाबों:


24

वैज्ञानिक संकेतन के साथ 10 लीटर की शक्तियां:

4e6 = 4000000

2 लीटर की शक्तियां:

4KB = 4096
4MB = 4194304
4GB = 4294967296

# TB and PB suffixes also exist, but less useful for golf.

काम आ सकता है।


19

यदि आपको एक लूप चलाने की आवश्यकता है, और आप ठीक से जानते हैं कि कितनी बार इसे हर बार चलाने की आवश्यकता है, तो उपयोग करने के बजाय उपनाम के ForEach-Objectमाध्यम से सन्निहित पूर्णांकों की एक सरणी को पाइप करने पर विचार %करें for

for($x=1;$x-le10;$x++){...}

बनाम

1..10|%{...}


18

आप रिक्तियों को छोड़ सकते हैं एक बहुत PowerShell में। अगर ऐसा लगता है कि इसकी आवश्यकता नहीं हो सकती है, तो यह संभवतः नहीं है। तुलनाओं में यह विशेष रूप से उपयोगी है।

उदाहरण:

$x-eq$i-and$x-ne9

बनाम

$x -eq $i -and $x -ne 9

यदि आपको एक एकल परीक्षण के परिणाम के आधार पर अपनी स्क्रिप्ट को शाखा करने की आवश्यकता होती है, जिसमें कई परिणाम हो सकते हैं, तो switchकभी-कभी एक बयान में मेल खा सकता है या हरा सकता है।

उदाहरण (स्विच बनाम यदि / और - टाई):

if($x%2-eq0){'even'}else{'odd'}

बनाम

switch($x%2){0{'even'}1{'odd'}}

या (स्विच बनाम इफ / पर्सिफ़ / वरना - 15 से स्विच जीत):

if($x%2-eq0){'even'}elseif($x%2-eq1){'odd'}else{'error'}

बनाम

switch($x%2){0{'even'}1{'odd'}2{'error'}}

यदि स्विच वास्तव में कुछ गणित के परिणामों पर आधारित है, तो ऊपर दिए गए मोडुलो ऑपरेशन की तरह, आप स्विच को पूरी तरह से एक ऐरे से बदल सकते हैं। यहाँ, यह एक और 13 वर्णों को बचाता है और मूल दो-विकल्प की तुलना में भी छोटा है यदि / अन्यथा कथन। ( इस बिट के लिए डैंको डर्बिक के लिए धन्यवाद ।)

('even','odd','error')[$x%2]

यदि आप किसी विशेष कमांड का उपयोग कर रहे हैं, विशेष रूप से पहले से मौजूद शॉर्ट-हैंड एलियास के बिना, तो एकल-पात्र उपनाम को जल्दी से सेट करें।

उदाहरण:

nal g Get-Random;g 10;g 10;g 10

बनाम

Get-Random 10;Get-Random 10;Get-Random 10

('even','odd')[$x%2]FYI करें।
Incorrigible1

15

कोष्ठक में एक चर को परिभाषित करने वाली कमांड को एनकैप्सुलेट करने से आप चर की परिभाषा को सीधे अन्य कमांडों में फीड कर सकते हैं।

उदाहरण के लिए, आप $ x को सेट कर सकते हैं और फिर इसके साथ एक शॉट में $ x के मूल्य के आधार पर $ y सेट कर सकते हैं:

$y=($x=1)+1

इसके अलावा:

$x=1;$y=$x+1

आप $ h सेट कर सकते हैं और इसे इसके साथ आउटपुट कर सकते हैं:

($h='Hello World!')

इसके अलावा:

$h='Hello World!';$h

1
यह विशेष रूप से वस्तुओं पर कॉल करने के तरीकों के लिए उपयोगी है। ($x=New-Object Windows.Forms.Form).Controls.Add($t)
स्पेलिंगडी

14

एक स्विच लूप की तरह काम कर सकता है, जब एक सरणी दी जाती है। उदाहरण के लिए:

$FooBarMeh='a','b','c'
switch ($FooBarMeh)
{
    'a'{'FOO'}
    'b'{'BAR'}
    default{'MEH'}
}

उत्पादन होगा:

फू
बर
मी

मुझे पूरी तरह से यकीन नहीं है कि यह कहाँ उपयोगी होगा, लेकिन मुझे उम्मीद है कि यह किसी के लिए कुछ समय के लिए उपयोगी होगा।


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

यह है ... बहुत अजीब है। एक सरणी को चार के साथ मेल नहीं खाना चाहिए, लेकिन यह करता है।
बिल्ली

@ जोये यही switch -File $pathहै
TheIncorrigible1

नहीं सब कुछ है कि पार्स किया जाता है एक फ़ाइल होने के लिए होता है।
जॉय

12

[math]::powगुणन के साथ बदलें । के बजाय

[math]::pow($a,$b)

तुम लिख सकते हो

"$a*"*$b+1|iex

यह पूर्णांक घातांक> = 0 के लिए काम करता है।


मुझे समझने के लिए इस उत्तर को देखने की आवश्यकता थी iex... एलियास के लिएInvoke-Expression
हीटफैन

11

तुलना संचालक मिलान मूल्यों को वापस करके मूल्यों के संग्रह पर काम करते हैं:

1..5 -gt 2

उपज होगी 3, 4और 5। कुछ मामलों में यह अन्यथा लंबे समय तक बचाने में मदद कर सकता है |?{$_...}

-match तुलना ऑपरेटर भी है।


1
ध्यान दें कि आपको उस उदाहरण में रिक्त स्थान की आवश्यकता नहीं है1..5-gt2
मैट

1
मुझे पता है; यह तकनीक दिखाने के बारे में अधिक था। रिक्तियाँ एक अलग उत्तर में हैं
जॉय

11

जब भी संभव हो उपनाम का उपयोग करें। उपयोगी लोगों का एक समूह है:

?        Where-Object
%        ForEach-Object
gu       Get-Unique
sort     Sort-Object
iex      Invoke-Expression

11

मूल्यों के संग्रह का अधिकतम या न्यूनतम पता लगाना चाहते हैं? कोशिश की

(...|measure -ma).Maximum

या

(...|measure -mi).Minimum

पहले से?

बस अंतिम या पहले आइटम को क्रमबद्ध करें और उसका उपयोग करें:

(...|sort)[-1]  # maximum
(...|sort)[0]   # minimum

1
और, यदि आप मूल्यों के संग्रह की लंबाई जानते हैं और यह 10 से कम है ...
wizzwizz4

@ wizzwizz4: ओह, अधिकतम लंबाई को अक्सर रचनात्मक रूप से नियोजित किया जा सकता है, जरूरी नहीं कि 10. हालांकि इस विशेष मामले के लिए मुझे एक उदाहरण याद नहीं है जहां यह कभी मदद करता है।
जॉय

1
मेरा मतलब, अगर अंतिम आइटम माना जाता है 0, 1, 2, 3, 4, 5, 6, 7, 8या 9, यह एक बाइट को बचाने के बजाय ज्ञात लंबाई लिखने के लिए होगा -1
wizzwizz4

10

संपत्ति का नाम छोटा करना

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

लेकिन कुछ cmdlets प्रॉपर्टी के नाम पर काम कर सकते हैं और वाइल्डकार्ड ले सकते हैं, और इसके बहुत कम ज्ञात पैरामीटर सेट हैं %और ?यह उपयोगी हो सकते हैं।

आमतौर पर हम एक स्क्रिप्टब्लॉक में पास होते हैं और आइटम को संदर्भित करते हैं $_, लेकिन इनमें से एक और रूप है जो एक संपत्ति का नाम लेता है, और यह एक वाइल्डकार्ड स्वीकार करता है।

$o|select Le*  
$o|%{$_.Length}

एक संपत्ति के साथ जैसे .Lengthहम v3 जादू का उपयोग नहीं कर सकते हैं जो सामान्य रूप से एक सरणी पर काम करेगा क्योंकि सरणी Lengthकी एक संपत्ति ही है, इसलिए उपरोक्त दो का उपयोग व्यक्तिगत सदस्यों की लंबाई प्राप्त करने के लिए किया जा सकता है। selectआता है एक छोटे में छोटे सा।

लेकिन %सीधे एक संपत्ति का नाम ले सकते हैं और उस मूल्य को वापस कर सकते हैं:

$a|% Length

जिसे वाइल्डकार्ड से छोटा किया जा सकता है। वाइल्डकार्ड को एक ही संपत्ति (या विधि, उस पर अधिक बाद में) को हल करना होगा, इसलिए यदि यह नहीं पता चलता है कि यह किस सदस्य को हल कर सकता है, तो यह एक सहायक त्रुटि को फेंक देगा।

के मामले में Length, Le*आमतौर पर सबसे छोटा है। एकल स्ट्रिंग पर भी, यह विधि केवल संपत्ति का उपयोग करने की तुलना में 1 बाइट कम है।

$a.Length                # 9   #(doesn't work on array)
$a|%{$_.Length}          # 15
$a|% Le*                 # 8

लेकिन आप इसके साथ क्या कर रहे हैं, इसके आधार पर, यह बदतर हो सकता है। आप कर सकते हैं $a.Length*5लेकिन इसे पाइपलाइन अभिव्यक्ति के साथ करने के लिए आपको इसे लपेटना होगा ($a|% Le*)*5; यह अभी भी इसके लायक हो सकता है अगर यह एक सरणी के खिलाफ है, लेकिन बिंदु यह एक सीधे प्रतिस्थापन के रूप में हमेशा उचित नहीं है।

यह विधियों के साथ भी काम करता है, और आप इसे छोड़ सकते हैं ()जो एक पूर्ण नाम को एक ही लंबाई बनाता है, लेकिन ऊपर से कभी-कभी इसे लपेटने के बारे में भी प्रतिबंध। विधि में एक अधिभार होना चाहिए जो कोई पैरामीटर नहीं लेता है (आप विधि नाम के बाद उन्हें रखकर तर्क पारित कर सकते हैं, जो वास्तव में अच्छा है):

$a.ToUpper()             # 12
$a|% *per                #  9

तर्कों के साथ:

'gaga'-replace'g','r'    # 21
'gaga'|% *ce g r         # 16

ये कड़ाई में समान नहीं हैं कि -replaceऑपरेटर रिप्जेक्स को प्रतिस्थापित करता है, लेकिन यदि आप एक स्ट्रिंग को प्रतिस्थापित कर रहे हैं, तो यह (अब) विधि का उपयोग करने के लिए कम हो सकता है; यह मदद करता है कि तार विधि तर्कों के बजाय cmdlet तर्क हैं, इसलिए उन्हें उद्धृत करने की आवश्यकता नहीं है।

जहाँ-जहाँ गुण

?के रूप में अच्छी तरह से (आंशिक) संपत्ति नाम ले सकते हैं, और इसे (स्विच मापदंडों के रूप में) एक "ऑपरेटर" लागू कर सकते हैं। Where-Objectयदि संपत्ति का नाम पर्याप्त रूप से लंबा और अनूठा है, तो फिर से यह मानक स्क्रिप्टब्लॉक दृष्टिकोण का उपयोग करने से कम हो सकता है ।

$a|?{$_.Length-gt5}      # 19
$a|? Le* -GT 5           # 14

($a|% Le*)-gt5           # 14 - Lengths, not objs

1
उन कुछ स्थानों में से एक जहां व्हॉट्सएप की आवश्यकता है। हालांकि अच्छा लगा। मैं कई क्षेत्रों के बारे में सोच सकता हूं जहां यह चीजों को छोटा कर देगा।
AdmBorkBork

अच्छा संपादन जॉय! धन्यवाद।
ब्रितानी

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

1
@ConnorLSW आह हाँ, मैं इसे अद्यतन करने का मतलब था क्योंकि मुझे एहसास हुआ कि आप इस तरह से पास कर सकते हैं, जो इसकी उपयोगिता को बढ़ाता है। के महान उपयोग .ToString()!
२१:

2
@briantist ने PowerShell को बहुत अधिक प्रतिस्पर्धी भाषा में बदल दिया है, वास्तव में कुछ कष्टप्रद वर्बोज़ .नेट कॉल को काट देता है।
कॉल्व्स


9

अर्धविराम और रेखा विराम विनिमेय हैं। गोल्फ लाइन अक्सर अधिक पठनीय होती है यदि एक ही लाइन में जाम न हो। और लंबाई अभी भी समान है (बशर्ते आप यू + 000 ए का उपयोग लाइन ब्रेक के रूप में करें जो पावरस्ले समस्याओं के बिना संभालता है)।


2
रुको, हम पठनीयता के बारे में चिंतित हैं ?!
केविन कॉक्स

4
यदि लंबाई पर इसका कोई प्रभाव नहीं है ... तो क्यों नहीं?
जोए

क्या तकनीकी रूप से इससे कोई फर्क नहीं पड़ता क्योंकि अर्धविराम \ r \ n से एक कम वर्ण है? केवल यूनिक्स में यह एक विलक्षण \ n है।
वासिलि सिरैकिस

2
@Vasili: आप लाइनों के बीच केवल U + 000A के साथ ठीक फ़ाइलों को बचा सकते हैं। PowerShell को शिकायत नहीं होगी। जो मैंने पहले से ही उत्तर में लिखा था, वैसे। लाइन ब्रेक फ़ाइल की एक संपत्ति है , ऑपरेटिंग सिस्टम का नहीं इसका उपयोग किया जाता है। कोई यह नहीं कहता है कि आप विंडोज पर यूनिक्स लाइन अंत का उपयोग नहीं कर सकते।
जॉय

@ जॉय यदि आपने कुछ त्वरित प्रोग्रामिंग करने के लिए खिड़कियों की एक ताजा स्थापना का उपयोग किया है, तो आप ध्यान देंगे कि नोटपैड \ x0a के साथ अच्छा नहीं खेलता है
स्टेन

9

Getक्रिया निहित है। यह किसी भी Get-Frobको छोटा कर सकता है Frob। बार-बार दावेदार हैं dateया random

ध्यान दें कि यह कुछ मामलों में ठीक से काम नहीं करेगा क्योंकि आपके रास्ते में GNU उपयोगिताओं (या अन्य मूल प्रोग्राम जो क्लैश हो सकते हैं) हो सकते हैं। उस मामले में कमांड लुकअप का आदेश मूल प्रोग्राम को पसंद करता है, इससे पहले कि वह Get-हटाए गए के साथ cmdlets समझता है:

PS Home:\> date

Freitag, 15. November 2013 07:13:45


PS Home:\> $Env:Path += ';D:\Users\Joey\Apps\GnuWin32\bin'
PS Home:\> date
Fr Nov 15 07:14:13 W. Europe Standard Time 2013

यह नहीं है काफी हमेशा बाहर काम अपेक्षा के अनुरूप। मेरे पास एक स्क्रिप्ट है जो nal g Get-Randomबाद में पात्रों को बचाने के लिए शुरू होती है । इसे बदलने nal g Randomसे स्क्रिप्ट अनिश्चित काल के लिए लटक जाती है (या, कम से कम, प्रक्रिया के लिए समय की एक विषम राशि ले लो - मेरे पास इसके समाप्त होने की प्रतीक्षा करने का धैर्य नहीं है, लेकिन यह मूल रूप से अधिक समय तक परिमाण के कई आदेश ले रहा है। इससे पहले कि मैं गर्भपात करूं)।
इज़ी

2
दो छोटे Measure-Commandआह्वान (100 बार Get-Randomबनाम random) मुझे बताएं कि यह लगभग 500 गुना धीमा है। मुझे नहीं पता था कि पहले, ईमानदार होने के लिए। लेकिन इसे ध्यान में रखना अच्छा है, विशेष रूप से कई पुनरावृत्तियों के साथ छोरों में। कहा जा रहा है, गोल्फ कोड छोटा होना चाहिए, तेजी से नहीं ( जो कहा जा रहा है, यह प्रोजेक्ट यूलर समस्या के जवाब के लिए दो दिन इंतजार करना पड़ता है)।
जोए

1
मेरी समस्या मोंटी हॉल परिदृश्य के 10,000 पुनरावृत्तियों चल रही थी, प्रत्येक में गेट-रैंडम के तीन पुनरावृत्तियों की आवश्यकता थी। प्रसंस्करण समय में 50,000% की वृद्धि, 30,000 रन के पार गुणा बहुत बुरा है।
इज़्ज़ी

वाह। ऐसा लगता है कि शायद किसी भी अन्य के लिए सच है। Get-Variableबनाम परीक्षण किया gvऔर एक समान तुलना मिली।
इस्सी

1
यह हो सकता है। मैंने कुछ गणित किया और लगा कि मेरे मोंटी हॉल की स्क्रिप्ट को बिना चलने के लिए लगभग 1.5 घंटे (सामान्य रूप से, 10-11 सेकंड) लेने चाहिए Get-। कि लंबाई में सिर्फ 4 वर्णों की बचत के लिए रन टाइम में एक बहुत सुंदर ब्लोट है।
इस्ति

8

for छोरों के हेडर में 0 और तीन कथनों के बीच कुछ भी हो सकता है:

अंतहीन पाश:

for(){}

प्रारंभ के साथ लूप:

for($n=0){}

प्रारंभिक और अंतिम स्थिति के साथ लूप:

for($n=0;$n-lt7){}

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

यह भी whileथोड़ा कम करता है। तुलना

while(...){}

तथा

for(;...){}

अतिरिक्त बोनस के साथ आप forअतिरिक्त लागत (और यहां तक ​​कि एक चरित्र को बचाने के बिना ) के रूप में अच्छी तरह से एक पिछली पंक्ति में छड़ी कर सकते हैं ।


8

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

कुछ इस तरह:

$a="apple","orange"
$a[0] # apple
$a[1] # orange

आसानी से इसे चालू किया जा सकता है:

$a,$o="apple","orange"
$a # apple
$o # orange

यह तब भी उपयोगी हो सकता है जब आपको किसी सरणी के पहले तत्व की आवश्यकता हो:

$a,$b=1..10
$a # 1
$b # 2..10

इस मामले में (स्ट्रिंग्स के साथ) $a="apple";$o="orange"लंबाई में समान है। यह लंबी सरणियाँ है जो कभी-कभी काफी अच्छी तरह से अनुकूलित की जा सकती हैं, उदाहरण के लिए एक विभाजक के साथ एक स्ट्रिंग में सभी तत्वों को डालकर और फिर का उपयोग करके -split(व्हाट्सएप को विभाजक के रूप में उपयोग करने के लिए सबसे अच्छा है क्योंकि तब एकता -splitपर्याप्त होगी)।
जॉय

8

स्ट्रिंग के लिए कास्टिंग:

[string]$x

बनाम

"$x"

इस तरह से स्ट्रिंग करने के लिए कास्टिंग को जोड़ने के बजाय स्ट्रिंग के एक सरणी को समतल करने के लिए भी इस्तेमाल किया जा सकता है:

$a = @('a','b','c')
$a -join ' '

बनाम

$a = @('a','b','c')
"$a"

संख्यात्मक प्रकार के लिए एक स्ट्रिंग कास्टिंग:

[int]$x     [float]$x

बनाम

+$x

यह जानने के लिए भी बहुत उपयोगी है कि PowerShell हमेशा अंतिम प्रकार के अभिव्यक्ति और रूपांतरण के अंतिम प्रकार को निर्धारित करने के लिए लेती है:

'1'+2    -> '12'
1+'2'    -> 3

जो यह निर्धारित करने में मदद कर सकता है कि अनावश्यक जातियां कहां हैं।


6

यह मत भूलो कि आपको हमेशा एक पैरामीटर का पूरा नाम प्रदान करने की आवश्यकता नहीं है, और कुछ पैरामीटर स्थितीय हैं।

Get-Random -InputObject (0..10)

... को ट्रिम किया जा सकता है ...

Get-Random -I (0..10)

... क्योंकि "I", इस मामले में, InputObjectइस आदेश के लिए अन्य मान्य मापदंडों से विशिष्ट पहचान करने के लिए पर्याप्त है ।

आप इसे आगे ट्रिम कर सकते हैं ...

Get-Random (0..10)

... क्योंकि InputObjectएक स्थितिगत पैरामीटर है।

पाइपिंग आमतौर पर एक पैरामीटर के रूप में वस्तुओं को खिलाने से कम होता है, खासकर जब यह कोष्ठक की आवश्यकता को दूर कर सकता है। चलो हमारे यादृच्छिक संख्या जनरेटर आगे ट्रिम ...

0..10|Get-Random

एक ही चीज़ को पूरा करने के लिए अन्य तरीकों की तलाश में रहें, भले ही आप कमांड को बदल न सकें। उपरोक्त मामले के लिए, आप ऐसा कर सकते हैं:

Get-Random 11

या, किसी अन्य सुझाव को शामिल करना *:

Random 11

** नोट: Get-एक कमांड नाम से ओमिटिंग रन समय को लगभग 50,000% तक बढ़ा सकता है। बुरा नहीं है यदि आपको केवल एक बार कमांड की आवश्यकता है, लेकिन लंबे छोरों में इसका उपयोग करने में सावधानी बरतें। *

और यह है कि एक साधारण कमांड को इसके आकार के एक तिहाई तक नीचे खटखटाया जा सकता है।


6

नकली टर्नरी ऑपरेटर। आप एक ifबयान से सीधे असाइन कर सकते हैं :

$z=if($x-eq$y){"truth"}else{"false"}

लेकिन आप 2-एलिमेंट एरे का उपयोग कर सकते हैं और टेस्ट को इंडेक्स करने के लिए उपयोग कर सकते हैं। $ मिथ्या परिणाम तत्व 0 प्राप्त करते हैं, $ सत्य परिणाम तत्व 1 लेते हैं:

$z=("false","true")[$x-eq$y]

एनबी। यह वास्तव में सरणी अनुक्रमण कर रहा है, और यदि परीक्षण के परिणाम में एक पूर्णांक के लिए डाली जा सकती है, तो आप सरणी के सीमा के बाहर एक आइटम के लिए पूछेंगे और $ null वापस प्राप्त करेंगे, और !(test)बल के लिए करने की आवश्यकता होगी परिणाम को उलट दिए जाने के साथ, एक बूल को कास्ट करें।


पहले स्निपेट ने एक समय में काम नहीं किया (पुराने पॉवरशेल संस्करण), अगर मुझे सही याद है, तो इसे लपेटने के लिए आवश्यक है $()। अनिवार्य रूप से आदेशों और कथनों से अभिव्यक्ति के रूप में बनाई गई पाइपलाइनों का उपयोग करने का एक भेद था। लगता है कि अब तक चला गया है, कम से कम PowerShell 5 में
जॉय

इसके अतिरिक्त, यदि सरणी तत्व गैर-स्थिर हैं, तो दोनों अनुक्रमणित होने से पहले सरणी निर्माण के भाग के रूप में पार्स और संसाधित हो जाते हैं और परिणाम असाइन किया जाता है। उदाहरण के लिए
AdmBorkBork

6

किसी ऑपरेटर के तर्क के रूप में किसी संख्या का उपयोग करते समय जिसे अन्यथा स्ट्रिंग की आवश्यकता होगी, आप सीधे संख्या का उपयोग कर सकते हैं। तुलना

...-join'0'

बनाम

...-join0

साथ -splitही काम करता है । तर्क को हमेशा पहले स्ट्रिंग में परिवर्तित किया जाता है।


संदर्भ के लिए, यह भी साथ काम करता है -replace
AdmBorkBork

-replaceयह भी कोई दूसरा तर्क के साथ काम करता है कि आप मैच को हटाना चाहते हैं,
जॉय

5

निरपेक्ष मूल्य

साथ में

$n=-123

के बजाय

[math]::abs($n)

उपयोग

$n-replace'-'

यदि कोष्ठक की आवश्यकता है, तो निश्चित रूप से बचत रद्द कर दी जाती है।


या यदि आपको किसी ऑपरेटर के बाईं ओर परिणाम की आवश्यकता है ;-)
जॉय

5

यदि आपको त्रुटियों को चुप करने की आवश्यकता है, तो स्पष्ट संस्करण होगा

try{ <# something that throws errors #> }catch{}

हालाँकि, यह रास्ता बहुत लंबा है। एक छोटा वेरिएंट tryब्लॉक को स्क्रिप्ट ब्लॉक के रूप में चलाने के लिए है और बस त्रुटियों को एक अनसेट वेरिएबल में रीडायरेक्ट $nullकरेगा ( सामान्य रूप से एक होगा, लेकिन यह अभी भी बहुत लंबा है):

.{ <# something that throws errors #> }2>$x

यह पांच मूल्यवान बाइट्स बचाता है (यदि दुनिया नहीं)।


5

सरणी को संशोधित करते समय उपयोग किए गए O utput F ield S eparator को बदलने के लिए $ofs विशेष चर का उपयोग करें । उपयोगी यदि आप कई बार तार को सरणियों को बदलने की जरूरत है।

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

$a=1,2,3,4
$a-join',';$a-join','
$ofs=',';"$a";"$a"

2+ n वर्णों को 2 पर सहेजता है -join, जहाँ n विभाजक की लंबाई है, और इसके बाद 3rd और प्रत्येक के लिए एक अतिरिक्त 5+ n बचाता है -join


1
अफसोस की बात है कि शायद ही कभी उपयोगी (कम से कम मेरी गोल्फ में अब तक - मैं इसे केवल एक ही अंत में शामिल होने के लिए पट्टी करता हूं)।
जॉय

5

स्वचालित चर में सच और गलत के लिए बूलियन होते हैं $trueऔर $falseआप तार्किक नहीं ऑपरेटर !और पूर्णांक 0 और 1 (या किसी भी गैर-शून्य पूर्णांक) का उपयोग करके समान परिणाम प्राप्त कर सकते हैं ।

PS C:\Users\matt> !1
False

PS C:\Users\matt> !0
True

सभी PowerShell अभिव्यक्तियों के पास बूलियन के रूप में मूल्यांकन किया जा सकता है। तो जब तक आप जानते हैं कि कुछ डेटा का मूल्यांकन कैसे किया जाता है, तो आप बूलियन प्राप्त कर सकते हैं और उन्हें स्पष्ट रूप से डालने की आवश्यकता नहीं है। इन्हें करते समय LHS मूल्य से अवगत रहें।

  • पूर्णांक 0 गलत है और गैर-शून्य पूर्णांकों का मूल्यांकन सही है।
  • गैर-शून्य लंबाई के तार सही हैं और खाली या अशक्त (और खुद को अशक्त) तार झूठे हैं।

अन्य उदाहरण हैं, लेकिन आप आसानी से एक कास्ट करके परीक्षण कर सकते हैं

PS C:\Users\matt> [bool]@(0)
False

1
कई अन्य डेटा प्रकारों की भी समान स्थिति है। Uninitialized वैरिएबल डिफ़ॉल्ट रूप से $null, जो कि गलत है। खाली स्ट्रिंग (और रिक्त स्ट्रिंग के लिए सेट चर) गलत हैं। आदि। तो इसे एक सरणी में अनुक्रमण शॉर्टकट करने के लिए इस्तेमाल किया जा सकता है (उदाहरण के लिए, a if/ करते समय else), जैसा कि FizzBuzz में उपयोग किया गया था ।
AdmBorkBork

@TimmyD बहुत सच है। intएस का उपयोग करना अभी कम है
मैट

@ टिम्मीड मैं आपका जवाब देने तक फ़िज़बज़्ज़ का जवाब देना चाहता था .... आपको हरा नहीं सकता .... कम से कम अभी तक नहीं
मैट

ध्यान दें कि कई मामलों में आपको वास्तव में कोई ज़रूरत नहीं है bool। आप उपयोग कर सकते हैं 0और 1बस के रूप में अच्छी तरह से। निहित रूपांतरण उस संबंध में बहुत मदद करते हैं (जिसे आप अक्सर कुछ ऑपरेटरों के साथ मजबूर कर सकते हैं)।
जोए

4

Invoke-Expressionऔर Get-Randomतर्कों के बजाय पाइपलाइन इनपुट भी प्राप्त कर सकते हैं।

इसके लिए iexकुछ अभिव्यक्तियों पर कोष्ठकों को सहेजने की अनुमति देता है:

iex 1..5-join'+'   # won't work
iex(1..5-join'+')  # does work, but has extra parentheses
1..5-join'+'|iex   # doesn't need the parentheses

इसके मामले में randomएक सामान्य मामले को थोड़ा अनुकूलित किया जा सकता है:

random -mi 10 31   # gets a random integer between 10 and 30
10..30|random      # much better :-)
(random 21)+10     # if needed in another expression that doesn't require extra
                   # parentheses

इसका उपयोग करने का बाद का तरीका बस एक सूची से एक आइटम का चयन करता है। -cतर्क एक भी चयन की तुलना में अधिक अनुमति देने के लिए दिया जा सकता है।


4

फ़ंक्शंस का उपयोग करने के बजाय, चर स्क्रिप्ट्स को चर में रखने पर विचार करें।

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

function Hi{echo 'Hello, World!'};Hi

बनाम

$Hi={echo 'Hello, World!'};&$Hi

2
उन कार्यों के लिए उपयोगी जो तर्क नहीं लेते हैं। अन्यथा params(...)फंक्शन डेफिनिशन सेव होने से ज्यादा जगह लेगा। संबंधित: उपयोग filterसे अधिक functionहै जब आप ऐसा कर सकते हैं।
जोए

आप $argsकी जरूरत से बचने के लिए उपयोग कर सकते हैं params; यानी $x={$args[0]+2}(या भी $x={2+"$args"}); कुछ परिस्थितियों में एक चरित्र या 2 को बचा सकता है। आप इसे कई $x={$a,$b=$args;$a+$b+3}
पारमों के

4

आप एक स्ट्रिंग को चार सरणी में विभाजित करने के $s|% t*yबजाय उपयोग कर सकते हैं [char[]]$sTessellatingHeckler के जवाब से दिया गया : समान % t*yकरने के लिए फैलता है | ForEach-Object -Method ToCharArray। का"$args".ToCharArray()

उदाहरण के लिए, तुलना करें

$s|% t*y

तथा

[char[]]$s

तथा

$s.ToCharArray()

यह $argsविशेष रूप से उपयोगी है :$args|% t*y


1
वह काफी साफ-सुथरा है। मैंने %कुछ समय के लिए सदस्यों के लिए ट्रिक का उपयोग किया है , लेकिन मेरे अधिकांश गोल्फिंग उस सुविधा; यह काफी सामान्य तकनीक भी है: एक पत्र / वाइल्डकार्ड संयोजन खोजने की कोशिश करें जो आपकी ज़रूरत की संपत्ति / विधि से मेल खाता हो (और वास्तविक स्थिति से कम हो)।
जॉय

उत्तर से एक और उपयोगी उदाहरण: के $s|% *perलिए $s.toUpper()और के $s|% *werलिए $s.toLower()। मैं सहमत हूँ कि काफी साफ-सुथरा है।
माज़ी

एक और उदाहरण : |% t* "ddd\:hh\:mm\:ss"for[TimeSpan].toString("ddd\:hh\:mm\:ss")
mazzy

खैर, यह सिर्फ उद्धरणों की बर्बादी है, फिर; आपको यहां उनकी आवश्यकता नहीं है :-)
जॉय


3

एक लूप में अगर-काउंटरों के स्थान पर बूलियन तर्क का उपयोग करें

मान लीजिए आप 1 से 10 तक सभी संख्याएँ जोड़ रहे हैं ... 2+4+6+8+10=30

1..10|%{if($_%2-eq0){$o+=$_}};$o

आप इसे छोटा करने के लिए बूलियन नकार का उपयोग कर सकते हैं

1..10|%{if(!($_%2)){$o+=$_}};$o

एक बाइट को बचाने के लिए, लेकिन इसके बजाय कैसे बूलियंस को चींटियों की अंतर्निहित कास्टिंग का उपयोग करें, और संचयकर्ता में सशर्त रोल करें

1..10|%{$o+=$_*!($_%2)};$o

इस उदाहरण में 6 बाइट्स बचाता है।


2
ईसा मसीह। मैं काम पर अपने उत्पादन कोड में ऐसा करने की योजना बना रहा हूं, मेरे सहयोगी मुझे इसके लिए प्यार करेंगे।
शावेज

3

PowerShell में पूर्णांकों के लिए फ़्लोटिंग-पॉइंट संख्याओं को परिवर्तित करना एक खदान का एक सा है। डिफ़ॉल्ट रूप से रूपांतरण बैंकर्स राउंडिंग करता है जो हमेशा दशमलव को ट्रिम नहीं करता है और छोटे पूरे नंबर को छोड़ देता है, या हमेशा राउंड .5 को अगले नंबर तक छोड़ देता है जैसे लोग लापरवाही से करते हैं, यह एक तरह से गोल हो जाता है और दूसरा रास्ता बनाता है - यह हो सकता है आश्चर्य की बात है, जैसे

PS C:\> [int]1.5
2

PS C:\> [int]2.5
2

और कोडगोल्फ गणनाओं को तोड़ें। कई अन्य सामान्य भाषाएं ट्रंकेशन-राउंडिंग करती हैं, इसलिए गोल्फ प्रश्नों में अक्सर ट्रंकेशन की आवश्यकता होती है। आप [Math]::Floor()अगली सबसे अच्छी चीज के रूप में पहुंच सकते हैं , लेकिन सावधान रहें यह केवल सकारात्मक संख्याओं के लिए छंटनी के समान है, लेकिन यह नकारात्मक संख्याओं को कम लेता है - शून्य से आगे। [Math]::Truncate()पीएस व्यवहार को अन्य भाषा की डिफ़ॉल्ट गोलाई के अनुरूप लाने की आवश्यकता है, लेकिन यह बहुत सारे वर्ण हैं।

दशमलव बिंदु के बाद अंकों को बदलने में मदद करने वाले Regex कुछ वर्णों को सहेज सकते हैं:

[Math]::Truncate(1.5)
[Math]::Floor(1.5)
1.5-replace'\..*'

[Math]::Truncate($a)
[Math]::Floor($a)
$a-replace'\..*'
$a.split('.')[0]        # literal character split, not regex pattern split

3

एक सरणी उलट

जहाँ बहुत कुछ फैशन में आउटपुट को प्रतिबिंबित किया जाता है, वहां बहुत सारी चुनौतियों का सामना करना पड़ता है।

मान लो तुम्हारे पास है

$a=1,2,3,4,5

पारंपरिक उत्क्रमण विधि लंबी, उबाऊ है, और तत्काल उपयोग के लिए पाइपलाइन पर सरणी नहीं छोड़ती है।

[array]::reverse($a)

सरणी में उल्टे क्रम में सीधे अनुक्रमण करना कुछ बाइट्स को बचाता है, क्योंकि यह पाइप लाइन पर परिणाम छोड़ता है, लेकिन अभी भी लंबा है:

$a[($a.count-1)..0]

इसके बजाय, एक पाश की कोशिश करो

$a|%{$a[-++$i]}

रिवर्स इंडेक्सिंग अच्छी तरह से काम करता है जब गिनती के लिए एक ऊपरी बाध्य होता है
जॉय

3

PowerShell Core 6 से शुरू करके, आप वर्णों के लिए श्रेणियों का उपयोग कर सकते हैं:

'a'..'z'

जो बहुत अधिक बोझिल की जगह ले सकता है

0..25|%{[char]($_+97)}

ओह, यह बहुत काम आने वाला है।
AdmBorkBork

1
[char[]](65..90)वर्णमाला उत्पन्न करने का एक आसान तरीका भी है
Veskah
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.