Какие общие советы у вас есть для игры в гольф в 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

против

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

Если вам нужно разветвить свой сценарий на основе результатов одного теста, который может иметь несколько результатов, switchиногда можно сопоставить или превзойти оператор if.

Пример (переключатель против if / else - tie):

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

против

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

Или (переключение против if / elseif / else - переключение выигрывает на 15):

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

против

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

против

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-Objectподхода к блоку сценариев, если имя свойства достаточно длинное и уникальное.

$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 до 3 операторов в заголовке:

Бесконечный цикл:

for(){}

Цикл с инициализацией:

for($n=0){}

Цикл с инициализацией и конечным условием:

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

В таких случаях дополнительные точки с запятой в конце могут быть опущены (это явно указано в спецификации языка , поэтому это не детали реализации) в отличие от языков, подобных C, которые всегда требуют ровно три оператора.

Это также делает 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

против

"$x"

Приведение к строке также можно использовать для выравнивания массива строк, вместо того, чтобы присоединять его:

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

против

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

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

[int]$x     [float]$x

против

+$x

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

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

который может помочь определить, где ненужные броски.

Не забывайте, что вам не всегда нужно указывать полное имя параметра, а некоторые параметры являются позиционными.

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%. Неплохо, если вам нужна команда только один раз, но будьте осторожны при ее использовании в длинных циклах. *

И вот как можно сбить простую команду до трети ее размера.

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

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

Но вы можете использовать 2-элементный массив и использовать тест для индексации в нем. Результаты $ falsey получают элемент 0, результаты $ truey принимают элемент 1:

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

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

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

...-join'0'

против

...-join0

Работает -splitтакже. Аргумент всегда сначала преобразуется в строку.

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

С

$n=-123

Вместо того

[math]::abs($n)

использование

$n-replace'-'

Конечно, сбережения отменяются, если нужны скобки.

Если вам нужно замолчать ошибки, очевидным вариантом будет

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

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

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

Это экономит пять ценных байтов (если не мир).

Используйте $ofs специальную переменную для изменения вывода utput F IELD S eparator используется , когда stringifying массив. Полезно, если вам нужно преобразовывать массивы в строки несколько раз.

Например:

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

Сохраняет 2+ n символов на втором -join, где n - длина разделителя, и сохраняет дополнительные 5+ n для третьего -joinи каждого последующего.

Автоматические переменные имеет булевы для истинного и ложного , как $trueи $falseно вы можете получить аналогичные результаты с использованием логического оператора не !и целых чисел 0 и 1 (или любое ненулевого числа.)

PS C:\Users\matt> !1
False

PS C:\Users\matt> !0
True

Почти все выражения PowerShell могут быть оценены как логические. Поэтому, если вы знаете, как оцениваются определенные данные, вы можете получить логические значения и вам никогда не потребуется явно приводить их. Помните о значении LHS при этом.

• Целое число 0 является ложным, а ненулевые целые числа оцениваются как истинные.
• строки ненулевой длины имеют значение true, а пустые или нулевые (и сами значения null) - false.

Есть и другие примеры, но вы можете легко проверить, выполнив приведение

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

против

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

$s|% t*yВместо этого вы можете использовать [char[]]$sдля разделения строки на массив символов. Исходя из ответа Тесселлатинга Хеклера : % 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

чтобы сохранить байт, но как же вместо этого использовать неявное приведение логических значений к целым, и бросить условное в аккумулятор

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

Сохраняет 6 байтов в этом примере.

Преобразование чисел с плавающей запятой в целые числа в PowerShell является чем-то вроде минного поля. По умолчанию при конвертации выполняется округление Bankers, которое не всегда обрезает десятичную дробь и оставляет меньшее целое число, или всегда округляет .5 до следующего числа, как это делают люди случайно, оно округляет четные в одну сторону и увеличивает коэффициент в другую - это может быть удивительным, например

PS C:\> [int]1.5
2

PS C:\> [int]2.5
2

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

Замена регулярных выражений после десятичной точки может помочь сохранить пару символов:

[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

Реверсивный массив

Пригодится во многих задачах ascii-art, где результат отражается каким-то образом.

Предположим, у вас есть

$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)}