Какой лучший (более чистый) способ игнорировать вывод в PowerShell?

Я только что провел несколько тестов четырех известных мне вариантов.

Measure-Command {$(1..1000) | Out-Null}

TotalMilliseconds : 76.211

Measure-Command {[Void]$(1..1000)}

TotalMilliseconds : 0.217

Measure-Command {$(1..1000) > $null}

TotalMilliseconds : 0.2478

Measure-Command {$null = $(1..1000)}

TotalMilliseconds : 0.2122

## Control, times vary from 0.21 to 0.24
Measure-Command {$(1..1000)}

TotalMilliseconds : 0.2141

Поэтому я бы посоветовал вам использовать что угодно, кроме Out-Null из-за накладных расходов. Следующим важным моментом для меня будет удобочитаемость. Мне нравится перенаправлять на $null и самому устанавливать значение $null. Я предпочитаю преобразование в [Void], но это может быть не так понятно при взгляде на код или для новых пользователей.

Думаю, я предпочитаю перенаправлять вывод на $null.

Do-Something > $null

Изменить

После очередного комментария Стей я решил провести еще несколько тестов с конвейерами, чтобы лучше изолировать накладные расходы, связанные с удалением вывода.

Вот несколько тестов с простым конвейером из 1000 объектов.

## Control Pipeline
Measure-Command {$(1..1000) | ?{$_ -is [int]}}

TotalMilliseconds : 119.3823

## Out-Null
Measure-Command {$(1..1000) | ?{$_ -is [int]} | Out-Null}

TotalMilliseconds : 190.2193

## Redirect to $null
Measure-Command {$(1..1000) | ?{$_ -is [int]} > $null}

TotalMilliseconds : 119.7923

В этом случае для Out-Null накладные расходы составляют около 60%, а для > $null - около 0,3%.

Приложение 2017-10-16: я изначально упустил из виду другой вариант с Out-Null, использование параметра -inputObject. Используя это, кажется, что накладные расходы исчезают, однако синтаксис отличается:

Out-Null -inputObject ($(1..1000) | ?{$_ -is [int]})

А теперь несколько тестов с простым конвейером из 100 объектов.

## Control Pipeline
Measure-Command {$(1..100) | ?{$_ -is [int]}}

TotalMilliseconds : 12.3566

## Out-Null
Measure-Command {$(1..100) | ?{$_ -is [int]} | Out-Null}

TotalMilliseconds : 19.7357

## Redirect to $null
Measure-Command {$(1..1000) | ?{$_ -is [int]} > $null}

TotalMilliseconds : 12.8527

Здесь снова Out-Null накладные расходы составляют около 60%. В то время как > $null имеет накладные расходы около 4%. Цифры здесь немного менялись от теста к тесту (я пробегал каждый примерно 5 раз и выбирал золотую середину). Но я думаю, что это явная причина не использовать Out-Null.

Я понимаю, что это старый поток, но для тех, кто принимает принятый ответ @JasonMArcher выше как факт, я удивлен, что он не был исправлен, многие из нас знали в течение многих лет, что на самом деле ТРУБОПРОВОД добавляет задержку и НИЧЕГО не связано с тем, это Out-Null или нет. Фактически, если вы запустите приведенные ниже тесты, вы быстро увидите, что те же самые «более быстрые» преобразования в [void] и $ void =, которые мы все годами использовали, думая, что это было быстрее, на самом деле ПРОСТО КАК МЕДЛЕННО и на самом деле ОЧЕНЬ МЕДЛЕННО, когда вы добавляете ЛЮБУЮ конвейерную обработку вообще. Другими словами, как только вы перейдете к чему-либо, все правило отказа от использования out-null отправляется в корзину.

Доказательство, последние 3 теста в списке ниже. Ужасный Out-null был 32339,3792 миллисекунды, но подождите - насколько быстрее было приведение к [void]? 34121.9251 мс?!? Какого черта? Это НАСТОЯЩИЕ # в моей системе, преобразование в VOID было на самом деле МЕДЛЕННЫМ. Как насчет = $ null? 34217,685 мс ..... все еще чертовски МЕДЛЕЕ! Итак, как показывают последние три простых теста, Out-Null на самом деле БЫСТРЕЕ во многих случаях, когда конвейер уже используется.

Итак, почему это? Простой. Это было и всегда было 100% галлюцинацией, что переход к Out-Null был медленнее. Однако работа по ТРУБОПРОВОДУ К чему-либо происходит медленнее, и разве мы не знали об этом с помощью базовой логики? Возможно, мы просто не знали НАМНОГО медленнее, но эти тесты наверняка расскажут о стоимости использования конвейера, если вы можете этого избежать. И мы не ошибались на 100%, потому что существует очень МАЛЕНЬКОЕ количество истинных сценариев, в которых out-null является злом. Когда? При добавлении Out-Null добавляется ТОЛЬКО действие конвейера. Другими словами .... причина в простой команде типа $ (1..1000) | Out-Null, как показано выше, показал истину.

Если вы просто добавите дополнительный канал к Out-String к каждому тесту выше, #s радикально изменятся (или просто вставите те, которые ниже), и, как вы сами можете видеть, Out-Null во многих случаях фактически становится БЫСТРЕЕ:

$GetProcess = Get-Process

# Batch 1 - Test 1 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$GetProcess | Out-Null 
} 
}).TotalMilliseconds

# Batch 1 - Test 2 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
[void]($GetProcess) 
} 
}).TotalMilliseconds

# Batch 1 - Test 3 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$null = $GetProcess 
} 
}).TotalMilliseconds

# Batch 2 - Test 1 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$GetProcess | Select-Object -Property ProcessName | Out-Null 
} 
}).TotalMilliseconds

# Batch 2 - Test 2 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
[void]($GetProcess | Select-Object -Property ProcessName ) 
} 
}).TotalMilliseconds

# Batch 2 - Test 3 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$null = $GetProcess | Select-Object -Property ProcessName 
} 
}).TotalMilliseconds

# Batch 3 - Test 1 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$GetProcess | Select-Object -Property Handles, NPM, PM, WS, VM, CPU, Id, SI, Name | Out-Null 
} 
}).TotalMilliseconds

# Batch 3 - Test 2 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
[void]($GetProcess | Select-Object -Property Handles, NPM, PM, WS, VM, CPU, Id, SI, Name ) 
} 
}).TotalMilliseconds

# Batch 3 - Test 3 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$null = $GetProcess | Select-Object -Property Handles, NPM, PM, WS, VM, CPU, Id, SI, Name 
} 
}).TotalMilliseconds

# Batch 4 - Test 1 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$GetProcess | Out-String | Out-Null 
} 
}).TotalMilliseconds

# Batch 4 - Test 2 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
[void]($GetProcess | Out-String ) 
} 
}).TotalMilliseconds

# Batch 4 - Test 3 
(Measure-Command { 
for ($i = 1; $i -lt 99; $i++) 
{ 
$null = $GetProcess | Out-String 
} 
}).TotalMilliseconds

Также существует командлет Out-Null, который можно использовать в конвейере , например, Add-Item | Out-Null.

Страница руководства для Out-Null

NAME
    Out-Null

SYNOPSIS
    Deletes output instead of sending it to the console.


SYNTAX
    Out-Null [-inputObject <psobject>] [<CommonParameters>]


DETAILED DESCRIPTION
    The Out-Null cmdlet sends output to NULL, in effect, deleting it.


RELATED LINKS
    Out-Printer
    Out-Host
    Out-File
    Out-String
    Out-Default

REMARKS
     For more information, type: "get-help Out-Null -detailed".
     For technical information, type: "get-help Out-Null -full".

Я бы подумал об использовании чего-то вроде:

function GetList
{
  . {
     $a = new-object Collections.ArrayList
     $a.Add(5)
     $a.Add('next 5')
  } | Out-Null
  $a
}
$x = GetList

Выходные данные из $a.Add не возвращаются - это справедливо для всех вызовов $a.Add методов. В противном случае вам нужно будет добавлять [void] перед каждым вызовом.

В простых случаях я бы пошел с [void]$a.Add, потому что совершенно ясно, что вывод не будет использоваться и будет отброшен.

Лично я использую ... | Out-Null, потому что, как отмечали другие, это выглядит более «PowerShellish» по сравнению с ... > $null и [void] .... $null = ... использует определенную автоматическую переменную и может быть легко не заметить, в то время как другие методы делают очевидным с дополнительным синтаксисом, что вы намереваетесь отбросить вывод выражения. Поскольку ... | Out-Null и ... > $null стоят в конце выражения, я думаю, что они эффективно сообщают: «возьмите все, что мы сделали до этого момента, и выбросьте его», плюс вы можете проще комментировать их для целей отладки (например, ... # | Out-Null) по сравнению с помещая $null = или [void] перед выражением, чтобы определить, что произойдет после его выполнения.

Однако давайте посмотрим на другой тест: не количество времени, которое требуется для выполнения каждого варианта, а количество времени, которое требуется, чтобы выяснить, что делает каждый вариант. Работая в среде с коллегами, которые не имели опыта работы с PowerShell или даже со сценариями, я стараюсь писать свои сценарии таким образом, чтобы кто-то, кто придет через несколько лет и даже не понимает язык, на который они смотрят, может иметь имеют шанс выяснить, что он делает, поскольку они могут быть в состоянии поддержать или заменить его. Мне никогда не приходило в голову, что это причина использовать один метод вместо других, но представьте, что вы находитесь в таком положении и используете команду help или свою любимую поисковую систему, чтобы попытаться выяснить, что делает Out-Null. Вы же сразу получаете полезный результат? Теперь попробуйте проделать то же самое с [void] и $null =. Не так-то просто, правда?

Конечно, подавление вывода значения - это довольно незначительная деталь по сравнению с пониманием общей логики скрипта, и вы можете только попытаться «упростить» свой код, прежде чем торговать своей способностью писать хороший код для способность новичка читать ... не очень хороший код. Я хочу сказать, что возможно, что некоторые, кто свободно владеет PowerShell, даже не знакомы с [void], $null = и т. Д., И то, что они могут выполняться быстрее или требовать меньшего количества нажатий клавиш для ввода, не означает, что они являются лучшим способом делать то, что вы пытаетесь сделать, и то, что язык дает вам необычный синтаксис, не означает, что вы должны использовать его вместо чего-то более ясного и известного. ^*

^* Я предполагаю, что Out-Null ясно и хорошо известно, а я не знаю, что это $true. Какой бы вариант вы ни считали наиболее понятным и доступным для будущих читателей и редакторов вашего кода (включая вас самих), независимо от времени набора или выполнения, я рекомендую именно этот вариант. ты используешь.