Posts on this page:
- Windows PowerShell ISE 3.0
- Windows PowerShell 3.0 CTP1
- Простой подсчёт хешей для файлов
- PowerShell — массивы (часть 2, последняя)
- PowerShell — массивы (часть 1, создание массивов)
Disclaimer: данный обзор проводится по Dev Preview редакции Windows 8. Это даже не CTP и не Beta, поэтому любой функционал в финальной версии может быть изменён, добавлен или удалён.
В новой версии PowerShell появился и не менее новый (ВНЕЗАПНО) редактор или IDE для разработки скриптов PowerShell. По некоторым данным, новый PowerShell ISE это самый настоящий повергуикапец. И вот почему. Например, первый запуск ISE:
Начнём с того, что мы видим. А видим сразу мы панель Commands, которая показывает список доступных командлетов. Так же, можете фильтровать их по модулям и по именам. Причём, поиск интерактивный. Но смысл этой панельки совсем не в том, чтобы просто показать какие командлеты у нас доступны, а больше:
Как видно, в этой панели есть графическая набиралка параметров. Вы можете заполнить параметры как нужно и потом с ними что-нибудь сделать. В параметры можно подавать массивы строк, разделяя их запятой (как и в обычной консоли). Например, если нажать кнопку Insert, соответствующая команда PowerShell (вместе с параметрами и аргументами) будет вставлена в панель консоли ISE (показано на скриншоте). Кнопка Copy копирует эту же строку в буфер обмена, так что вы можете её вставить в панель редактора. Так же можно заметить, что вы можете использовать разные наборы параметров (parameter set). Эта панелька будет интересна скорее новичкам, потому что все параметры на виду и кавычки будут проставлены автоматически. Но эта панелька может быть полезна и для не новичков, потому что:
Количество встроенных командлетов в PowerShell V2:
[↓] [vPodans] (gcm -com cmdlet).length
236
и в PowerShell 3.0:
PS C:\Users\Administrator> (gcm -com cmdlet).length 718
Почти в три раза больше и вполне можно затеряться в них.
А теперь, самый эпиквин:
Наконец-то появился вменяемый Intellisense! По кнопке [Tab] в редакторе автозавершаются имена переменных! Но есть один нюанс: прежде чем автозавершать имена переменных, код, в котором используется переменная должен быть запущен. Вариант, как в PowerGUI Script Editor'е (когда имена переменных в Intellisense появляются сразу, как они упоминуются в редакторе) пока что не работает. Ну и Intellisense для переменных пока что не предусмотрен, только табом переключать. Intellisense так же доступен для извлечения членов классов:
Единственное, для чего не работает Intellisense: стандартные операторы (-eq, –ne, –like, –notlike, etc.) и классы .NET'а. Но это тоже должно появиться в будущем.
А вот здесь мы видим много интересного. В ISE появился outlining, т.е. можно сворачивать всякие конструкции (нажимая плюсики и минусики). И ещё появился онлайн парсер кода и если парсер видит что-то непотребное, он будет весьма недоволен и подчёркивать красной волнистой линией. Если навести курсор на неё, вылезет тултип (tooltip) c описанием ошибки. Я немного забежал вперёд и спалил новый параметр для цикла foreach: –parallel. Сейчас он не реализован, но обязательно будет в финальной версии. Суть всего этого — теперь цикл будет работать не последовательно, а параллельно! Я считаю это винрарным улучшением перформанса.
Вроде мелочь, а приятно! Теперь ISE показывает парные скобки (круглые, квадратные, фигурные), кавычки (одиночные, двойные, herestrings).
В ISE теперь есть сниппеты :) И наконец-то поправили кодировку файлов с Unicode Big Endian (что доставляло немало лулзовкирпичей при запуске такого скрипта в консоле) на UTF8.
Если подвести краткий итог, PowerShell ISE сделал серьёзную заявку на право называться редактором для PowerShell. Причём, при определённых условиях (в зависимости от конечного функционала) ISE может стать моим основным редактором, даже не смотря на многолетнюю привычку использовать PowerGUI Script Editor. В любом случае, для новичков ISE будет хорошим стартом.
Очень сильно прозреваю, что я буду последним, кто сообщил эту новость и вы скорее всего получили эту информацию из более оперативных источников. Поэтому данный пост предназначен для тех, кто более розовый, чем я :).
Итак, на днях в открытый доступ выложили Windows Management Framework 3.0 CTP (Community Technology Preview), который содержит и PowerShell 3.0 (очевидно, что тоже ещё в стадии CTP). WMF3 устанавливается на системы Windows 7 и Windows Server 2008 R2. Владельцы других систем пока могут быть свободны. Краткий список нововведений есть на странице загрузки. Если у вас есть предыдущая версия WMF 3.0 (KB2508781 и KB2506143), её надо будет удалить, иначе возможны разные сюрпризы. И ещё раз ссылка для самых розовых:
>> Windows Management Framework 3.0 CTP <<
На этом пока всё. А в следующих разах расскажу про что-нибудь новое подробнее и как и почему случился повергуикапец :)
По просьбам трудящихся публикую скриптик, который подсчитывает хеш для файлов. Скрипт очень простой, он всего лишь выводит имя файла (полное) и значение хеша, который можно использовать как вам нужно.
function Get-FileHash { [CmdletBinding()] param( [Parameter(Mandatory = $true, ValueFromPipeline = $true, ValueFromPipelinebyPropertyName = $true)] [string]$FullName, [ValidateSet("MD5","SHA1","SHA256","SHA384","SHA512")] [string]$Hash = "SHA1" ) begin { function Test-FileLock ($file) { $locked = $false trap { Set-Variable -name locked -value $true -scope 1 continue } $inputStream = New-Object system.IO.StreamReader $file if ($inputStream) {$inputStream.Close()} $locked } $Hasher = switch ($Hash) { "MD5" {[System.Security.Cryptography.MD5]::Create()} "SHA1" {[System.Security.Cryptography.SHA1]::Create()} "SHA256" {[System.Security.Cryptography.SHA256]::Create()} "SHA384" {[System.Security.Cryptography.SHA384]::Create()} "SHA512" {[System.Security.Cryptography.SHA512]::Create()} } } Process { $file = gi (Resolve-Path $FullName) -Force if ($file -is [IO.FileInfo]) { if (Test-FileLock $file) {return} $inputStream = New-Object System.IO.StreamReader ($file) $hashBytes = $hasher.ComputeHash($inputStream.BaseStream) $inputStream.Close() $builder = New-Object System.Text.StringBuilder $hashBytes | %{[void]$builder.Append($_.ToString("X2"))} New-Object psobject -Property @{ FullName = $file.ToString() Hash = $builder.ToString() } } } }
Использование простое: dir c:\folder | Get-FileHash
или с указанием другого алгоритма (по умолчанию SHA1): dir c:\folder -recurse | Get-FileHash -Hash sha256
Но, всё же, для отслеживания изменённых файлов советую использовать мой PSFCIV, который специально заточен под это дело и позволяет не только считать хеши, но и проверять их.
В прошлый раз мы рассмотрели основные вопросы массивов и управления ими в Windows PowerShell. Мы теперь знаем, как они создаются, как изменять их размер (ресайзить) и какие математические операции можно проводить над массивами. В этой части я расскажу о сравнении массивов, поиске элементов и т.д.
Сравнение массивов
Как известно, в PowerShell есть куча операторов (или групп операторов) сравнения, как –eq и –like. Но здесь у нас сразу появляется проблема — эти операторы нельзя использовать для сравнения массивов. Давайте посмотрим, что получится:
[↓] [vPodans] "abc" -eq "abc" True [↓] [vPodans] 1,2,3 -eq 1,2,3 [↓] [vPodans]
Оператор –eq ничего не вернул. Дело в том, что справа от оператора –eq может быть только один объект, буква, строка, число и т.д. В контексте массивов оператор –eq можно использовать для получения элементов массива, содержащих конкретное значение. Например, у нас есть массив из нескольких чисел и мы хотим узнать сколько раз конкретное число использовано в массиве. Вот простой пример:
[↓] [vPodans] 2,8,5,6,2,5,4,2,7 -eq 2 2 2 2 [↓] [vPodans] 2,8,5,6,2,5,4,2,7 -eq 5 5 5 [↓] [vPodans] 2,8,5,6,2,5,4,2,7 -eq 1 [↓] [vPodans] (2,8,5,6,2,5,4,2,7 -eq 2).Length 3 [↓] [vPodans] (2,8,5,6,2,5,4,2,7 -eq 5).Length 2 [↓] [vPodans] (2,8,5,6,2,5,4,2,7 -eq 1).Length 0 [↓] [vPodans]
Из показанных примеров мы видим, что оператор –eq возвращает элементы, которые соответствуют сравниваемому объекту. Поэтому при помощи оператора –eq можно узнать, содержит ли массив конкретное значение или нет и если да, то сколько раз. То же самое относится и к оператору –like, который больше подходит для сравнения строк по маске:
[↓] [vPodans] "abc","cba","bac","bca" -like "a*" abc [↓] [vPodans] "abc","cba","bac","bca" -like "?b?" abc cba [↓] [vPodans]
Здесь используется тот же принцип, что и с использованием оператора –eq, только с разницей, что оператор –like сравнивает по маске (нестрогое соответствие).
Для точного сравнения двух массивов следует использовать командлет Compare-Object:
[↓] [vPodans] Compare-Object 1,2,3 1,2,3 [↓] [vPodans] Compare-Object 1,2,3 1,2 InputObject SideIndicator ----------- ------------- 3 <= [↓] [vPodans] Compare-Object 1,2,3 1,2,2 InputObject SideIndicator ----------- ------------- 2 => 3 <= [↓] [vPodans]
Если массивы одинаковые, командлет ничего не вернёт. Если же есть различия, вы увидите, какие элементы отсутствуют в одном массиве (направление стрелочки указывает от массива с недостающим элментом). Может быть и так, что оба массива одинаковы по размеру, но какие-то элементы имеют разные значения. Тогда вы увидите стрелочки в оба направления. Командлет Compare-Object может выводить и одинаковые элементы:
[↓] [vPodans] Compare-Object -ref 1,2,3 -dif 1,2,2 -IncludeEqual InputObject SideIndicator ----------- ------------- 1 == 2 == 2 => 3 <= [↓] [vPodans]
В одинаковых элементах SideIndicator будет показывать двойной знак равенства (==).
Поиск по массиву
Иногда бывает очень нужным найти индекс элемента массива, значение которого совпадает с какой-то величиной. К сожалению, в PowerShell нет стандартного механизма поиска индексов. Во времена, когда я в повершеле был ещё совсем чайником, Вася Гусев написал мне простенький ванлайнер, который выводит индексы элементов массивов, значения которых совпали по какой-то маске:
function findinarr ($array, $value) {for ($i=0; $i -lt $array.count;$i++){if($array[$i] -eq $value){$i}}}
или более развёрнутый вариант:
function findinarr ($array, $value) { for ($i=0; $i -lt $array.count;$i++) { if($array[$i] -eq $value){$i} } }
Например, узнать, индекс (или индексы) элемента массива, который содержит цифру 2 и 5:
[↓] [vPodans] $a = 2,8,5,6,2,5,4,2,7 [↓] [vPodans] findinarr $a 2 0 4 7 [↓] [vPodans] findinarr $a 5 2 5 [↓] [vPodans]
Мы видим, что цифра 2 в указанном массиве содержится в элементах с индексами 0, 4 и 7, а цифра 5 в элементах с индексами 2 и 5. Не забудьте, что индексы в массивах начинаются с нуля.
Форматирование массивов
PowerShell отображает массивы в столбик, т.е. каждый элемент массива показывается на новой строке. А если вы хотите показать массив так, чтобы все элементы были в строчку, разделённой пробелами? Можно извратиться конструкцией вида:
$a = 1..100 $string = "" $a | ForEach-Object {$string += "$_" + " "}
[↓] [vPodans] $a = 1..100 [↓] [vPodans] $string = "" [↓] [vPodans] $a | ForEach-Object {$string += "$_" + " "} [↓] [vPodans] $string 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 8 3 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 [↓] [vPodans]
Но можно сделать ещё круче — заключить переменную с массивом в двойные кавычки:
[↓] [vPodans] $a = 1..100 [↓] [vPodans] "$a" 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 8 3 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 [↓] [vPodans]
как видите, результат точно такой же, только кода израсходовано куда меньше.
Преобразование строк в массивы и обратно
Далеко не всегда мы имеем возможность получить готовый массив, наоборот, нам нужно разбить одну строку на массив строк. Для этого можно использовать метод Split() класса System.String или оператор –split:
[↓] [vPodans] "this is a single string".split() this is a single string [↓] [vPodans] -split "this is a single string" this is a single string [↓] [vPodans]
По умолчанию, строка разбивается на массив строк по пробелу и разделителю строк. Если вы хотите разделить по другому разделителю можно его указать явно. Например, разбить MAC адрес сетевой карты на октеты:
[↓] [vPodans] "00-18-DE-54-57-8E" -split "-" 00 18 DE 54 57 8E [↓] [vPodans]
Причём, обратите внимание, что оператор –split может быть как унарным (когда всё располагается только справа от оператора), так и бинарным (когда исходная строка находится слева от оператора, остальное располагается справа). Более подробно про оператор –split лучше всего прочитать в справке: http://technet.microsoft.com/en-us/library/dd347708.aspx. Функционал оператора достаточно интересен, но выходит за рамки рассматриваемой статьи.
Есть ещё один трюк, как разделить строку на массив символов. Для этого используется метод ToCharArray():
[↓] [vPodans] "00-18-DE-54-57-8E".tochararray() 0 0 - 1 8 - D E - 5 4 - 5 7 - 8 E [↓] [vPodans]
Есть ещё один трюк, как разбить строку на массив символов. Для этого надо строку привести к массиву символов (char[]) и результат будет точно такой же:
[char[]]"00-18-DE-54-57-8E"
Если у вас есть массив и его нужно преобразовать в одну строку, можно воспользоваться статическим методом Join() класса System.String или оператором –join:
[↓] [vPodans] $a = 1..10 [↓] [vPodans] $a 1 2 3 4 5 6 7 8 9 10 [↓] [vPodans] [string]::Join(",",$a) 1,2,3,4,5,6,7,8,9,10 [↓] [vPodans] $a -join "," 1,2,3,4,5,6,7,8,9,10 [↓] [vPodans] -join $a 12345678910 [↓] [vPodans]
Как видно из примера, оператор –join так же, как и –split бывает унарным и бинарным. Бинарная форма всегда используется, когда нужно явно указать разделитель или другие параметры оператора –join. Если оператор унарный, он не принимает явный разделитель и просто последовательно пристыковывает элементы массива в строку. Если вам нужно преобразовать несколько массивов в строки с использованием одного и того же разделителя, в PowerShell можно использовать специальную переменную $ofs и массив явно привести к типу string:
[↓] [vPodans] $ofs = "+" [↓] [vPodans] [string]$a 1+2+3+4+5+6+7+8+9+10 [↓] [vPodans] iex ([string]$a) 55 [↓] [vPodans]
Как можно видеть из примеров, с массивами в PowerShell можно делать что угодно (кроме вычитания и деления). Причём, зачастую, существует несколько способов выполнить одну и ту же задачу.
Реверсирование массивов
Вообще это используется не так часто, что можно было бы и опустить, но я достаточно часто работаю с CryptoAPI и бывает нужным первернуть массив. Дело в том, что CryptoAPI до мозга костей little-endian, а остальные API (даже тот же .NET) как правило big-endian. И чтобы перевернуть массив верх тормашками можно использовать статический метод
[↓] [vPodans] $a = 1..5 [↓] [vPodans] $a 1 2 3 4 5 [↓] [vPodans] [array]::Reverse($a) [↓] [vPodans] $a 5 4 3 2 1 [↓] [vPodans]
Следует учитывать, что этот метод меняет порядок следования элементов в самой перменной и не образует выходной информации.
Эпилог
В качестве эпилога скажу, что я рассмотрел лишь самые популярные действия с массивами и это составляет лишь малую часть того, что с ними можно сделать в реальности. Но этого материала (включая предыдущую статью) вам хватит на 95% случаев. И на этом всё.
Данный пост немного не вписывается в формат моего блога, но я посчитал нужным рассказать про массивы и работу с ними в PowerShell. Мне просто нравятся массивы и всё, что с ними можно вытворять. Это очень интересно и полезно. Сразу оговорюсь, мозголомного материала здесь не будет, поэтому пост могут читать даже начинающие.
Что такое массив? Это просто набор данных. Массивы вокруг нас, ТЫСЯЧИ ИХ! Например, мой бложек — это тоже массив, массив постов. В PowerShell массивы наследуются из класса System.Array. Это означает, что любой массив будет содержать те же свойства и методы, что и упомянутый класс. Давайте посмотрим на самый простой массив и как он создаётся:
Variable = Value1, Value2, Value3 <...> ValueN
[↓] [vPodans] $a = 1,2,3 [↓] [vPodans] $a | Get-Member TypeName: System.Int32 Name MemberType Definition ---- ---------- ---------- CompareTo Method int CompareTo(System.Object value), int CompareTo(int value) Equals Method bool Equals(System.Object obj), bool Equals(int obj) GetHashCode Method int GetHashCode() GetType Method type GetType() GetTypeCode Method System.TypeCode GetTypeCode() ToString Method string ToString(), string ToString(string format), string ToString(System.IFormatProvider pro... [↓] [vPodans] $a.GetType().fullname System.Object[] [↓] [vPodans] $a 1 2 3 [↓] [vPodans]
Мы создали простой массив состоящий из 3-х чисел: 1, 2 и 3. Однако, мы видим, что тип вовсе не System.Array, а System.Object[]. Квадратные скобки после названия класса означают, что рассматриваемый объект — массив объектов указанного класса. Например, массив объектов класса System.Object. PowerShell не использует напрямую System.Array для представления массива, а вместо этого создаёт новый объект, который наследуется из System.Array. Это означает, что массивы внутри могут содержать различную информацию и иметь любой тип (Char[], String[], Int[], ...), но набор свойств и методов будет всегда одинаковый. Чтобы убедиться в этом, посмотрите на исходный объект:
$a.PSBase | Get-Member
По умолчанию PowerShell создаёт универсальный массив, который может содержать любые данные. Доступ к элементам массива осуществляется посредством квадратных скобок следующих за переменной и индексом элемента в массиве внутри этих скобок:
[↓] [vPodans] $a[0] 1 [↓] [vPodans] $a[1] 2 [↓] [vPodans] $a[2] 3 [↓] [vPodans]
Как и во многих языках программирования, индекс элементов массива начинается с нуля (в VBS, напрмер, с 1). Вот так можно получать доступ к элементам массива. Давайте посмотрим, в чём универсальность этого массива. Сейчас он содержит только объекты типа Int32. Сейчас мы подмешаем в наш массив немного мусора:
[↓] [vPodans] $a[0] = "я - строчка!!!111одинодин" [↓] [vPodans] $a я - строчка!!!111одинодин 2 3 [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans]
И мусор успешно добавлен. Всё дело как раз в этом объекте System.Object, который может хранить какие угодно данные. Но мы можем создать массив определённого типа. Например, массив, содержащий только числа:
[↓] [vPodans] $a = [int[]](1,2,3) [↓] [vPodans] $a.GetType().FullName System.Int32[] [↓] [vPodans] $a[0] = "я - строчка!!!111одинодин" Array assignment to [0] failed: Cannot convert value "я - строчка!!!111одинодин" to type "System.Int32". Error: "Input string was not in a correct format.". At line:1 char:4 + $a[ <<<< 0] = "я - строчка!!!111одинодин" + CategoryInfo : InvalidOperation: (я - строчка!!!111одинодин:String) [], RuntimeException + FullyQualifiedErrorId : ArrayAssignmentFailed [↓] [vPodans]
Я создал массив, который может содержать только целые числа. Это видно по новому типу: System.Int32[]. Поэтому если теперь мы попробуем в массив подсунуть нечто нечисловое — получим ошибку. Как ещё можно создавать массивы? Например, хочу получить массив, состоящий из одного элемента. Или не содержащий ни одного элемента. Каково, а? Для этого можно использовать вот такую форму:
@()
Значок пёсика и круглых скобок будет означать массив. Внутри скобок можно положить какие угодно данные и они будут приведены к массиву. Смотрим:
[↓] [vPodans] # пустой массив [↓] [vPodans] $a = @() [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans] $a[0] [↓] [vPodans] $a.Length 0 [↓] [vPodans] # массив из одного элемента [↓] [vPodans] $a = @("я - единственный элемент в массиве") [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans] $a[0] я - единственный элемент в массиве [↓] [vPodans] $a.Length 1 [↓] [vPodans]
Из этого примера мы видим, что пустой массив — это тоже себе массив. Просто пустой (это видно по свойству Length, которое показывает количество элементов в массиве). Такой же формой можно привести и единичный объект к массиву из одного элемента. Этот метод создания и приведения к массиву может быть очень полезным. Например, вы обрабатываете выход некоторой команды. Этот выход может содержать один объект, а может и несколько. Это может несколько затруднить вам жизнь, потому что не у всех типов есть свойство Length, а у тех, у кого оно есть, это свойство может означать всякую всячину. Например, у System.String это свойство будет означать количество символов в строке. Именно поэтому вы можете вывод команды заключить в такую конструкцию — @() и тогда будете точно знать сколько элементов вы получили. Вот пример:
[↓] [vPodans] (Get-Item .\).length [↓] [vPodans] @(Get-Item .\).length 1 [↓] [vPodans]
Этот пример наглядно иллюстрирует указанную проблему. Если команда вернула много элементов в массиве, вы можете использовать свойство Length, чтобы узнать сколько их там. Если команда вернула ноль или один элемент, вам свойство Length может быть недоступно и вам придётся выяснять содержимое вывода другими средствами, например, сравнивать выход команды с $null. Но, если заключить вывод команды в @(), тогда он будет гарантированно приведён к массиву и вы всегда по свойству Length узнаете сколько данных вы получили, ноль, один или больше.
Есть ещё один простенький способ создать простой массив из одного элемента — при помощи унарного оператора запятой:
[↓] [vPodans] $a = ,5 [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans] $a.Length 1 [↓] [vPodans] $a = ,2,5,6 [↓] [vPodans] $a.Length 3 [↓] [vPodans]
Если запятая стоит в начале выражения, она интерпретируется как оператор и всё, что есть справа от оператора будет интерпретироваться как элементы массива. Я надеюсь, что многие знают о замечательном операторе двух точек. Этот оператор генерирует массив целых чисел (и только чисел) начиная от числа слева от оператора до числа (включительно), указанного справа от оператора:
[↓] [vPodans] $a = 5..10 [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans] $a.Length 6 [↓] [vPodans]
Вот так создаётся простой массив целых чисел.
Вам кажется, что у вас массив очень маленький? У соседа он больше и он первый парень на деревне? Сделайте себе ещё больше!
Массивы можно увеличивать в размере при помощи математического оператора сложения или умножения. Уменьшать массив операторами вычитания и деления нельзя (и правильно, уменьшите свой массив и девушки на вас смотреть не будут).
[↓] [vPodans] $a = 5..10 [↓] [vPodans] $a 5 6 7 8 9 10 [↓] [vPodans] $a.Length 6 [↓] [vPodans] $a += 0 [↓] [vPodans] $a.Length 7 [↓] [vPodans] $a 5 6 7 8 9 10 0 [↓] [vPodans]
Мы сначала создали массив из 6 элементов и оператором сложения с присвоением добавили ещё один.
Примечание: команда вида $a += 0 является упрощённой записью простейшего счётчика: $a = $a + 0. То же самое и касается оператора *=. Это равносильно команде $a = $a * 0.
Массивы не резиновые (это очевидно!) и растягивать их нельзя. Внутренне PowerShell создаёт ещё один массив размером, достаточным хранить существующий массив и добавляемый. Вы этого просто не видите, а оно происходит. Доказать это можно очень просто. В самом начале поста я пытался подменить элемент массива фиксированного типа и у меня ничего хорошего из этого не вышло. А теперь попробуем вот так:
[↓] [vPodans] $a = [int[]](1,2,3) [↓] [vPodans] $a.GetType().FullName System.Int32[] [↓] [vPodans] $a += "я - строчка!!!111одинодин" [↓] [vPodans] $a 1 2 3 я - строчка!!!111одинодин [↓] [vPodans] $a.GetType().FullName System.Object[] [↓] [vPodans]
Мы сначала создали массив фиксированного типа, который может хранить только целые числа. Добавив к массиву ещё один элемент, массив стал снова универсальным, большего размера и без ошибок добавил нашу строку к числовому массиву. Это следует учитывать, если вы хотите иметь массив фиксированного типа.
Для пытливых умов: чтобы создать настоящий массив фиксированного типа следует использовать класс List(T). Такой массив не будет изменять свой тип при изменении размера. И если попытаться в такой массив добавить элемент неправильного типа, вы получите ошибку.
Как я уже говорил, массивы можно не просто складывать, но и умножать, что позволит вам достаточно просто обогнать массив вашего соседа. Если при сложении вы можете складывать 2 и более массивов, то с умножением немного иначе. Вы не можете умножить один массив на другой. Умножение массива просто копирует ваш массив столько раз, сколько указано в правой части от оператора умножения:
[↓] [vPodans] $a = 1,2 [↓] [vPodans] $a * 3 1 2 1 2 1 2 [↓] [vPodans]
Мы создали простой массив из двух элементов. Умножили его на 3 и получили тот же массив, только скопипастенных 3 раза. Здесь действуют те же законы оператора умножения, что и в математике. Т.е. если умножить массив на 1, мы получим исходный массив без изменений. Как известно из школьного курса математики, любое число умноженное на 1 не изменится. И если умножить любой массив на ноль, мы молучим совершенно пустой массив:
[↓] [vPodans] $a.Length 2 [↓] [vPodans] $a *= 1 [↓] [vPodans] $a.Length 2 [↓] [vPodans] $a *= 0 [↓] [vPodans] $a.Length 0 [↓] [vPodans] $a.GetType().FullName System.Object[]
Я посмотрел размер исходного массива и умножил его на 1. Его размер не изменился. Потом я умножил наш массив на ноль и он резко опустел. Но наш массив сам никуда не делся, он остался.
До сих пор мы рассматривали одномерные массивы. Но бывают и двумерные массивы. Они представляют собой обычную плоскую матрицу или таблицу со строками и столбцами. В мире геометрии это будет просто плоскость длиной N столбцов и высотой M строк:
[↓] [vPodans] $b = New-Object "object[,]" 3,3 [↓] [vPodans] $b[0,0] = 1 [↓] [vPodans] $b[0,1] = 2 [↓] [vPodans] $b[0,2] = 3 [↓] [vPodans] $b[1,0] = 4 [↓] [vPodans] $b[1,1] = 5 [↓] [vPodans] $b[1,2] = 6 [↓] [vPodans] $b[2,0] = 7 [↓] [vPodans] $b[2,1] = 8 [↓] [vPodans] $b[2,2] = 9 [↓] [vPodans] $b 1 2 3 4 5 6 7 8 9 [↓] [vPodans] $b[1,2] 6 [↓] [vPodans] $b[2,1] 8 [↓] [vPodans] for ($n = 0; $n -lt 3; $n++) { >> Write-Host $b[0,$n] $b[1,$n] $b[2,$n] >> } >> 1 4 7 2 5 8 3 6 9 [↓] [vPodans]
Вот таким нехитрым образом создаются двумерные массивы. Первый индекс указывает на номер столбца, второй индекс указывает номер строки. Однако, двумерные массивы нельзя складывать или умножать. В этом случае PowerShell разбивает этот массив в одномерный путём присоединения каждого последуюшего столбца к предыдущему.
На сегодня всё. В следующий раз расскажу немного о некоторых полезных операциях, которые можно проделывать с массивами, включая поиск элементов.