Коллекция power shell stack

$array = 1, 2, 3, 4, 5

$array = $array + 6

$array = $array | Where-Object { $_ -ne 3 }

$thirdElement = $array[2]

$array[2] = 10

$arrayList = New-Object System.Collections.ArrayList

$arrayList.Add(1)
$arrayList.Add(2)

$arrayList.AddRange(@(3, 4, 5))

$arrayList.Remove(3)

$arrayList.RemoveAt(0)

$thirdElement = $arrayList[2]
$arrayList[2] = 10

# Array
$array = 1, 2, 3
$array = $array + 4
# ArrayList
$arrayList = New-Object System.Collections.ArrayList
$arrayList.AddRange(@(1, 2, 3))
$arrayList.Add(4)

# Array
$array = 1, 2, 3, 4, 5
$array = $array | Where-Object { $_ -ne 3 }
# ArrayList
$arrayList = New-Object System.Collections.ArrayList
$arrayList.AddRange(@(1, 2, 3, 4, 5))
$arrayList.Remove(3)

# Array
$array = 1, 2, 3, 4, 5
$array[2] = 10
# ArrayList
$arrayList = New-Object System.Collections.ArrayList
$arrayList.AddRange(@(1, 2, 3, 4, 5))
$arrayList[2] = 10

An array is a  data structure that can hold more than one value at a time. Think of it as a collection or a list of items of the same or different data types. Arrays are used in many scripting and programming languages, including Windows PowerShell.  

Let’s delve into how to create and use an array in PowerShell.

Creating an Array of Objects

By default, each item in an array is an object, rather than another data type like string or integer. Here is an example of how to create an array of objects by explicitly adding objects:

$people = @(
    [PSCustomObject]@{Name='Alice'; Age=30},
    [PSCustomObject]@{Name='Bob'; Age=25}

Creating an Array with Just One Element

If you put just one value in a variable, then PowerShell will not create an array. To confirm this, let’s use two scripts and output their data types.

First, we will create an array in PowerShell with five elements:

$array = @(1, 2, 3, 4, 5)
$array1.GetType()

Now let’s try to use a similar script to create an array with just one element:

$array1 = 1
$array1.GetType()

As you can see from the output below, PowerShell created an array (System.Array) for the first example script but not the second.

This behavior is particularly concerning if you want to create an array by retrieving objects by executing a particular command, since you do not know in advance how many objects will be returned in the results.

To get around this issue, you can use the , (comma) operator. If a comma is used as a binary operator, then a normal array is created; if it is used as a unary operator, the array has just one element.

For example, here is how we can get an array consisting of one element:

$array1 = ,1
$array1.GetType()

We can confirm the creation of the array with the output shown below:

Creating an Empty Array

$array3 = @()
$array3.GetType()

Creating a Strongly Typed Array

By default, the elements of an array can have different data types. But you can also create arrays that accept only values of a single designated type. Trying to add a value of a different type will produce an error.  Here is how to create the most common strongly typed arrays:

[int[]]$intArray = 1, 2, 3

[string[]]$strArray = "one", "two", "three"

[datetime[]]$dateArray = (Get-Date), (Get-Date).AddDays(1)

Creating a Multidimensional Array (Matrix)

By nesting arrays using commas, you can create a structured arrangement of data in rows or columns. Here we create a 3×3 matrix:

Comparing, Grouping, Selecting and Sorting Arrays

Other useful PowerShell cmdlets for working with arrays include:

• Compare-Object — Compares two arrays and returns the differences.
• Group-Object — Groups array elements based on property values.
• Select-Object — Selects specified properties of an object or set of objects, and can also be used to select a specific number of elements from an array.
• Sort-Object — Used to sort arrays that contain only one data type, as shown below:

$array = @(3, 1, 4, 2)
$sortedArray = $array | Sort-Object

Looping through an Array

$array8 = @("Earth","Mercury","Venus","Jupiter","Saturn","Mars", "Neptune", "Pluto")
foreach ($array in $array8) {
 "$array = " + $array.length
}

The result will look like this:

Using a Pipeline

The pipeline is used in PowerShell to pass the output of one command as the input to another. When working with arrays, you can use the pipeline to process and manipulate the data in the array and assign the results to a new array or modify the existing one.

Here we will multiply each array item by 2:

$numbers = 1,2,3,4,5
$doubled = $numbers | ForEach-Object { $_ * 2 }

Adding to an Array

The size of an array in PowerShell is immutable once it is defined. However, the operator += enables you to create a new array by appending items to an existing array — essentially creating a new combined array.

$array = @(1, 2, 3)
$array += 4

Creating an ArrayList

For large arrays or frequent additions, use of += can be a performance concern, since every time use it, a new array is created, the old elements are copied over and the new element is added to the end. In those cases, you may want to use an ArrayList.

The size of an ArrayList is mutable, so you can add or remove items without having to recreate the entire collection. Like a standard array, an ArrayList can hold items of different data types.

Here is the cmdlet to create an ArrayList:

$array3 = New-Object System.Collections.ArrayList

Removing an Item from an Array

Now let’s use an ArrayList to remove an item from an array. First let’s create an array.

$array5 = "one", "two", "three", "four", "five"
$array5.gettype()

Now we will add it to an ArrayList so we can easily modify it.

[System.Collections.ArrayList]$ArrayList1 = $array5
$ArrayList1.GetType()

We will then use the .Remove command.

$ArrayList1.Remove("three")

Clearing an Array

There is no defined way to delete an array, but there are several ways to get rid of the contents of an array (clear it). One is to assign the variable $null to the array:

$array7 = $null
$array7

Here is another way to clear an array:

$array = @("element1", "element2", "element3")
$array = @()

Here is how to clear an ArrayList:

$arrayList = New-Object System.Collections.ArrayList
$arrayList.Add("element1")
$arrayList.Add("element2")
$arrayList.Clear()

Printing an Array

The easiest way to display the contents of an array is to simply reference the array variable. The example below shows how to include the text “Element:” before each item in the array:

To write to a .txt file, use the Out-File command:

$var5 | Out-File C:scriptsarray.txt

To export to a .csv file, use the Export-Csv command:

$var6 | Export-Csv -Path C:scriptsarray.csv

Filtering an Array

We can use the Where-Object cmdlet to retrieve only the even numbers from an array:

$numbers = 1,2,3,4,5,6
$evenNumbers = $numbers | Where-Object { $_ % 2 -eq 0 }
$evenNumbers

Alternatively, we can use the .Where() method, which it does not require a pipeline:

$numbers = 1,2,3,4,5,6
$evenNumbers = $numbers.Where({ $_ % 2 -eq 0 })
$evenNumbers

Checking the Length of an Array

To return the number of elements in array, use the .length parameter:

$array6 = 1,2,3,4,5,6
echo $array6.Length

Checking Whether an Array Contains a Particular Value

If you want to see if any of the elements in an array contains a particular value, use the Contains method. This code will show whether an array contains either a 2 or a 12:

$array7 = 1,2,5,8,3,4,5
$array7.Contains(2)
$array7.Contains(12)

Accessing Items using the Array Index

As with most programming languages, each individual item in a PowerShell array can be accessed by an index. The index of an array starts at zero, so in an array of three items, the first item is at index 0, the second is at index 1, and the third is at index 2.

To access items using the array index, you need to provide the index in square brackets after the array variable. Below is an example showing how to create an array show the second element:

$colors = "Red", "Green", "Blue", "Yellow"
$secondColor = $colors[1]
Write-Output $secondColor

You can access items from the end of an array by using a negative index. -1 refers to the last item, -2 refers to the second from the last item, etc.

Using the Join Operator and the Split Operator

In PowerShell, the join operator is used to append an array of strings into a single string, optionally using a specified delimiter. Here is an example without a delimiter.

$array = "Power", "Shell"
$joined = $array -join ""
# Output: "PowerShell"

Here is what it would be with a delimiter:

The split operator essentially does the opposite of the join operator, as shown in the example below:

$string = "apple,banana,grape"
$fruits = $string -split ","

Using the Replace Operator

The replace operator is used to replace one string with another. Here is the cmdlet structure:

<originalString> -replace <patternToFind>, <replacementString>

Here is an example that will replace “Hello World” with “PowerShell”:

$string = "Hello World"
$newString = $string -replace "World", "PowerShell"

Slicing an Array

You can create a sub-array by specifying a range, as shown here:

$array = 1,2,3,4,5,6,7,8,9
$subset = $array[3..6]

Reversing an Array

Here is an example of how to reverse the order of the elements in an array:

$numbers = 1..5
[Array]::Reverse($numbers)

Arrays are a fundamental data structure in most scripting and programming languages because they enable you to store, retrieve and manipulate a collection of items of various data types. Understanding arrays will enhance your ability to automate tasks using PowerShell.

Now Netwrix Can Help

Netwrix GroupID empowers you to:

• Automate user provisioning and deprovisioning from your HR information system (HRIS) to Active Directory, Entra ID and SCIM-enabled applications, thereby enabling new employees to quickly be productive and slashing the risk of adversaries taking over stale identities.
• Automatically update directory groups based on changes like an employee’s promotion or shift to another role, as recorded in your HRIS. This automation keeps access rights updated in near real time as required for security and compliance, while saving your IT team time.
• Delegate group and user management to the people who know who should have access to what. Simple workflows enable line-of-business owners to review their groups and approve or deny user access requests, reducing the risk of having over-privileged groups and users in your directory.
• Keep the directory clean and easier to manage with automated user creation, expiration and deletion.
• Maintain and prove compliance with regulations and standards with deep insight, effective automation and clear reporting on groups and members.

It sounds like what you are looking for is a Hashtable. Hashtables work on a Key = Value basis, so you would choose or generate a key that you can reference later to retrieve the desired value. For example, let us say that you have Event1 saved in $Event1 and Event2 saved in $Event2. You could then form a hashtable like this:

$Events = @{ 'Event1' = $Event1 'Event2' = $Event2
}

Then later you can recall a specific event by referencing the key like this:

$Events['Event1']

Or, to just get the ThreatID of Event2 you could do this:

$Events['Event2'].ThreatID

The keys can be anything, but remember that you need to have some way to reference that thing, so often times strings are the easiest way to do it.

Edit: In response to how you would add the same keys from multiple events to the same hashtable, the answer is you wouldn’t. The point is to have a unique identifier for the key, and the entire event as the value. There’s a couple ways to do that. The first way is to determine a unique value that each event has (in this example I will use DetectionID which is a unique identifier for each threat detection as noted here). You could do:

# Create empty hashtable
$Events =@{}
# Iterate through results, and add each event to the hashtable by DetectionID
Get-MpThreatDetection | Where-Object {$_.InitialDetectionTime -ge $time} | ForEach-Object{ $Events.Add($_.DetectionID, $_)
}

Then later you can reference any event by the DetectionID. Like this:

PS C:\Windows\System32> $Events['009c9051-71cc-479f-ae8f-1bff94ad1e3b'].ThreatID
2147593794

Alternatively you could just capture all events in a simple array, and then reference events by their index. That would look more like this:

PS C:\Windows\System32> $Events = Get-MpThreatDetection | Where-Object {$_.InitialDetectionTime -ge $time}
PS C:\Windows\System32> $Events[0].initialdetectiontime
23/08/2023 21:31:04
PS C:\Windows\System32> $Events[1].Resources
file:_D:\KeyGen\keygen.exe

Like other programming languages, arrays provide a simple way to store a list of items in PowerShell. However, standard PowerShell arrays have limitations – they are fixed-sized and don’t provide many helpful methods to manipulate the array contents. This is where ArrayLists come in. The ArrayList is one of the most useful collection types in PowerShell. It provides a dynamic array that can grow and shrink as needed. ArrayLists make it easy to add, remove, sort, and update items in the collection.

In this post, you will learn how to:

• Create ArrayLists in PowerShell
• Add, insert, and remove items from an ArrayList
• Resize ArrayLists dynamically
• Sort and reverse ArrayLists
• Access items by index
• Concatenate multiple ArrayLists
• Convert between ArrayList and arrays
• Search for items in an ArrayList

In this comprehensive guide, we will delve into the depths of the PowerShell ArrayList, from creation to manipulation, uncovering its features and benefits, troubleshooting common errors, and sharing tips to optimize your script performance.

Understanding ArrayList and its Benefits in PowerShell

Understanding how to work with ArrayLists unlocks more flexible scripting capabilities. The ArrayList is a generic List collection type found in the System.Collections.ArrayList class. You can store ordered collections of any object type, like strings, numbers, custom objects, etc. Unlike the traditional PowerShell array, ArrayList can grow and shrink dynamically, making it ideal for situations where the number of elements is not known in advance or needs to change over time.

The benefits of using an ArrayList in PowerShell are numerous:

1. Dynamic size: As mentioned earlier, ArrayList can grow and shrink dynamically, unlike the traditional array in PowerShell. This means you can easily add or remove elements without worrying about resizing the array or losing data.
2. Improved performance: ArrayList provides better performance compared to the traditional array, especially when dealing with large volumes of data. This is because ArrayList uses a more efficient method of storing and retrieving data, which reduces the time and resources required to process your scripts.
3. Compatibility: ArrayList is compatible with other PowerShell objects and can be easily converted to different data types, such as strings or arrays. This makes it a versatile choice for working with various data sources and formats.
4. Rich built-in methods: ArrayList provides several built-in methods for manipulating and processing data. These methods include adding elements, removing elements, sorting, and searching, among others.

PowerShell ArrayList vs. Array: Key differences

• ArrayList is a dynamic collection of objects that can grow and shrink dynamically, while Array is a static collection of objects with a fixed size. This means that once an Array is created, its size cannot be changed.
• ArrayList provides better performance compared to Array when dealing with large volumes of data or when the number of elements is not known in advance. This is because ArrayList uses a more efficient method of storing and retrieving data, which reduces the time and resources required to process your scripts.
• PowerShell Arrays are strongly typed (meaning they can only store elements of a specific type). In contrast, ArrayLists can store values of any data type.
• On the other hand, Array offers better performance when dealing with a small number of elements or when the size of the collection is fixed. This is because Array uses a more straightforward method of storing and retrieving data, which can be faster than ArrayList in some cases.

When choosing between PowerShell Array List and Array, consider the size and nature of your data, as well as the performance requirements of your script. Here is another post on using arrays in PowerShell: How to use Arrays in PowerShell?

Creating an ArrayList in PowerShell

$arrayList = New-Object -TypeName System.Collections.ArrayList

This initializes an empty ArrayList. Alternatively, you can use type accelerators to create a new array list variable:

$ArrayList = [System.Collections.ArrayList]::new()

Initialize ArrayList with a capacity: When creating an ArrayList, it’s a good idea to initialize it with a capacity close to the expected number of elements. This can help reduce the number of memory allocations and improve the performance of your script. For example, if you expect your ArrayList to have approximately 100 elements, you can create it like this:

$ArrayList = New-Object -TypeName System.Collections.ArrayList -ArgumentList 100

$ArrayList = [System.Collections.ArrayList]@("Banana", "Cherry", "Apple","Orange")

Both methods will create a new ArrayList object, which you can then use to store and manipulate data in your PowerShell script.

Unlike the default array, the ArrayList can contain a mix of data types. E.g., let’s say you want to create an “Employee” ArrayList with Employee Number, Employee Name, and Date of Join values:

$Employee = New-Object System.Collections.ArrayList
$Employee.Add(001)
$Employee.Add("Steve Johnson")
$Employee.Add([DateTime]"01/01/2021")

Adding elements to PowerShell ArrayList

Once your ArrayList is created, Adding elements to a PowerShell ArrayList is easy, with the help of the built-in Add() method. This method allows you to add a single element to the end of the ArrayList:

Alternatively, you can use the AddRange() method to ArrayList with a set of initial values.

$Fruits = @("Banana", "Cherry", "Date")
$ArrayList.AddRange($Fruits)

$initialValues = 1..5
$arrayList = New-Object -TypeName System.Collections.ArrayList
$arrayList.AddRange($initialValues)

Here is another way to add multiple elements to an array list with the help of a Loop:

#Create a Array List
$ArrayList = New-Object System.Collections.ArrayList
#Add Elements to Array List
@(0..100).ForEach({$ArrayList.Add($_)})

Additionally, the Insert() method can be used to insert an element at a specific index within the ArrayList:

$arrayList.Insert(0, "Plums")

This code will insert “Plums” at the beginning of the ArrayList (index 0). Keep in mind that the index is zero-based, meaning that the first element has an index of 0, the second element has an index of 1, and so on.

You can use the GetType() method to retrieve the data type of an element stored in the ArrayList. E.g.,

$ArrayList[0].GetType().Name

Access and Retrieve Elements

To get the number of elements in ArrayList:

To retrieve an element by index:

$item1 = $Arraylist[0]
$item2 = $Arraylist[1]

You can access elements just like a standard PowerShell array.

To retrieve the last element:

$LastItem = $ArrayList[-1]

Loop Through ArrayList with Foreach

To process all elements in ArrayList, use Foreach:

ForEach ($Element in $ArrayList) { # Do something with $Element Write-Output $Element
}

This iterates through each element sequentially. You can also use a for loop with Count:

For($i=0; $i -lt $Arraylist.Count; $i++) { # Do something with $element $element = $arraylist[$i] Write-host $Element
}

Here is another form:

$ArrayList | ForEach-Object { Write-Host $_
}

Modifying ArrayList elements in PowerShell

Once you have an ArrayList in your PowerShell script, there are several methods available to manipulate and modify its elements. To change the value of an element in an ArrayList, you can use the set_Item() method or the array index notation. For example, to update the first element, you can use:

$ArrayList.set_Item(0, "Updated Element")
#Another way
$ArrayList[0] = "Updated Element".

We will explore more advanced manipulation techniques, such as sorting, reversing, and searching, in a later section of this article.

Removing elements from a PowerShell ArrayList

Removing elements from a PowerShell ArrayList is a common operation that can be done using the Remove(), RemoveRange() or RemoveAt() methods. Whether you want to remove a specific element, or multiple elements, or even clear the entire list, there’s a method to help you do just that. Here’s how:

The Remove() method removes the first occurrence of a specified element, while the RemoveAt() method removes the element at a specific index.

$arrayList.Remove("apple")

Removing a Range of Elements

The RemoveRange method allows you to remove a range of elements by specifying the starting index and the number of elements to remove parameters:

$ArrayList.RemoveRange(0,2) # This will remove the first two elements

To remove all items from the ArrayList, use the Clear() method:

Clear() empties the entire ArrayList.

Keep in mind that these methods modify the original Array List object, so use them with caution and ensure that you are removing the correct elements.

Sorting, reversing, and searching PowerShell ArrayLists

PowerShell ArrayList provides several methods for manipulating and processing data, such as sorting, reversing, and searching.

$ArrayList.Sort()
$ArrayList.Reverse()

This code will first sort the ArrayList in ascending order and then reverse the order to get the elements in descending order. The Sort-Object cmdlet also can be used for sorting elements in the array:

$SortedArrayList = $ArrayList | Sort-Object

if ($ArrayList.Contains("apple")) { Write-Host "ArrayList contains 'apple'"
}

This code will check if the ArrayList contains the element “apple” and print a message if it does. 

Convert Between ArrayList and Arrays

You can easily convert between ArrayList and standard PowerShell arrays:

Convert ArrayList to array

To convert an ArrayList to an array, use the typecasting as:

$Array = [array]$ArrayList

You can also use the ToArray() method:

$array = $arraylist.ToArray()

How about the reverse? To convert an existing array to ArrayList, use:

$arraylist = [System.Collections.ArrayList]$array

The array or ArrayList gets cast to the target type automatically.

Converting PowerShell ArrayList to string

$string = $arrayList -join ', '

Or, using the String.Join() method:

$string = [System.String]::Join(', ', $arrayList)

Both methods will create a new string containing the elements of the ArrayList, separated by the specified delimiter (a comma and a space in this case).

Join Multiple ArrayLists

To combine multiple ArrayLists:

$arraylist1 = [System.Collections.ArrayList]@(1, 2, 3)
$arraylist2 = [System.Collections.ArrayList]@(4, 5, 6)
$result = $arraylist1.Clone()
$result.AddRange($arraylist2)

Clone() makes a copy before appending $arraylist2 to avoid modifying the original.

Filter ArrayList

You can filter elements in ArrayList using the Where method:

#Create a Array List with values: 1 to 10
$Values = 1..10
$ArrayList = New-Object -TypeName System.Collections.ArrayList
$ArrayList.AddRange($Values)
#Filter Array List
$Arraylist = $ArrayList.Where{$_ -ge 5}

Alternatively, You can use the Where-Object cmdlet to Filter Array elements:

#Filter ArrayList
$MyArraylist = $ArrayList | Where-Object {$_ -ge 5}

Export ArrayList to CSV

Let’s say you have an ArrayList like this:

$ArrayList = New-Object System.Collections.ArrayList
$ArrayList.Add("Apple")
$ArrayList.Add("Banana")
$ArrayList.Add("Cherry")

The challenge here is that this ArrayList contains simple string data, and Export-Csv expects objects with properties. To resolve this, you could create a custom object array from these simple data types, like:

#Convert ArrayList to Object array
$Objects = $ArrayList | ForEach-Object { [PSCustomObject]@{Fruit = $_} }
#Export Array to CSV
$Objects | Export-Csv -Path "C:\Temp\Fruits.csv" -NoTypeInformation

PowerShell Import CSV to ArrayList

You can import a CSV file into an ArrayList using Import-Csv and a ForEach loop.

$csvData = Import-Csv -Path 'C:\Temp\Fruits.csv'
$ArrayList = New-Object System.Collections.ArrayList
ForEach ($row in $csvData) { $ArrayList.Add($row)
}

Common errors and troubleshooting in PowerShell ArrayList

As you work with PowerShell ArrayList, you may encounter some common errors or issues. In this section, we will discuss some of these errors and provide tips for troubleshooting and resolving them.

1. Index out of range: This error occurs when you try to access or modify an element at an index that does not exist in the ArrayList. To avoid this error, always ensure that the index you are using is within the bounds of the ArrayList. You can use the Count property to get the number of elements in the ArrayList.
2. InvalidCastException: This error occurs when you try to convert an element in the ArrayList to an incompatible data type. To fix this error, ensure that you are using the correct data type for the element in question or use the appropriate conversion methods provided by PowerShell and the .NET Framework.
3. Adding elements of different data types: While it is possible to store elements of different data types in an ArrayList, doing so can lead to unexpected behavior and performance issues. To avoid this, try to use a consistent data type for all elements in the ArrayList or consider using a different collection type, such as a Hashtable or a custom object.

Real-world applications of PowerShell ArrayList

PowerShell ArrayList can be used in a variety of real-world scenarios, such as:

1. Log file processing: ArrayList can be used to store and process log file data, allowing you to filter, sort, and analyze log entries efficiently.
2. Inventory management: PowerShell ArrayList can be utilized to store and manage inventory data, such as computer names, IP addresses, and hardware details.
3. Data processing: ArrayList can be employed in data processing tasks, such as parsing CSV files, processing XML data, or handling JSON objects.
4. Script optimization: As mentioned earlier, using ArrayList can help improve the performance of your PowerShell scripts, making it a valuable tool for script optimization tasks.
5. Storing ordered collections like lists of servers, users, etc., that change frequently
6. Collecting output from loops and pipelines before exporting to CSV

Conclusion

ArrayLists provide a powerful alternative to standard PowerShell arrays for storing dynamic collections. In this comprehensive guide, we have covered the essentials of PowerShell ArrayList, from creation and manipulation to troubleshooting common errors of this fantastic data structure. We have also explored real-world use cases and provided tips for optimizing script performance. By understanding the features and benefits of ArrayList, you can easily store and manipulate data in a dynamic and efficient way.

Skip to content

The PowerShell Stack collection

The PowerShell Stack collection

In a C# video, I heard about the System.collections.stack collection (PowerShell Stack Collection). I didn’t knew what it was, so I looked it up, read about it, and applied it to powershell immediatley.

In this article I will go through what the System.collections.stack actually is, and in what cases it should be used. I’ll explain of course how to use in Powershell, and showcase some examples where one might want to use them.  In a nutshell, when used in powershell, the system.collections.stack allows to handle elements in an array by and them in a specific order using specific methods (push / pop & peek).

Luckly enough, anything that works in .Net (should) also work(s) in Powershell. So, let’s try it out 🙂

The System.Collection.Stack follows the principle of last in, first out.

A simple example of the powershell stack collection would be the following one: (Don’t worry to much about the syntax here, I cover the ‘push‘ method in detail a bit further down in this article).

You’ll notice that the last object I added (the “district” one) is displayed at first. This is the whole purpose of the powershell stack collection. The powershell stack collection allows you to “stack” items (objects, etc..) one on top of each other.

 As opposed with the queue collection, wich returns the most old item in the collection (The one added first), the powershell Stack collection will return the last item you added to the collection (The most recent one). So, in other words The last item you added, will be the first one to be returned.

Use cases for the powershell system.collections.stack collection:

I haven’t really found a use case for this (yet) in my daily work, but, it worth to know it exists, and it could be usefull if we meet a use case once.

Daniel Meier comment this article on Facebook, explained how he has been using the Stack Collection:

“I’ve used stacks when changing directories. I’ll put the current directory on the stack then cd to a new directory, put it on the stack, etc. Then I can go back out of each directory to the previous one. I do this when walking a directory tree.”

Indeed, that is a perfect use case! Needing to go through () a specific path (Directory, Registry, List, WebSite). It allows to use the exact same opposite path when moving back.

If you have used the powershell Stack collection before, please share with us for what use case you have used it (via the comment section below).

In the mean time, below I explain how the powershell stack collection works.

Methods and properties you don’t want to miss:

Lets have a look at the members of our collection object:

We will focus on the three most interesting ones of the stack array:

• push
• pop
• peek

the .push() method

As you could have noticed before, in our stack example above, we already used the push() method, and not add() (which doesn’t exists on the stack object type).

As demonstrated earlier, the push() method allows us to add a new element onto our stack. yes onto our stack, not into the stack.

The Pop() method

The pop method will give us the possibility to retrieve the item on the top of our stack. This means, that the pop() method returns the last item that has been added.

As you can see, “district” was the last item that we added, but the first one to be returned when we called the pop() method.

The Peek() method:

The peek method will work exactly as the pop() method, except,  that the item that was returned will not be removed from the stack. As it’s name suggest, it allows you to peek onto the stack, and to see what would eventually  be returned if you would call the pop() method.

AS you can see in the example above, the peek method (in red) returns the item, but doesn’t removes it from the powershell stack collection.

Using the pop method, returns the “gulick” item just as the peek method informed us it would do, and in this case, removed it from the stack item.

A word about the ‘count’ property:

The stack collection instance comes with a ‘count‘ property (yes, a property, not a method!). It allows (as you might have guessed) to get the count of the number of items in your current powershell stack collection. This is a convenient property to check, to go through your stack collection as showcased in the following example:

0 “Returning Element -> $($mystack.Peek())” “End of example”

The powershell Stack collection allows us to go through a collection, and return each item using a loop such as a foreach or a for statement.

Conclusion:

This can be really handy since it allow you to go through collections of objects/ items without the need to iterate through them, or even to know how many items you currently have.
The second positive thing is that you can now ‘really’ have way of controlling the order in which each element will be treated. Since we know that the pop() method of the powershell stack collection returns the most item from the collection (the last one added).

Have you used a stack collection already in one of your scripts? I’ll be curious to know how you used. Let us know!

Links

MSDN link to the Collections.Stack –> msdn

“See you in the next article :)”

 

Share This Story, Choose Your Platform!

Related Posts

Page load link

Похожее:

Список power shell array: руководство для начинающих Как составить имена файлов только в power shell DPC Latency Checker 1.3 Download (Free) – dpclat.exe Удалить обновление при помощи DISM.