Объекты без свойства '.Count' - использование @ () (оператор подвыражения массива) по сравнению с приведением [Array]

В PSv3 + с унифицированной обработкой скаляров и коллекций любой объект - даже $null - должен иметь свойство .Count (и, за исключением of $null, должен поддерживать индексацию с [0]).

Любое появление объекта, не поддерживающего вышеуказанное, следует рассматривать как ошибку; например:

• Использование этого встроенного (поставляется с движком) < strong> .Count свойство неожиданно выходит из строя, когда Set-StrictMode -Version 2 или выше, что является давней ошибкой, о которой сообщалось в проблема GitHub № 2798, все еще присутствующая в PowerShell 7.2 (тогда как свойство родного типа .Count, например, в массиве, может безопасно быть доступ).

• ([pscustomobject] экземпляры, не воспроизводящиеся по этим правилам, были известной ошибкой, исправлено в 2017 г.).

Поскольку я не знаю, связана ли указанная ошибка с экземплярами [Microsoft.Management.Infrastructure.CimInstance#ROOT/Microsoft/Windows/Storage/MSFT_Disk], которые выводятся Get-Disk, и поскольку Get-Disk - по крайней мере в настоящее время - доступен только в Windows PowerShell, я рекомендую вам сообщить об отдельной ошибке uservoice.com.

Использование оператора подвыражения массива @(...) только необходимо:

• в качестве обходного пути для обнаруженной ошибки / ошибки Set-StrictMode -Version 2.

• в случае, если у скалярного объекта есть свое собственное .Count свойство.

Как правило, если вам нужно убедиться, что что-то является массивом, используйте @(...), а не [Array] ... / [object[]] ... - @() - это идиоматический, более краткий и синтаксически простой в стиле PowerShell.

^{Тем не менее, учитывая, что @() технически создает (неглубокую) копию существующего массива, вы можете предпочесть [Array] при работе с потенциально большими массивами.}

Кроме того, @(...) и [Array] ... в целом не эквивалентны, поскольку PetSerAl Полезные примеры в комментарии к вопросу демонстрируют; чтобы адаптировать один из его примеров:

@($null) возвращает массив с одним элементом, единственным элементом которого является $null, тогда как [Array] $null не имеет никакого эффекта (остается $null).

Такое поведение @() согласуется с его назначением (см. Ниже): поскольку $null не является массивом, @() оборачивает его в один (в результате получается экземпляр [System.Object[]] с $null в качестве единственного элемента).

В других примерах PetSerAl поведение @() с New-Object созданными массивами и коллекциями - может быть удивительным - см. Ниже.

Назначение @(...) и принцип его работы:

цель @(), оператор подвыражения массива, грубо говоря, чтобы гарантировать, что результат выражения / команды обрабатывается как массив , даже если это скаляр (отдельный объект) .:

• @(...) собирает закрытые выходные команды как есть / закрытые выражения перечисленные выходные данные в - < em> всегда новый - [object[]] массив, даже если имеется только единственный объект вывода.

• @(...) никогда не нужен для литералов (в v5.1 + он оптимизирован), но он полезен в двух случаях:

  • для создания пустого массива: @()

  • для синтаксического удобства: распространить то, что концептуально является литералом массива, на несколько строк без необходимости использовать , для разделения элементов и без необходимости заключать команды в (...); например.:

    @(
      'one'
      Write-Output two
    )
    

• Подводные камни:

  • @() не является конструктором массива, а является гарантом: поэтому @(@(1,2)) не создает вложенный массив:

    • @(@(1, 2)) is effectively the same as @(1, 2) (and just 1, 2). In fact, each additional @() is an expensive no-op, because it simply creates a copy of the array output by the previous one.
    • Используйте унарную форму , оператор конструктора массива для создания вложенных массивов:
      , (1, 2)

  • $null рассматривается @() как отдельный объект, поэтому в результате получается одноэлементный массив с элементом $null:

    • @($null).Count is 1

  • Вызовы Command, которые выводят единый массив в целом, приводят к вложенному массиву:

    • @(Write-Output -NoEnumerate 1, 2).Count is 1

  • В выражении упаковка коллекции любого типа в @() перечисляет и неизменно собирает элементы в (новом) [object[]] array:

    • @([System.Collections.ArrayList] (1, 2)).GetType().Name returns 'Object[]'

При необходимости читайте более подробную информацию.

Подробности:

@() ведет себя следующим образом: ^{Совет шляпы PetSerAl за его обширную помощь.}

• В PSv5.1 + (Windows PowerShell 5.1 и PowerShell [Core] 6+) с использованием выражения, которое напрямую создает массив с использованием ,, оператор массива конструктор, оптимизирует @() прочь:

  • Например, @(1, 2) то же самое, что просто 1, 2, а @(, 1) то же самое, что просто , 1.

  • В случае массива, построенного с использованием только ,, что дает массив System.Object[], эта оптимизация полезна, поскольку избавляет от ненужного шага сначала развернуть этот массив, а затем переупаковать его (см. Ниже). < br /> Предположительно, эта оптимизация была вызвана широко распространенной и ранее неэффективной практикой использования @( ..., ..., ...) для построения массивов, проистекающей из ошибочного убеждения, что @() необходим для создания массива.

  • Однако в Windows PowerShell v5.1 только, оптимизация неожиданно также применяется при построении массива с конкретным type с использованием приведения, например [int[]] (поведение было исправлено в PowerShell [Core] 6+ и более ранних версиях Windows PowerShell не < / em> затронуты); например,
    @([int[]] (1, 2)).GetType().Name дает Int32[]. Это единственная ситуация, в которой @() возвращает что-то другое, кроме System.Object[], и предположение, что это всегда так, может привести к неожиданным ошибкам и побочным эффектам; например:
    @([int[]] (1, 2))[-1] = 'foo' breaks.
    $a = [int[]] (1, 2); $b = @([int[]] $a) неожиданно не создает новый массив - см. эта проблема GitHub.

• В противном случае: если (первая) инструкция внутри @(...) является выражением, которое оказывается коллекцией, эта коллекция перечисляется ; выходные данные команды (обычно потоковое по очереди) собираются как есть; в любом случае результирующее количество объектов определяет поведение:

  • Если результатом является одиночный элемент / не содержит никаких элементов, результат будет заключен в одноэлементный / пустой массив типа [System.Object[]].

    • Например, @('foo').GetType().Name дает Object[], а @('foo').Count дает 1 (хотя, как указано, в PSv3 + вы можете использовать 'foo'.Count напрямую).
      @( & { } ).Count дает 0 (выполнение пустого блока скрипта дает нулевую коллекцию ([System.Management.Automation.Internal.AutomationNull]::Value)

    • Предупреждение: @() вокруг New-Object вызова, который создает массив / коллекцию, выводит этот массив / коллекцию , заключенный во внешний одноэлементный массив.

      • @(New-Object System.Collections.ArrayList).Count дает 1 - список пустых массивов помещается в одноэлементный System.Object[] экземпляр.

      • Причина в том, что New-Object в силу того, что он является командой (например, вызовом cmdlet), не подлежит перечислению (разворачиванию), что приводит к @(), чтобы увидеть только одиночный элемент (который оказывается массивом / коллекцией), который, следовательно, заключен в массив из одиночных элементов.

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

        • @([system.collections.arraylist]::new()).Count yields 0; the expression outputs an empty collection that is enumerated, and since there's noting to enumerate, @() creates an empty System.Object[] array.
          Note that, in PSv3+, simply using an extra set of parentheses ((...)) with New-Object - which converts the New-Object command to an expression - would yield the same result:
          @((New-Object System.Collections.ArrayList)).Count yields 0 too.

  • Если результат содержит несколько элементов, эти элементы возвращаются как обычный массив PowerShell ([System.Object[]]); например.:

    • With a command:
      • $arr = @(Get-ChildItem *.txt) collects the one-by-one streaming output from Get-ChildItem in a System.Object[] array
    • With an expression:

      • $arr = [int[]] (1, 2); @($arr) перечисляет [int[]] массив $arr, а затем переупаковывает элементы как System.Object[] массив.

      • Обратите внимание на неэффективность и потенциальную потерю верности типа этого процесса: исходный массив перечисляется и собирается в новом массив, который всегда имеет тип System.Object[]; эффективная альтернатива - преобразовать в [array] (который также работает с командами): [array] $result = ...