Які загальні поради щодо гольфу в Windows PowerShell? Я шукаю ідеї, які можна застосувати до проблем із гольфом загалом, які принаймні дещо специфічні для PowerShell (наприклад, "видалити коментарі" - це не відповідь). Будь ласка, опублікуйте одну пораду за кожну відповідь.

—Взявся майже дослівно від запитання Маркога .

Повноваження 10 літералістів з науковими позначеннями:

4e6 = 4000000

Повноваження 2 літералістів:

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

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

Може стати в нагоді.

Якщо вам потрібно запустити цикл, і ви точно знаєте , скільки разів його потрібно запускати кожен раз, розгляньте можливість прошивки масиву суміжних цілих чисел ForEach-Objectчерез %псевдонім замість використання for.

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

проти

1..10|%{...}

Ви можете пропустити Прогалини багато в PowerShell. Якщо вам здається, що це може не знадобитися, то, можливо, це не так. Це особливо корисно для порівнянь.

Приклад:

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

vs.

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

Якщо вам потрібно розгалужувати сценарій за результатами одного тесту, який може мати декілька результатів, switchіноді може відповідати або перемогти оператор if.

Приклад (перем. На if / else - прив'язати):

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

vs.

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

Або (перем. На if / elseif / else - перемикач виграє на 15):

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

vs.

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

Якщо перемикач насправді заснований на певних математичних результатах, як-от операція з модулем, описаною вище, ви можете повністю замінити перемикач на масив. Тут він економить ще 13 символів і навіть коротший, ніж оригінальний двоскарочний оператор if / else. (Спасибі Данко Дурбіч за цей шматочок.)

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

Якщо ви будете багато використовувати певну команду, особливо одну, без попереднього псевдоніма короткої руки, на початку встановіть псевдонім з одним символом.

Приклад:

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

vs.

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

Інкапсуляція команди, яка визначає змінну в круглих дужках, дозволяє подавати визначення змінної безпосередньо в інші команди.

Наприклад, ви можете встановити $ x, а потім встановити $ y, виходячи зі значення $ x в одному знімку за допомогою цього:

$y=($x=1)+1

Замість цього:

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

Ви можете встановити $ h і вивести його за допомогою цього:

($h='Hello World!')

Замість цього:

$h='Hello World!';$h

Комутатор може діяти як цикл, коли йому дано масив. Наприклад:

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

Виведе:

FOO
BAR
MEH

Я не зовсім впевнений, де це стане в нагоді, але сподіваюсь, що комусь це стане в нагоді деякий час.

Замініть [math]::powмноженням. Замість

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

можна писати

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

Це працює для цілих показників> = 0.

Оператори порівняння працюють над колекціями значень, повертаючи відповідні значення:

1..5 -gt 2

принесе 3, 4і 5. У деяких випадках це може допомогти зберегти інакше довше |?{$_...}.

-match є також оператором порівняння.

Використовуйте псевдоніми, коли це можливо. Є купа корисних:

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

Хочете знайти максимум або мінімум колекції значень? Спробував

(...|measure -ma).Maximum

або

(...|measure -mi).Minimum

вже?

Просто сортуйте та використовуйте останній чи перший елемент:

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

Скорочення імен властивостей

На жаль, на відміну від параметрів, властивості / методи (все, до чого звертається з крапкою .) зазвичай не можуть бути скорочені до однозначної форми.

Але деякі командлети можуть працювати на іменах властивостей та отримувати групові символи, і є маловідомі набори параметрів з %і ?які можуть бути корисні.

Зазвичай ми передаємо в блоці сценаріїв і посилаємося на елемент з $_, але є інша форма, яка має ім'я властивості, і він приймає підстановку.

$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оператор замінює регулярний вираз, але якщо ви просто робите заміну рядка, він може (тепер) коротше використовувати метод; це допомагає, що рядки є аргументами командлетів замість аргументів методу, тому їх не потрібно цитувати.

Де-Властивості об'єкта

?може також приймати (часткові) імена властивостей і застосовувати до нього "оператор" (у вигляді параметрів комутатора). Знову ж це може бути коротше , ніж при використанні стандартного Where-ObjectScriptBlock підходу , якщо ім'я властивості досить довго і унікальні.

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

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

Пошук суми довгим шляхом:

(...|measure -s).Sum

Коротший шлях:

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

І навіть коротше:

...-join'+'|iex

Точки з комою та перервами рядків взаємозамінні. Код для гольфу часто читається, якщо не застряг в одному рядку. А довжина все одно така ж (за умови використання U + 000A в якості розриву рядків, який PowerShell обробляє без проблем).

GetДієслово мається на увазі. Це може скоротити будь-якого Get-Frobдо справедливого Frob. Частими претендентами є dateабо random.

Зауважте, що в деяких випадках це не спрацює належним чином, оскільки у вас можуть бути утиліти GNU на своєму шляху (або інші рідні програми, які зіштовхуються). Порядок пошуку команд у такому випадку, здається, віддає перевагу нативній програмі, перш ніж розглядати командлети зі Get-видаленим:

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 петлі можуть містити в своєму заголовку що-небудь між 0 і трьома заявами:

Нескінченний цикл:

for(){}

Цикл з ініціалізацією:

for($n=0){}

Цикл з ініціалізацією та кінцевою умовою:

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

У таких випадках додаткові крапки з комою в кінці можуть бути опущені (це чітко зазначено в специфікації мови , тому це не детальна інформація про реалізацію) на відміну від С-подібних мов, які завжди вимагають рівно трьох висловлювань.

Це також робить whileтрохи коротшим. Порівняйте

while(...){}

і

for(;...){}

З додатковим бонусом, який ви можете вписати в попередньому рядку (якщо такий є), forтакож без додаткових витрат (і навіть збереження символу).

Якщо ви призначаєте масив, який, як відомо, буде мати лише два значення, не використовуйте індексацію.

Щось на зразок цього:

$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

Передавання на рядок:

[string]$x

vs.

"$x"

Передавання рядків подібним чином може також використовуватися для вирівнювання масиву рядків, а не приєднання до нього:

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

vs.

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

Передавання рядка до числового типу:

[int]$x     [float]$x

vs.

+$x

Також дуже корисно знати, що PowerShell завжди приймає тип лівого операнда для визначення остаточного типу виразу та перетворень, які слід застосувати:

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

що може допомогти визначити, де непотрібні ролі.

Не забувайте, що вам не завжди потрібно вказувати повне ім'я параметра, а деякі параметри є позиційними.

Get-Random -InputObject (0..10)

... можна обрізати ...

Get-Random -I (0..10)

... тому що "Я" в цьому випадку достатньо для однозначної ідентифікації InputObjectз інших дійсних параметрів для цієї команди.

Ви можете обрізати його далі ...

Get-Random (0..10)

... тому що InputObjectє позиційним параметром.

Трубопроводи зазвичай коротші, ніж подача об'єктів як параметр, особливо коли це може усунути потребу в дужках. Давайте обробимо наш генератор випадкових чисел далі ...

0..10|Get-Random

Також слідкуйте за іншими способами досягти того ж, навіть якщо ви не можете змінити команду. У наведеному вище випадку ви можете зробити це:

Get-Random 11

Або, включивши іншу пропозицію *:

Random 11

** Примітка. Відмова Get-від імені команди може збільшити час виконання приблизно на 50 000%. Непогано, якщо вам потрібна команда лише один раз, але будьте обережні, використовуючи її у довгих циклах. *

І ось як можна збити просту команду до третини свого розміру.

Підроблений потрійний оператор. Ви можете призначити прямо з ifзаяви:

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

Але ви можете використовувати 2-елементний масив і використовувати тест, щоб індексувати його. $ falsey результати отримують елемент 0, $ truthy результати беруть елемент 1:

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

NB. що це справді робить індексацію масиву, і якщо тест призведе до значення, яке може бути передано цілому числу, ви попросите елемент поза межами масиву і отримаєте $ null назад, і це потрібно буде зробити, !(test)щоб примусити киньте результат у булінг, при цьому параметри повернені.

Використовуючи число в якості аргументу для оператора, який інакше вимагатиме рядок, ви можете використовувати номер безпосередньо. Порівняйте

...-join'0'

vs.

...-join0

Працює -splitтакож. Аргумент завжди спочатку перетворюється на рядок.

Абсолютне значення

З

$n=-123

Замість

[math]::abs($n)

використання

$n-replace'-'

Звичайно, заощадження скасовуються, якщо потрібні дужки.

Якщо вам потрібно заглушити помилки, очевидним був би варіант

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

Однак це шлях занадто довгий. Більш короткий варіант - запустити tryблок як блок скриптів і просто перенаправити помилки в незмінену змінну ( $nullбуло б звичайною, але це все ще занадто довго):

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

Це економить п'ять цінних байтів (якщо не світ).

Використовуйте $ofs спеціальну змінну, щоб змінити епіратор виводу F ield S, який використовується під час строфікації масиву. Корисно, якщо вам потрібно кілька разів перетворити масиви в рядки.

Наприклад:

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

Зберігає 2+ n символів на другому -join, де n - довжина роздільника, і зберігає додаткові 5+ n для 3-го -joinта кожного наступного.

Автоматичні змінні має булеві для істинного і помилкового , як $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

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Аргумент може бути дано , щоб дозволити більш одного вибору.

Подумайте про збереження повторних блоків скриптів у змінних, замість використання функцій.

Я збирався використати це, щоб зберегти деякі символи в моїй реалізації Rock, Paper, Scissors, перш ніж зрозумів, що перезапис функції як змінної зробив навіть змінну непотрібною. Це все ще може бути корисно для інших сценаріїв, де ви фактично використовуєте один і той же код кілька разів.

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

vs.

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

Ви можете використовувати $s|% t*yзамість того, [char[]]$sщоб розділити рядок на масив char. Даний з відповіді TessellatingHeckler : % t*yрозширюється до | ForEach-Object -Method ToCharArrayеквівалента. з"$args".ToCharArray()

Наприклад, порівняйте

$s|% t*y

і

[char[]]$s

і

$s.ToCharArray()

Це корисно $argsособливо:$args|% t*y

Використовуйте логічну логіку замість лічильників if у циклі

Припустимо, ви додаєте всі парні числа від 1 до 10 ... 2+4+6+8+10=30

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

Ви можете використовувати булеве заперечення, щоб скоротити його

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

щоб зберегти байт, а як натомість використовувати неявну кастинг булевих форматів до ints та згортати умовне в акумулятор

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

Зберігає 6 байт у цьому прикладі.

Перетворення чисел з плаваючою комою в цілі числа в PowerShell - це трохи мінне поле. За замовчуванням конверсія робить " Округлення банкірів", яке не завжди обрізає десятковий і залишає менше ціле число, або завжди кругле .5 до наступного числа, як це роблять люди випадково; дивуватись, напр

PS C:\> [int]1.5
2

PS C:\> [int]2.5
2

і розбити розрахунки кодогольфа. Багато інших поширених мов виконують усічення, тому питання про гольф часто вимагають усічення. Ви можете досягти [Math]::Floor()наступної найкращої речі, але будьте обережні, вона поводиться так само, як усічення для позитивних чисел, але забирає негативні числа нижче - далі від нуля. [Math]::Truncate()це те, що вам потрібно, щоб привести поведінку PS у відповідність до округлення інших мов за замовчуванням, але це багато символів.

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

Зворотний масив

Корисно підходить для багатьох проблем мистецтва, де результат відображається певним чином.

Припустимо, у вас є

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

Традиційний метод розвороту довгий, нудний і не залишає масив на трубопроводі для негайного використання.

[array]::reverse($a)

Індексація безпосередньо в масив у зворотному порядку економить кілька байт, оскільки він залишає результати на конвеєрі, але все ще досить довгий:

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

Замість цього спробуйте цикл

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

Починаючи з PowerShell Core 6, ви також можете використовувати діапазони для символів:

'a'..'z'

що може замінити набагато громіздкіше

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