Quali suggerimenti generali hai per giocare a golf in Windows PowerShell? Sto cercando idee che possano essere applicate ai problemi del codice golf in generale, almeno in qualche modo specifiche per PowerShell (ad esempio "rimuovere i commenti" non è una risposta). Si prega di inviare un suggerimento per risposta.

- preso quasi alla lettera dalla domanda di Marcog .

Poteri di 10 letterali con notazione scientifica:

4e6 = 4000000

Poteri di 2 letterali:

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

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

Potrebbe tornare utile.

Se è necessario eseguire un ciclo e si sa esattamente quante volte deve essere eseguito ogni volta, prendere in considerazione il piping di una matrice di numeri interi contigui ForEach-Objecttramite l' %alias invece di utilizzare for.

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

vs

1..10|%{...}

È possibile saltare spazi molto in PowerShell. Se sembra che potrebbe non essere necessario, molto probabilmente non lo è. Ciò è particolarmente utile nei confronti.

Esempio:

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

vs.

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

Se devi ramificare lo script in base al risultato di un singolo test che può avere più risultati, a switchvolte può abbinare o battere un'istruzione if.

Esempio (switch vs. if / else - tie):

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

vs.

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

Oppure (switch vs. if / elseif / else - switch vince per 15):

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

vs.

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

Se lo switch si basa effettivamente su determinati risultati matematici, come l'operazione modulo sopra, è possibile sostituirlo completamente con un array. Qui, salva altri 13 caratteri ed è persino più breve dell'istruzione if / else originale a due opzioni. (Grazie a Danko Durbic per questo pezzo.)

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

Se utilizzerai molto un determinato comando, in particolare uno senza un alias abbreviato preesistente, imposta un alias a carattere singolo all'inizio.

Esempio:

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

vs.

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

Incapsulare il comando che definisce una variabile tra parentesi consente di alimentare la definizione della variabile direttamente ad altri comandi.

Ad esempio, puoi impostare $ x e quindi impostare $ y in base al valore di $ x in un colpo solo con questo:

$y=($x=1)+1

Invece di questo:

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

È possibile impostare $ h e inviarlo con questo:

($h='Hello World!')

Invece di questo:

$h='Hello World!';$h

Un interruttore può agire come un ciclo, quando viene fornito un array. Per esempio:

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

Uscita:

FOO
BAR
MEH

Non sono del tutto sicuro di dove questo sarà utile, ma mi aspetto che sarà utile per qualcuno qualche volta.

Sostituisci [math]::powcon moltiplicazione. Invece di

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

tu puoi scrivere

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

Funziona con esponenti interi> = 0.

Gli operatori di confronto lavorano su raccolte di valori restituendo valori corrispondenti:

1..5 -gt 2

cederà 3, 4e 5. In alcuni casi questo può aiutare a risparmiare un tempo più lungo |?{$_...}.

-match è anche un operatore di confronto.

Usa gli alias quando possibile. Ce ne sono molti utili:

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

Vuoi trovare il massimo o il minimo di una raccolta di valori? Provato

(...|measure -ma).Maximum

o

(...|measure -mi).Minimum

già?

Basta ordinare e utilizzare l'ultimo o il primo elemento:

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

Accorciamento dei nomi delle proprietà

Purtroppo, diversamente dai parametri, le proprietà / i metodi (qualsiasi cosa a cui si accede con un punto .) non possono in genere essere abbreviati nella sua forma non ambigua.

Tuttavia, alcuni cmdlet possono operare su nomi di proprietà e accettare caratteri jolly e esistono insiemi di parametri poco noti di %e ?che possono essere utili.

Di solito passiamo in uno scriptblock e ci riferiamo all'elemento con $_, ma c'è un'altra forma di questi che prende un nome di proprietà e accetta un carattere jolly.

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

Con una proprietà come .Lengthquesta non possiamo usare la magia v3 che normalmente funzionerebbe su un array perché Lengthè una proprietà dell'array stesso, quindi i due precedenti potrebbero essere usati per ottenere le lunghezze dei singoli membri. La selectarriva in un po 'più breve.

Ma %può prendere direttamente un nome di proprietà e restituire quel valore:

$a|% Length

Che può essere abbreviato con caratteri jolly. Il carattere jolly deve essere risolto in una singola proprietà (o metodo, ne parleremo più avanti), quindi genererà un errore utile in caso contrario, indicando esattamente a quali membri potrebbe risolvere.

Nel caso di Length, Le*è in genere il più breve. Anche su una singola stringa, questo metodo è più corto di 1 byte rispetto all'uso della proprietà.

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

Ma a seconda di cosa stai facendo, questo può essere peggio. Puoi farlo $a.Length*5ma per farlo con l'espressione della pipeline dovresti avvolgerlo ($a|% Le*)*5; potrebbe comunque valerne la pena se è contro un array, ma il punto è che non è sempre appropriato come sostituzione diretta.

Funziona anche con i metodi e puoi tralasciare quello ()che rende un nome completo della stessa lunghezza, ma la stessa restrizione di cui sopra a volte a doverlo avvolgere. Il metodo deve avere un sovraccarico che non accetta parametri (è possibile passare argomenti posizionandoli dopo il nome del metodo, il che è davvero bello):

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

Con argomenti:

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

Questi non sono esattamente gli stessi in quanto l' -replaceoperatore esegue una sostituzione regex, ma se si sta semplicemente eseguendo una sostituzione di stringa, può (ora) essere più breve per utilizzare il metodo; aiuta che le stringhe siano argomenti del cmdlet anziché argomenti del metodo, quindi non è necessario che siano citate.

Proprietà Where-Object

?può anche prendere nomi di proprietà (parziali) e applicarvi un "operatore" (sotto forma di parametri switch). Anche in questo caso può essere più breve rispetto all'uso dell'approccio Where-Objectscriptblock standard se il nome della proprietà è sufficientemente lungo e univoco.

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

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

Trovare una somma a lungo termine:

(...|measure -s).Sum

Un modo più breve:

...|%{$s+=$_};$s

E ancora più breve:

...-join'+'|iex

I punti e virgola e le interruzioni di riga sono intercambiabili. Il codice golfizzato è spesso più leggibile se non bloccato in una singola riga. E la lunghezza è sempre la stessa (a condizione che tu usi U + 000A come interruzione di linea che PowerShell gestisce senza problemi).

Il Getverbo è implicito. Questo può ridurre qualsiasi Get-Froba poco Frob. I contendenti frequenti sono dateo random.

Nota che questo non funzionerà correttamente in alcuni casi perché potresti avere utilità GNU nel tuo percorso (o altri programmi nativi che si scontrano). La ricerca dell'ordine dei comandi in quel caso sembra preferire il programma nativo prima di considerare i cmdlet con il Get-rimosso:

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

for i loop possono avere qualcosa tra 0 e tre istruzioni nella loro intestazione:

Ciclo infinito:

for(){}

Loop con inizializzazione:

for($n=0){}

Ciclo con inizializzazione e condizione finale:

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

In questi casi i punti e virgola aggiuntivi alla fine possono essere omessi (è esplicitamente indicato nelle specifiche del linguaggio , quindi non è un dettaglio di implementazione) in contrasto con i linguaggi di tipo C che richiedono sempre esattamente tre istruzioni.

Questo rende anche whileun po 'più breve. Confrontare

while(...){}

e

for(;...){}

Con il bonus aggiunto che puoi inserire in una riga precedente (se ce n'è una) anche nel forcosto senza costi aggiuntivi (e persino salvando un personaggio).

Se stai assegnando un array che sai avrà solo due valori, non utilizzare l'indicizzazione.

Qualcosa come questo:

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

Può essere facilmente trasformato in questo:

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

Questo può essere utile anche se hai solo bisogno del primo elemento di un array:

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

Casting su stringa:

[string]$x

vs.

"$x"

Il cast su una stringa come questa può anche essere usato per appiattire una matrice di stringhe, invece di unirla:

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

vs.

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

Trasmissione di una stringa a un tipo numerico:

[int]$x     [float]$x

vs.

+$x

Molto utile anche sapere che PowerShell prende sempre il tipo di operando di sinistra per determinare il tipo finale di un'espressione e le conversioni da applicare:

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

che può aiutare a determinare dove sono i cast inutili.

Non dimenticare che non è sempre necessario fornire il nome completo di un parametro e alcuni parametri sono posizionali.

Get-Random -InputObject (0..10)

... può essere tagliato in ...

Get-Random -I (0..10)

... perché "I", in questo caso, è sufficiente per identificarsi in modo univoco InputObjectdagli altri parametri validi per questo comando.

Potresti tagliarlo ulteriormente per ...

Get-Random (0..10)

... perché InputObjectè un parametro posizionale.

Le tubazioni sono generalmente più brevi rispetto all'alimentazione di oggetti come parametro, soprattutto quando possono rimuovere la necessità di parentesi. Tagliamo ulteriormente il nostro generatore di numeri casuali ...

0..10|Get-Random

Cerca anche altri modi per ottenere lo stesso risultato, anche se non puoi modificare il comando. Per il caso precedente, potresti fare questo:

Get-Random 11

Oppure, incorporando un altro suggerimento *:

Random 11

** Nota: l'omissione Get-dal nome di un comando può gonfiare il tempo di esecuzione di circa il 50.000%. Non male se hai solo bisogno del comando una volta, ma fai attenzione ad usarlo in cicli lunghi. *

Ed è così che può abbattere un semplice comando fino a un terzo della sua dimensione.

Operatore ternario falso. Puoi assegnare direttamente da ifun'istruzione:

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

Ma puoi usare un array a 2 elementi e usare il test per indicizzarlo. I risultati di $ falsey ottengono l'elemento 0, i risultati di $ truey prendono l'elemento 1:

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

NB. che questo sta realmente facendo l'indicizzazione dell'array, e se il test risulta in un valore che può essere lanciato su un numero intero, chiederai un oggetto al di fuori dei limiti dell'array e otterrai $ null indietro, e dovrai farlo !(test)per forzare getti il ​​risultato in un bool, con le opzioni invertite.

Quando si utilizza un numero come argomento per un operatore che altrimenti richiederebbe una stringa, è possibile utilizzare direttamente il numero. Confrontare

...-join'0'

vs.

...-join0

Funziona anche con -split. L'argomento viene sempre convertito prima in una stringa.

Valore assoluto

Con

$n=-123

Invece di

[math]::abs($n)

uso

$n-replace'-'

Naturalmente, i risparmi vengono annullati se sono necessarie le parentesi.

Se hai bisogno di mettere a tacere gli errori, la variante ovvia sarebbe

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

Tuttavia, questo è troppo lungo. Una variante più breve consiste trynell'eseguire il blocco come blocco di script e reindirizzare gli errori in una variabile non impostata ( $nullsarebbe la solita, ma è ancora troppo lunga):

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

Ciò consente di risparmiare cinque byte preziosi (se non il mondo).

Utilizzare la $ofs variabile speciale per modificare l' O scita F ield S eparator utilizzato quando stringifying un array. Utile se hai bisogno di trasformare più volte array in stringhe.

Per esempio:

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

Salva 2+ n caratteri nel 2 ° -join, dove n è la lunghezza del separatore e salva altri 5+ n per il 3 ° -joine ciascuno in seguito.

Le variabili automatiche hanno valori booleani di Vero e Falso come $truee $falsema è possibile ottenere risultati simili utilizzando l'operatore non logico !e gli interi 0 e 1 (o qualsiasi numero intero diverso da zero).

PS C:\Users\matt> !1
False

PS C:\Users\matt> !0
True

Quasi tutte le espressioni di PowerShell possono essere valutate come booleane. Quindi, fintanto che sei consapevole di come vengono valutati determinati dati, puoi ottenere booleani e non devi mai lanciarli esplicitamente. Prestare attenzione al valore LHS durante queste operazioni.

• Il numero intero 0 è falso e i numeri interi diversi da zero vengono valutati su vero.
• le stringhe di lunghezza diversa da zero sono vere e vuote o le stringhe nulle (e gli stessi null) sono false.

Ci sono altri esempi ma puoi facilmente provare facendo un cast

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

Invoke-Expressione Get-Randompuò anche ottenere input dalla pipeline anziché argomenti.

Per iexquesto consente di salvare le parentesi su alcune espressioni:

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

In questo caso randomconsente di ottimizzare un po 'un caso comune:

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

L'ultimo modo di usarlo seleziona semplicemente un elemento da un elenco. L' -cargomento può essere dato per consentire più di una singola selezione.

Prendi in considerazione l'archiviazione di blocchi di script ripetuti in variabili, anziché utilizzare le funzioni.

Stavo per usarlo per salvare alcuni personaggi nella mia implementazione Rock, Paper, Scissors prima di rendermi conto che riscrivere la funzione come variabile rendeva superflua anche la variabile. Questo potrebbe essere comunque utile per altri script, dove in realtà stai eseguendo lo stesso codice più volte.

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

vs.

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

È possibile utilizzare $s|% t*yinvece [char[]]$sper dividere una stringa in array di caratteri. Dato dalla risposta di TessellatingHeckler : si % t*yespande in | ForEach-Object -Method ToCharArrayequiv. di"$args".ToCharArray()

Ad esempio, confronta

$s|% t*y

e

[char[]]$s

e

$s.ToCharArray()

È utile $argssoprattutto:$args|% t*y

Usa la logica booleana al posto degli if-counter in un loop

Supponiamo di aggiungere tutti i numeri pari da 1 a 10 ... 2+4+6+8+10=30

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

È possibile utilizzare la negazione booleana per accorciarla

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

per salvare un byte, ma che ne dici invece di usare il cast implicito di booleani in ints e di arrotolare il condizionale nell'accumulatore

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

Salva 6 byte in questo esempio.

La conversione di numeri in virgola mobile in numeri interi in PowerShell è un po 'un campo minato. Per impostazione predefinita, la conversione fa l' arrotondamento dei banchieri, che non sempre taglia il decimale e lascia il numero intero più piccolo, o sempre arrotondato .5 fino al numero successivo come fanno le persone casualmente, arrotondando le pari in un modo e le probabilità in un altro - questo può essere sorprendente, ad es

PS C:\> [int]1.5
2

PS C:\> [int]2.5
2

e rompere i calcoli di codegolf. Molte altre lingue comuni eseguono arrotondamenti per troncamento, quindi le domande sul golf spesso richiedono troncamento. Potresti cercare [Math]::Floor()la prossima cosa migliore, ma attenzione, questo si comporta solo come il troncamento per i numeri positivi, ma prende i numeri negativi più in basso - più lontano da zero. [Math]::Truncate()è ciò di cui hai bisogno per allineare il comportamento di PS con l'arrotondamento predefinito di un'altra lingua, ma sono molti i personaggi.

Regex che sostituisce le cifre dopo il punto decimale può aiutare a salvare un paio di caratteri:

[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

Invertire una matrice

È utile in molte sfide di arte ascii in cui l'output si riflette in qualche modo.

Supponi di avere

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

Il metodo di inversione tradizionale è lungo, noioso e non lascia l'array sulla pipeline per un utilizzo immediato.

[array]::reverse($a)

L'indicizzazione diretta nell'array in ordine inverso consente di risparmiare alcuni byte, poiché lascia i risultati sulla pipeline, ma è ancora piuttosto lunga:

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

Invece, prova un loop

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

A partire da PowerShell Core 6, puoi anche usare intervalli per i personaggi:

'a'..'z'

che può sostituire il molto più ingombrante

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