{"id":74311,"date":"2015-11-01T00:01:00","date_gmt":"2015-11-01T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2015\/11\/01\/weekend-scripter-exploring-powershell-arrays\/"},"modified":"2019-02-18T09:34:42","modified_gmt":"2019-02-18T16:34:42","slug":"weekend-scripter-exploring-powershell-arrays","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/weekend-scripter-exploring-powershell-arrays\/","title":{"rendered":"Weekend Scripter: Exploring PowerShell Arrays"},"content":{"rendered":"

Summary<\/b>: Ed Wilson, Microsoft Scripting Guy, talks about Exploring Windows PowerShell arrays.<\/span><\/p>\n

Microsoft Scripting Guy, Ed Wilson, is here. One of the problems I had with Windows PowerShell when I first learned it was handling arrays. Why? Because they were so easy. Well, they are easy, but they are also a bit confusing. Why? Because Get-Member<\/b> seems to hide the type, so I may have an array, and it will report string. But that is something I will talk about in a minute. First, let's look at creating an array.<\/p>\n

Create an array in PowerShell<\/h2>\n

The easiest way to create an array is to simply create a variable and assign more than one item to it. Here is an example:<\/p>\n

$a = 1,2,3,4,5<\/p>\n

As shown here, if I pipe the $a<\/b> variable to the Get-Member<\/b> (gm<\/b> is an alias) cmdlet, it reports that it is a System.Int32:<\/p>\n

PS C:\\> $a | gm<\/p>\n

   TypeName: System.Int32<\/p>\n

Name        MemberType Definition<\/p>\n

—-        ———- ———-<\/p>\n

CompareTo   Method     int CompareTo(System.Object value), int CompareTo(int valu…<\/p>\n

Equals      Method     bool Equals(System.Object obj), bool Equals(int obj), bool…<\/p>\n

GetHashCode Method     int GetHashCode()<\/p>\n

GetType     Method     type GetType()<\/p>\n

GetTypeCode Method     System.TypeCode GetTypeCode(), System.TypeCode IConvertibl…<\/p>\n

ToBoolean   Method     bool IConvertible.ToBoolean(System.IFormatProvider provider)<\/p>\n

ToByte      Method     byte IConvertible.ToByte(System.IFormatProvider provider)<\/p>\n

ToChar      Method     char IConvertible.ToChar(System.IFormatProvider provider)<\/p>\n

ToDateTime  Method     datetime IConvertible.ToDateTime(System.IFormatProvider pr…<\/p>\n

ToDecimal   Method     decimal IConvertible.ToDecimal(System.IFormatProvider prov…<\/p>\n

ToDouble    Method     double IConvertible.ToDouble(System.IFormatProvider provider)<\/p>\n

ToInt16     Method     int16 IConvertible.ToInt16(System.IFormatProvider provider)<\/p>\n

ToInt32     Method     int IConvertible.ToInt32(System.IFormatProvider provider)<\/p>\n

ToInt64     Method     long IConvertible.ToInt64(System.IFormatProvider provider)<\/p>\n

ToSByte     Method     sbyte IConvertible.ToSByte(System.IFormatProvider provider)<\/p>\n

ToSingle    Method     float IConvertible.ToSingle(System.IFormatProvider provider)<\/p>\n

ToString    Method     string ToString(), string ToString(string format), string …<\/p>\n

ToType      Method     System.Object IConvertible.ToType(type conversionType, Sys…<\/p>\n

ToUInt16    Method     uint16 IConvertible.ToUInt16(System.IFormatProvider provider)<\/p>\n

ToUInt32    Method     uint32 IConvertible.ToUInt32(System.IFormatProvider provider)<\/p>\n

ToUInt64    Method     uint64 IConvertible.ToUInt64(System.IFormatProvider provider)<\/p>\n

But if I use $a<\/b> as an input object to Get-Member<\/b>, it reports system.object[]<\/b>. The [] <\/b>means an array. This is shown here:<\/p>\n

\"Image<\/a><\/p>\n

It is also interesting to look at the .psbase<\/b> property. This is basically a hidden property, meaning that it does not readily appear and Tab expansion does not seem to show it. It is pretty cool. As shown here, it tells me the length, the rank, and other stuff.<\/p>\n

PS C:\\> $a.psbase<\/p>\n

Length         : 5<\/p>\n

LongLength     : 5<\/p>\n

Rank           : 1<\/p>\n

SyncRoot       : {1, 2, 3, 4…}<\/p>\n

IsReadOnly     : False<\/p>\n

IsFixedSize    : True<\/p>\n

IsSynchronized : False<\/p>\n

Count          : 5<\/p>\n

Also cool is the PSObject<\/b> property. Note especially, that at the bottom of the output, it says we have three types—one of which is System.Array<\/b>:<\/p>\n

PS C:\\> $a.psobject<\/p>\n

Members             : {Count = Length, int Length {get;}, long LongLength {get;},<\/p>\n

                      int Rank {get;}…}<\/p>\n

Properties          : {Count = Length, int Length {get;}, long LongLength {get;},<\/p>\n

                      int Rank {get;}…}<\/p>\n

Methods             : {void Set(int , System.Object ), System.Object&, mscorlib,<\/p>\n

                      Version=4.0.0.0, Culture=neutral,<\/p>\n

                      PublicKeyToken=b77a5c561934e089 Address(int ), System.Object<\/p>\n

                      Get(int ), System.Object GetValue(Params int[] indices),<\/p>\n

                      System.Object GetValue(int index), System.Object GetValue(int<\/p>\n

                      index1, int index2), System.Object GetValue(int index1, int<\/p>\n

                      index2, int index3), System.Object GetValue(long index),<\/p>\n

                      System.Object GetValue(long index1, long index2),<\/p>\n

                      System.Object GetValue(long index1, long index2, long<\/p>\n

                      index3), System.Object GetValue(Params long[] indices)…}<\/p>\n

ImmediateBaseObject : {1, 2, 3, 4…}<\/p>\n

BaseObject          : {1, 2, 3, 4…}<\/p>\n

TypeNames           : {System.Object[], System.Array, System.Object}<\/p>\n

If I use the GetType()<\/b> method that is automatically created, it tells me that I have an object[]<\/b> (note the square brackets again) and that my BaseType is an array:<\/p>\n

PS C:\\> $a.GetType()<\/p>\n

IsPublic IsSerial Name                           BaseType<\/p>\n

——– ——– —-                                     ——–<\/p>\n

True     True     Object[]                       System.Array<\/p>\n

Use the range operator to save typing<\/h2>\n

One of my absolutely positively favorite operators is the range operator. It is simply a couple of dots. It will create an array with the numbers in the range. The reason it is so cool is that I can easily create an array with 2 or with 2,000,000 elements in it. It really doesn’t matter. Here is an example:<\/p>\n

PS C:\\> $b = 1..2000000<\/p>\n

PS C:\\> $b.Count<\/p>\n

2000000<\/p>\n

Is it an array? Well, when I use GetType()<\/b>, it says, yep, it is an array:<\/p>\n

PS C:\\> $b.GetType()<\/p>\n

IsPublic IsSerial Name                           BaseType<\/p>\n

——– ——– —-                                     ——–<\/p>\n

True     True     Object[]                        System.Array<\/p>\n

Create a strongly typed array<\/h2>\n

One of the things that is way cool about Windows PowerShell is that it is a strongly typed language, but it behaves as if it were typeless. What this means is that everything is an object, and every object is a type of something. For instance, in the previous array, the type was System.Array<\/b>, but the array held. An int32<\/b> holds numbers from -2147483648 to 2147483647 in size. This is shown here:<\/p>\n

PS C:\\> [int32]::MaxValue<\/p>\n

2147483647<\/p>\n

PS C:\\> [int32]::MinValue<\/p>\n

-2147483648<\/p>\n

int32 <\/b>is the default. But what if I don’t need a number that big? Well, I can change to int16<\/b>. As you can see here, int16<\/b> has a maximum value of 32767:<\/p>\n

PS C:\\> [int16]<\/p>\n

IsPublic IsSerial Name                           BaseType<\/p>\n

——– ——– —-                                     ——–<\/p>\n

True     True     Int16                            System.ValueType<\/p>\n

PS C:\\> [int16]::MaxValue<\/p>\n

32767<\/p>\n

If I want to ensure that my array does not change, I can use [int16[]]<\/b> to constrain the type or to keep it from changing. If I try to assign a number that is too large, it generates the following error message:<\/p>\n

\"Image<\/a><\/p>\n

I invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

Ed Wilson, Microsoft Scripting Guy<\/b> <\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

Summary: Ed Wilson, Microsoft Scripting Guy, talks about Exploring Windows PowerShell arrays. Microsoft Scripting Guy, Ed Wilson, is here. One of the problems I had with Windows PowerShell when I first learned it was handling arrays. Why? Because they were so easy. Well, they are easy, but they are also a bit confusing. Why? Because […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[442,51,3,61,45],"class_list":["post-74311","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-arrays","tag-getting-started","tag-scripting-guy","tag-weekend-scripter","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Summary: Ed Wilson, Microsoft Scripting Guy, talks about Exploring Windows PowerShell arrays. Microsoft Scripting Guy, Ed Wilson, is here. One of the problems I had with Windows PowerShell when I first learned it was handling arrays. Why? Because they were so easy. Well, they are easy, but they are also a bit confusing. Why? Because […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/74311","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=74311"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/74311\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=74311"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=74311"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=74311"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}