Powershell Read External Command Output Into Array

Arrays are a key feature of PowerShell. Arrays brand it possible to ingest, manipulate and output true information structures (and non merely raw strings). This adequacy makes PowerShell different and more useful than other scripting languages.

In this article, nosotros'll explain what arrays are, and how to use them in PowerShell. We'll get-go bear witness you how to create arrays in PowerShell, and so how to utilize bones functions to dispense them. So we'll look at several different types of arrays, and explore some of the more subtle features of them.

Get the costless PowerShell and Active Directory Video Course

Our aim is to give you a good grounding in working with arrays in PowerShell. Once you've mastered these basics, y'all can take a look at our grade on PowerShell to larn more.

• Array Fundamentals
• Arrays of Objects
• Operators For Arrays
• How to Add Values to an Assortment
• Assortment Types
• Advanced Array Functions

PowerShell Arrays

Arrays are a mutual feature of most all programming languages. They are a data construction that serves as a collection of multiple pieces of information. When working with an array, you lot can either use the same control to perform the same role on each item inside an array, or access and manipulate individual elements using an index.

Arrays in PowerShell tin contain 1 or more items. An item tin exist a string, an integer, an object, or even another array, and one array can contain whatsoever combination of these items. Each of these items has an index, which always starts (sometimes confusingly) at 0. So the outset particular in an array is given the index 0, the 2d is indexed every bit 1, and so on.

PowerShell arrays are such a fundamental role of PowerShell that they announced in every PowerShell tutorial out there, and a good knowledge of how to work with them is critical for many aspects of using PowerShell, from configuring Office 365 to using PowerShell for Pentesting.

An Example of a PowerShell Array

The easiest way to illustrate what an assortment is to take an example. Let's brand an array that represents a basin of fruit.

There are several ways to create arrays in Powershell, only the easiest is to run this control:

@()

This volition create an empty assortment. An empty array is not that useful, however, and then let's add some fruits to our new array. These volition exist represented as text strings. To practice that, run this command

$fruit = @('Apples','Oranges','Bananas')

This will name an array "fruit", and add three items to information technology. To run across that this has worked, you tin read the assortment using this command:

PS /Users/yourname> $fruit

Which will now return:

  Apples    Oranges    Bananas

Every bit you tin can see, this assortment is a grouping of individual pieces of data. PowerShell will automatically index them in the way nosotros've explained higher up: "Apple" will be indexed as 0, "Oranges" every bit ane, and "Bananas" as two.

This case might make it seem like arrays are quite simple objects, and in a way they are. Their simplicity, however, is as well what makes them such flexible, powerful objects. In the rest of this guide, nosotros'll give you lot a gustation of what you can do with arrays.

Array Fundamentals

In this department, nosotros'll look at the most bones ways to create and piece of work with arrays in PowerShell.

Create an Array

Start, we'll create an array. The standard style of doing this is to employ @(), though there are other ways.

For at present, let's create an array called "data". To exercise this, run:

$data = @()

This assortment is empty at the moment considering we haven't specified any information for it. To check how many items are in an array, we can use the count function:

$data.count

Which, at the moment, will return a 0, because in that location are no items in our array. To brand an array with some data in it, we put these data inside the parentheses after the @:

$data = @('Zero','One','Two','Iii')

Run the same count function now, and you lot'll see that in that location are iv items in this array. To run across these items over again, nosotros but invoke the assortment:

$data

Which will list the items we put in the assortment.

Accessing Items

Now we have an assortment, nosotros will want to access items from it. There are several means to do this. The first is to use the index of the items in the array. As we said earlier, indexes commencement at 0, so to retrieve the outset item in our assortment nosotros volition demand to tell PowerShell to look at the item whose index is nil. We do that by running:

$data[0]

This will return "zero" because that was the outset string we put in our assortment.

We tin can also extend this syntax to return multiple items from the aforementioned assortment, just by putting more indexes in the same control. For example, run:

$data[0,2,iii]

This will render "Zero Two Three". The items are returned in the same order that you entered the indexes. Yous tin can also use further syntax to render sets of items from an array. For instance:

$information[1..3]

Will render all items with an index between one and 3 (inclusive). And:

$data[-1]

Will return the last item in the array: the negative number tells PowerShell to count backward from the finish of the array, and then in this case, this command will return "Three", the last item in our test array.

Irresolute Items

The aforementioned method tin can be used to update the items in an array. For example, to update the item whose index is ii (remember that this is the third detail in the assortment), we can run:

$data[ii] = '2d'

This gives usa direct access to the items within an assortment.

Iterated Actions

One of the most powerful features of PowerShell (and, in fact, of whatever command-line interface) is the ability to perform the aforementioned activity on all the items in an array. There are a number of different ways of doing this.

The most bones is to use a Pipeline, which is the graphic symbol |. When you pass an array to a pipeline, each item in an assortment is candy individually. Every bit we've pointed out in our commodity on PowerShell objects and information piping, this is oftentimes the simplest mode to perform iterated actions.

For instance, to add together a description to each particular in our assortment, we can use this control:

$information | ForEach-Object {"Item: [$PSItem]"}

This command tells PowerShell to accept the items in $data one at a time, and and so for each of them add "Item: " to the beginning, followed by the original value.

There are several other ways to perform iterated actions in PowerShell, many of which will be familiar if y'all've used other programming languages: PowerShell includes ForEach loops, For loops, and Switch loops. For more details on these, check the Microsoft documentation.

Arrays of Objects

So far, nosotros've been working with an array that contains basic data: a cord. However, arrays can likewise comprise objects, and many of the almost common uses of PowerShell – like configuring Function 365 – require that you know how to work with objects. So permit's expect at some bones commands for doing that.

Creating an Array of Objects

Nosotros can create an array of objects in the aforementioned way that we did with strings, using the @() function. For instance, to make a exam list of employees, we tin employ:

$data = @(         [pscustomobject]@{FirstName='Kevin';LastName='Marquette'}         [pscustomobject]@{FirstName='John'; LastName='Doe'}     )

Most cmdlets volition return an array of this type when you assign them a variable to piece of work with.

Accessing Objects from Arrays

The process we ran through above to access individual pieces of data can every bit be used with arrays that incorporate objects. For instance, running:

$data[0]

Volition return:

   FirstName LastName      -----     ----      Kevin     Marquette

Alternatively, nosotros can access the properties of individual objects past specifying which property we would like within the same command, similar this:

$data[0].FirstName

Which will return "Kevin".

Updating Object Properties in Arrays

Going further, the aforementioned syntax gives us the capability of updating private properties inside objects that are held in arrays. For instance:

$data[0].FirstName = 'Jay'

Will update the FirstName property in the start particular in our array to "Jay".

Accessing Every Property in an Assortment of Objects

In most programming languages, we would have to use an iterative procedure (run across above) to access all the backdrop in an assortment of objects. We can do that in PowerShell equally well, of course, past running:

$data | ForEach-Object {$_.LastName}

This will return a list of all of the LastName properties in our assortment, simply it is computationally expensive and hard to write every time you desire to run into this information. So instead, PowerShell has a shortcut. Run this:

$data.LastName

And you volition see the same list. PowerShell is actually taking each object in turn, just as before, only it hides this complexity from us.

Operators For Arrays

Virtually all of the operators that we utilize for private information items in PowerShell will also work with arrays, only some of them work a little differently when used in this fashion. So let'south take a look at the almost common operators, and how y'all tin can apply them in arrays.

-join

The -join operator is i of the most used commands in PowerShell, and it is extremely useful when working with arrays. Information technology can be used iteratively on the items in an assortment to join them together in the output of an array.

Let's have an case. First, create a uncomplicated assortment:

$data = @(1,2,3,4)

And so use -join to insert a hyphen in betwixt each detail, and output the issue:

$data -join '-'

Which will render "ane-two-iii-iv". The -join operator tin likewise exist used without a delimiter, in which can the items in an array will be output equally a series of unseparated values.

-contains

The -contains operator works on arrays in a very like way to its usage with single data points. You tin can use it to check if an array contains a detail cord, and it will output a Boolean value. For instance:

    PS> $data = @('blood-red','greenish','bluish')      PS> $data -contains 'green'      True

Equalities

There are 2 operators for checking for equality in PowerShell: -eq and -ne. If y'all are used to using these on single values, though, the way that these work in relation to arrays can seem a little strange. If you lot use -eq, for instance, the operator will non output a Boolean "True", but instead volition return the object that matches.

For example:

    PS> $data = @('red','green','blue')      PS> $information -eq 'green'      green

The -ne operator works in much the same way, except that it will requite you all the values that are not equal to your specified value. And then:

    PS> $data = @('red','green','blue')      PS> $information -ne 'green'      red      bluish

You can, nonetheless, use an if() argument to compare the output of these operators with your expected output, and return a "Truthful" or "False" output.

How to Add Values to an Array

Later on all of the instructions in a higher place, you are probably wondering why we've left out adding data items to an array. That's considering there is no way of doing that. An array, once created, stays the aforementioned size forever, and so in guild to make it larger you need to copy it to a new array, and delete the original.

That sounds complicated, simply Powershell handles this procedure for you using a serial of pretty uncomplicated operators. At that place are two master ways to do this.

Array Add-on

PowerShell tin can add together two arrays together using the "+" operator, which hides the complexity of what the system is actually doing. For instance, if you brand two test arrays like this:

    $first = @(          'Cypher'          'I'      )      $second = @(          '2'          '3'      )

You tin then add them together using just:

    PS> $first + $second

This will make a new array with all 4 values, and output the results. Note, however, that it will not give this new array a new proper name. To do that, we use the += operator.

Plus Equals for Combining Arrays

Instead of using the "+" operator in the above example, nosotros could have used the "+=" operator, which will give us a whole new array:

    $commencement += 'Two, Three'

The command looks elementary, but it is hiding what PowerShell is actually doing hither. It is copying all of the values from $first, and making a new array that includes the extra values. It then deletes the original array.

This is somewhat problematic because it is computationally expensive. With small arrays, you might non detect, simply with large amounts of data this method tin can quickly lock up your system. That'due south why we've given you a style around this trouble, beneath.

Array Types

So far, nosotros've been dealing with default arrays in PowerShell. Though PowerShell didn't tell u.s. at the time, every array that nosotros've created so far is of one type, the [PSObject[]] blazon. This blazon of array can hold any type of information value.

Strongly Typed Arrays

However, there are times when you want to restrict the types of data or objects that an array can hold to just one. We can do this by using a strongly typed assortment, which can only contain the specified data type.

For instance, to make an array that can simply have integers, we tin can use:

    PS> [int[]] $numbers = i,two,iii

If you effort and put the wrong blazon of data value into a strongly typed assortment, information technology volition return an error code.

ArrayList

As nosotros've said above, adding items to arrays can be a hassle. However, at that place is a different type of collection – ArrayList – that handles this more elegantly. In club to utilize this type of collection, however, we will have to invoke the .Net framework, which tin can throw some unfortunate outputs in our style.

To create an ArrayList, and then add together items to it, run the following:

   $myarray = [System.Collections.ArrayList]::new()      [void]$myArray.Add together('Value')

Here, we can utilize the default .Cyberspace constructor to create a new ArrayList, and so using the -Add operator to add items to it. The [void] operator is there considering sometimes these commands throw out strange outputs that tin can mess with the code.

Going Further

These are the nigh mutual assortment types in PowerShell, but there are a few others. If you lot are developing as a PowerShell user, information technology's useful to start using ArrayLists instead of straight arrays, just you should also be aware that this type of array is not used past advanced users.

Instead, near experienced coders will utilize a generic list type called List[]. This type of list is a petty more circuitous to use because it is derived straight from C#, but one time yous've mastered information technology, information technology offers far more than flexibility than the arrays we've discussed so far.

Advanced Array Functions

In improver to the bones functionality nosotros've covered then far, at that place are also a number of more avant-garde array functions, and some extra features to note, as y'all start to utilise them more ofttimes.

Pre-Sized Arrays

The standard fashion of creating arrays above will create an array with a size determined by the number of items in it. However, you tin create an array of a specified size by using the new($size) constructor.

You tin can practice that like this:

    $data = [Object[]]::new(four)

If you run a .count query on this array, it volition render "4", considering even though it doesn't take information in it, it will fill the space with 0. This is actually extremely useful if you need to initialize a new assortment that is filled with zeroes because a pre-sized array volition initially be filled with 0.

Multiplying Arrays

Multiplying the objects in an assortment – and particularly strings – is something that confuses most people when they first have to do it. Nosotros've seen extremely complicated if() scripts to achieve this outcome, but in that location is a much simpler manner:

    PS> $data = @('red','green','bluish')      PS> $data * iii

Yep, that's correct. This will create a new array with each value repeated 3 times. You can besides use this control as an culling way to fill an array with zeros (or any other default value) by making an assortment with your called value, and and then multiplying information technology as many times as you like.

Nested Arrays

Similar many other programming languages, PowerShell supports nested arrays. The standard way of doing this in PowerShell is to utilise a multi-dimensional array. The simplest case of this is to create a two-dimensional array:

   $data = @(@(1,2,three),@(iv,5,half dozen),@(vii,viii,9))         $data2 = @(          @(one,2,three),          @(iv,5,6),          @(vii,8,ix)      )

The information structure you are making with this command is a classic matrix, and it tin be worked with like those in other programming languages. For instance, to access a particular value from this array, yous will demand to specify two dimensions.

For example, to access the value "3", nosotros would utilize this:

    PS> $outside = 0      PS> $inside = ii      PS> $data[$outside][$inside]      3

This command can then exist used to admission any value, only you lot need to add together nested brackets to get inside each level of the matrix.

A Concluding Word

All of the instructions above might be a lot for users who are first coming to PowerShell, but they take been carefully chosen as a way of learning the language. By combining the various techniques, y'all tin build powerful scripts to automate many of the near frequent – and near time consuming – work you lot exercise with PowerShell.

These skills volition also help y'all to go beyond PowerShell. Many of the most common languages used for managing cybersecurity, like NetCat and Nmap, apply many of the same principles that PowerShell does. And then using PowerShell to improve your cybersecurity is a great way to learn how to secure your systems more generally.

yanganted1951.blogspot.com

Source: https://www.varonis.com/blog/powershell-array

Share this post