{"id":8152,"date":"2014-11-18T06:00:00","date_gmt":"2014-11-18T14:00:00","guid":{"rendered":"http:\/\/www.sapien.com\/blog\/?p=8152"},"modified":"2014-11-19T09:31:09","modified_gmt":"2014-11-19T17:31:09","slug":"removing-objects-from-arrays-in-powershell","status":"publish","type":"post","link":"https:\/\/dev.sapien.com\/blog\/2014\/11\/18\/removing-objects-from-arrays-in-powershell\/","title":{"rendered":"Removing Objects from Arrays in PowerShell"},"content":{"rendered":"

 <\/p>\n

A member of the PowerShell group on Facebook<\/a> asked how to delete an object from an array. It’s a simple question, but the answer isn’t very simple at all. It’s one of those beginner questions that has an advanced answer.<\/p>\n

When I first answered this question in about_Arrays<\/a>, I didn’t really know much about the subject and I used the (very good) answer that the team gave me. But that answer was incomplete, and while there are many good posts on the topic, none really cover the whole scope of pitfalls.<\/p>\n

[Be sure to start with about_Arrays. I’ll assume that you’ve read it and won’t repeat the basics of arrays that are described there.]<\/p>\n

 <\/p>\n

Why is removing difficult?<\/h2>\n

Removing objects from arrays should be simple, but the default collection type in Windows PowerShell, an object array (System.Object[]), has a fixed size. You can change objects in the array, but you can’t add or delete them, because that would change the size of the array.<\/p>\n

Let’s look at the problem. I\u2019ll create an array called $letters<\/strong> and save a few letters in the array.<\/p>\n

 $letters<\/span> =<\/span> \"a\"<\/span>, <\/span>\"b\"<\/span>, <\/span>\"c\"<\/span>, <\/span>\"d\"<\/span><\/pre>\n
 <\/p>\n
Now, I\u2019ll try to remove the \u201cc\u201d from the array.<\/p>\n
    $letters<\/span> =<\/span> $letters<\/span> -<\/span> \"c\"<\/span><\/pre>\n
Method invocation failed because [System.Object[]] does not contain a method named ‘op_Subtraction’.
\nAt line:1 char:2
\n+\u00a0 $letters = $letters – “c”
\n+\u00a0 ~~~~~~~~~~~~~~~~~~~~~~~~~
\n+ CategoryInfo\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : InvalidOperation: (op_Subtraction:String) [], RuntimeException
\n+ FullyQualifiedErrorId : MethodNotFound<\/span><\/p><\/blockquote>\n
That didn’t work, because object arrays [System.Object[]) don’t have a subtraction (op_Subtraction) method. Let’s find the methods that System.Object[] supports.<\/p>\n
Typically, to get the type, methods, and properties of an object, you pipe it to the Get-Member<\/b> cmdlet. But, when you pipe a collection of objects to Get-Member, Get-Member gets the members of objects in the collection. To get the members of the collection (not the objects that it contains), use its InputObject<\/b> parameter.<\/p>\n
 <\/p>\n
\"image\"<\/a><\/p><\/blockquote>\n
This command reveals that object arrays, like the one in the $letters variable have a Remove<\/strong> method. Let’s try the Remove<\/strong> method.<\/p>\n
\"image\"<\/a><\/p><\/blockquote>\n
Remove fails, because object arrays are a fixed size.<\/p>\n
This is where beginners get stuck and even experienced users hit Google, Facebook, or a PowerShell forum for help.<\/p>\n
<\/h4>\n
Create a new array<\/h2>\n
One way to remove an object from a fixed-size array is to create a new array that includes only selected objects from the original array. In this command, we use a ForEach loop go through every letter in the $letters array. We add all of the objects in $letters to the $newLetters array, except for “c”. To add objects to the new array, use the + or += operators; the statements are equivalent.<\/p>\n
    $newLetters<\/span> =<\/span> @()\r\n    <\/span>foreach<\/span> (<\/span>$letter<\/span> in<\/span> $letters<\/span>)\r\n    {\r\n        <\/span>if<\/span> (<\/span>$letter<\/span> -ne<\/span> \"c\"<\/span>)\r\n        {\r\n            <\/span>#$newLetters = $newLetters + $letter<\/span>\r\n            $newLetters<\/span> =<\/span> $newLetters<\/span> +=<\/span> $letter<\/span>\r\n        }\r\n    }<\/span><\/pre>\n
PS C:\\> $newLetters
\na
\nb
\nd<\/span><\/p><\/blockquote>\n
 <\/p>\n
Interestingly, when we use the + or += operators, Windows PowerShell actually creates a new array each time in the background, because you can\u2019t change the size of array. Sadly, there is no \u2013= operator. Also, in this very simple example, it\u2019s easier use the Where-Object cmdlet to filter out the “c”, but we can assume that you\u2019re using an array for a more complex task.<\/p>\n
\n
$newLetters<\/span> =<\/span> $letters<\/span> |<\/span> Where-Object<\/span> { <\/span>$_<\/span> \u2013<\/span>ne<\/span> \"c\" }<\/span><\/pre>\n<\/blockquote>\n
 <\/p>\n
You can also use array index notation to exclude items from the new array. In this command, we add the items at indexes 0, 1, and 3 from $letters to the $newLetters array, but we exclude the item at index 2.<\/p>\n
    $newLetters<\/span> =<\/span> $letters<\/span>[<\/span>0<\/span>, <\/span>1<\/span>, <\/span>3<\/span>]<\/span><\/pre>\n
 <\/p>\n
You can reuse the $letters variable name, but you are still creating a new $letters array that is independent of the original one.<\/p>\n
    $letters<\/span> =<\/span> $letters<\/span>[<\/span>0<\/span>, <\/span>1<\/span>, <\/span>3<\/span>]<\/span><\/pre>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
Use an ArrayList<\/h2>\n
My favorite solution to the \u201ccollection was of a fixed size\u201d problem is to create an ArrayList<\/strong> (System.Collections.ArrayList<\/a>), instead of the default object array (System.Object[]). ArrayLists behave like arrays, but unlike arrays, ArrayList objects don\u2019t have a fixed size.<\/p>\n
To create an array list, cast the variable:<\/p>\n
    [<\/span>System.Collections.ArrayList<\/span>]<\/span>$caps<\/span> =<\/span> \"A\"<\/span>, <\/span>\"B\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"D\"<\/span><\/pre>\n
 <\/p>\n
Or, cast the objects. (Don\u2019t forget the parentheses.)<\/p>\n
    $caps<\/span> =<\/span> [<\/span>System.Collections.ArrayList<\/span>](<\/span>\"A\"<\/span>, <\/span>\"B\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"D\")<\/span><\/pre>\n
 <\/p>\n
Use the InputObject parameter of Get-Member to get the properties and methods of an array list. There\u2019s a Remove<\/strong> method of ArrayList objects and this one works.<\/p>\n
\"image\"<\/a><\/p><\/blockquote>\n
 <\/p>\n
 <\/p>\n
Remove objects from an array list<\/h2>\n
As the help shows, the Remove<\/strong> method of an ArrayList removes the first instance of the item from the array list. It returns Void<\/strong>, which means nothing. The Remove method changes the original array list. It doesn\u2019t return a new array list.<\/p>\n
\"image\"<\/a><\/p><\/blockquote>\n
PS C:\\ps-test> $caps
\nA
\nB
\nD<\/span><\/p><\/blockquote>\n
 <\/p>\n
To remove multiple instances of an object, use a While<\/strong> loop.<\/p>\n
    [<\/span>System.Collections.ArrayList<\/span>]<\/span>$caps<\/span> =<\/span> \"A\"<\/span>, <\/span>\"B\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"D\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"E\"<\/span>\r\n    while<\/span> (<\/span>$caps<\/span> -contains<\/span> \"C\"<\/span>) {\r\n        <\/span>$caps<\/span>.Remove(<\/span>\"C\"<\/span>)\r\n    }<\/span><\/pre>\n
<\/pre>\n
You can also use a ForEach<\/strong> loop on an array list, but you can\u2019t remove objects from the array list that you\u2019re traversing with ForEach. In the background, ForEach uses positional indexes and the position of each object in an array list (or any collection) changes when you remove an object.<\/p>\n
In the following example, the code uses a ForEach loop to remove the svchost<\/strong> processes from an array list of processes.<\/p>\n
    [<\/span>System.Collections.ArrayList<\/span>]<\/span>$p<\/span> =<\/span> Get-Process<\/span>\r\n    foreach<\/span> (<\/span>$process<\/span> in<\/span> $p<\/span>)\r\n    {\r\n        <\/span>if<\/span> (<\/span>$process<\/span>.Name <\/span>-eq<\/span> \"svchost\"<\/span>)\r\n        {\r\n            <\/span>$p<\/span>.Remove(<\/span>$process<\/span>)\r\n        }\r\n    }<\/span><\/pre>\n
Collection was modified; enumeration operation may not execute.
\nAt line:1 char:10
\n+ foreach ($process in $p)
\n+ ~~~~
\n+ CategoryInfo\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : OperationStopped: (:) [], InvalidOperationException
\n+ FullyQualifiedErrorId : System.InvalidOperationException<\/span><\/p><\/blockquote>\n
 <\/p>\n
Instead, create an array of svchost<\/strong> processes ($s) and use a ForEach loop to remove each svchost process from $p. Because ForEach is traversing the $s array, you can use it to remove objects from $p.<\/p>\n
\u00a0   [<\/span>System.Collections.ArrayList<\/span>]<\/span>$p<\/span> =<\/span> Get-Process<\/span>\r\n    $s<\/span> =<\/span> Get-Process<\/span> |<\/span> where<\/span> ProcessName <\/span>-eq<\/span> \"svchost\"<\/span>\r\n    foreach<\/span> (<\/span>$svchost<\/span> in<\/span> $s<\/span>)\r\n    {\r\n        <\/span>$p<\/span>.Remove(<\/span>$svchost<\/span>)\r\n    }\r\n<\/span><\/pre>\n
 <\/p>\n
RemoveAt: Remove Objects by Index<\/h2>\n
You can also use the RemoveAt method of ArrayLists to remove objects. RemoveAt takes the index of the object that you want to remove. In this example, we\u2019ll use a value of 2, which is the index of \u201cC\u201d.<\/p>\n
\"image\"<\/a><\/p><\/blockquote>\n
PS C:\\ps-test> $caps
\nA
\nB
\nD
\nE<\/span><\/p><\/blockquote>\n
 <\/p>\n
It was easy to find the index of \u201cC\u201d in such a small array list, but it you have a larger array list, you can use the IndexOf<\/strong> method to find the index and then use the RemoveAt<\/strong> method to remove the object at that index. You can call the methods in two separate commands or in a single command.<\/p>\n
 <\/p>\n
    $index<\/span> =<\/span> $caps<\/span>.IndexOf(<\/span>\"C\"<\/span>)\r\n    <\/span>$caps<\/span>.RemoveAt(<\/span>$index<\/span>)\r\n<\/span><\/pre>\n
-or-<\/span><\/p>\n
    $caps<\/span>.RemoveAt(<\/span>$caps<\/span>.IndexOf(<\/span>\"C\"<\/span>))\r\n<\/span><\/pre>\n
<\/pre>\n
To use the RemoveAt method to remove multiple objects, use a For<\/strong> loop. The For loop is well suited to this task because it use indexes.<\/p>\n
But, be careful! When you remove an object from a collection, you change the indexes of every subsequent object in the collection. For example, in the following array list, we want to remove the \u201cC\u201d objects at indexes 2, 3, and 4. But after we remove the \u201cC\u201d object at index 2, the index of the second \u201cC\u201d object changes from 3 to 2. If we advance the index from 2 to 3, we’ll miss the “C” that is now at index 2.<\/p>\n
\n\"image\"<\/a>\n<\/p><\/blockquote>\n
 <\/p>\n
To compensate, whenever you remove an object, decrement the index by 1. You can use any notation to reduce it’s value by one:\u00a0 $i = $i \u2013 1<\/span>, $i \u2013= 1<\/span>, or $i–<\/span>.<\/p>\n
    [<\/span>System.Collections.ArrayList<\/span>]<\/span>$caps<\/span> =<\/span> \"A\"<\/span>, <\/span>\"B\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"D\"<\/span>, <\/span>\"C\"<\/span>, <\/span>\"E\"<\/span>\r\n    for<\/span> (<\/span>$i<\/span> =<\/span> 0<\/span>; <\/span>$i<\/span> -lt<\/span> $caps<\/span>.count; <\/span>$i<\/span>++<\/span>)\r\n    {\r\n        <\/span>if<\/span> (<\/span>$caps<\/span>[<\/span>$i<\/span>] <\/span>-eq<\/span> \"C\"<\/span>)\r\n        {\r\n            <\/span>$caps<\/span>.RemoveAt(<\/span>$i<\/span>)\r\n            <\/span>$i--<\/span>\r\n        }\r\n    }<\/span><\/pre>\n
 <\/p>\n
Here’s the same technique used to remove the svchost processes from the $p array list.<\/p>\n
    [<\/span>System.Collections.ArrayList<\/span>]<\/span>$p<\/span> =<\/span> Get-Process<\/span>\r\n    for<\/span> (<\/span>$i<\/span> =<\/span> 0<\/span>; <\/span>$i<\/span> -lt<\/span> $p<\/span>.Count; <\/span>$i<\/span>++<\/span>)\r\n    {\r\n        <\/span>if<\/span> (<\/span>$p<\/span>[<\/span>$i<\/span>].Name <\/span>-eq<\/span> \"svchost\"<\/span>)\r\n        {\r\n            <\/span>$p<\/span>.RemoveAt(<\/span>$i<\/span>)\r\n            <\/span>$i<\/span>--<\/span>\r\n        }    \r\n    }<\/span><\/pre>\n
 <\/p>\n
Summary<\/h2>\n
For most scripts, you don\u2019t manipulate arrays directly. Instead, you use Where-Object to create a new collection that includes only the items that you need. But if you need to manage an array directly, you can add and remove objects.<\/p>\n
June Blender is a technology evangelist at SAPIEN Technologies, Inc. You can reach her at juneb@sapien.com<\/a> or follow her on Twitter at @juneb_get_help<\/a>.<\/i><\/p>\n","protected":false},"excerpt":{"rendered":"
  A member of the PowerShell group on Facebook asked how to delete an object from an array. It’s a simple question, but the answer isn’t very simple at all. It’s one of those beginner questions that has an advanced answer. When I first answered this question in about_Arrays, I didn’t really know much about […]<\/p>\n","protected":false},"author":31,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[932,25],"tags":[934,28],"class_list":["post-8152","post","type-post","status-publish","format-standard","hentry","category-beginners","category-windows-powershell","tag-juneb","tag-powershell"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8152","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/users\/31"}],"replies":[{"embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/comments?post=8152"}],"version-history":[{"count":3,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8152\/revisions"}],"predecessor-version":[{"id":8205,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/posts\/8152\/revisions\/8205"}],"wp:attachment":[{"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/media?parent=8152"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/categories?post=8152"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dev.sapien.com\/blog\/wp-json\/wp\/v2\/tags?post=8152"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}