Group-Object

Syntax

Group-Object
     [-NoElement]
     [-AsHashTable]
     [-AsString]
     [-InputObject <PSObject>]
     [[-Property] <Object[]>]
     [-Culture <String>]
     [-CaseSensitive]
     [<CommonParameters>]

Description

The Group-Object cmdlet displays objects in groups based on the value of a specified property. Group-Object returns a table with one row for each property value and a column that displays the number of items with that value.

If you specify more than one property, Group-Object first groups them by the values of the first property, and then, within each property group, it groups by the value of the next property.

Beginning in PowerShell 7, Group-Object can combine the CaseSensitive and AsHashtable parameters to create a case-sensitive hash table. The hash table keys use case-sensitive comparisons and output a System.Collections.Hashtable object.

Examples

Example 1: Group files by extension

This example recursively gets the files under $PSHOME and groups them by file name extension. The output is sent to the Sort-Object cmdlet, which sorts them by the count files found for the given extension. The empty Name represents directories.

This example uses the NoElement parameter to omit the members of the group.

$files = Get-ChildItem -Path $PSHOME -Recurse
$files | Group-Object -Property extension -NoElement | Sort-Object -Property Count -Descending

Count Name
----- ----
  365 .xml
  231 .cdxml
  197
  169 .ps1xml
  142 .txt
  114 .psd1
   63 .psm1
   49 .xsd
   36 .dll
   15 .mfl
   15 .mof
...

Example 2: Group integers by odds and evens

This example shows how to use script blocks as the value of the Property parameter. This command displays the integers from 1 to 20, grouped by odds and even.

1..20 | Group-Object -Property {$_ % 2}

Count Name                      Group
----- ----                      -----
   10 0                         {2, 4, 6, 8...}
   10 1                         {1, 3, 5, 7...}

Example 3: Group event log events by EntryType

This example displays the 1,000 most recent entries in the System event log, grouped by EntryType.

In the output, the Count column represents the number of entries in each group. The Name column represents the EventType values that define a group. The Group column represents the objects in each group.

Get-WinEvent -LogName System -MaxEvents 1000 | Group-Object -Property LevelDisplayName

Count Name          Group
----- ----          -----
  153 Error         {System.Diagnostics.Eventing.Reader.EventLogRecord, System.Diagnostics...}
  722 Information   {System.Diagnostics.Eventing.Reader.EventLogRecord, System.Diagnostics...}
  125 Warning       {System.Diagnostics.Eventing.Reader.EventLogRecord, System.Diagnostics...}

Example 4: Group processes by priority class

This example demonstrates the effect of the NoElement parameter. These commands group the processes on the computer by priority class.

The first command uses the Get-Process cmdlet to get the processes on the computer and sends the objects down the pipeline. Group-Objectgroups the objects by the value of the PriorityClass property of the process.

The second example uses the NoElement parameter to eliminate the members of the group from the output. The result is a table with only the Count and Name property value.

The results are shown in the following sample output.

Get-Process | Group-Object -Property PriorityClass

Count Name         Group
----- ----         -----
   55 Normal       {System.Diagnostics.Process (AdtAgent), System.Diagnosti...
    1              {System.Diagnostics.Process (Idle)}
    3 High         {System.Diagnostics.Process (Newproc), System.Diagnostic...
    2 BelowNormal  {System.Diagnostics.Process (winperf),

Get-Process | Group-Object -Property PriorityClass -NoElement

Count Name
----- ----
   55 Normal
    1
    3 High
    2 BelowNormal

Example 5: Group processes by name

The following example uses Group-Object to group multiple instances of processes running on the local computer. Where-Object displays processes with more than one instance.

Get-Process | Group-Object -Property Name -NoElement | Where-Object {$_.Count -gt 1}

Count Name
----- ----
2     csrss
5     svchost
2     winlogon
2     wmiprvse

Example 6: Group objects in a hash table

This example uses the AsHashTable and AsString parameters to return the groups in a hash table, as a collection of key-value pairs.

In the resulting hash table, each property value is a key, and the group elements are the values. Because each key is a property of the hash table object, you can use dot notation to display the values.

The first command gets the Get and Set cmdlets in the session, groups them by verb, returns the groups as a hash table, and saves the hash table in the $A variable.

The second command displays the hash table in $A. There are two key-value pairs, one for the Get cmdlets and one for the Set cmdlets.

The third command uses dot notation, $A.Get to display the values of the Get key in $A. The values are CmdletInfo object. The AsString parameter doesn't convert the objects in the groups to strings.

$A = Get-Command Get-*, Set-* -CommandType cmdlet | Group-Object -Property Verb -AsHashTable -AsString
$A

Name     Value
----     -----
Get      {Get-Acl, Get-Alias, Get-AppLockerFileInformation, Get-AppLockerPolicy...}
Set      {Set-Acl, Set-Alias, Set-AppBackgroundTaskResourcePolicy, Set-AppLockerPolicy...}

$A.Get

CommandType     Name                                Version    Source
-----------     ----                                -------    ------
Cmdlet          Get-Acl                             7.0.0.0    Microsoft.PowerShell.Security
Cmdlet          Get-Alias                           7.0.0.0    Microsoft.PowerShell.Utility
Cmdlet          Get-AppLockerFileInformation        2.0.0.0    AppLocker
Cmdlet          Get-AppLockerPolicy                 2.0.0.0    AppLocker
...

Example 7: Create a case-sensitive hash table

This example combines the CaseSensitive and AsHashTable parameters to create a case-sensitive hash table. The files in the example have extensions of .txt and .TXT.

$hash = Get-ChildItem -Path C:\Files | Group-Object -Property Extension -CaseSensitive -AsHashTable
$hash

Name           Value
----           -----
.TXT           {C:\Files\File7.TXT, C:\Files\File8.TXT, C:\Files\File9.TXT}
.txt           {C:\Files\file1.txt, C:\Files\file2.txt, C:\Files\file3.txt}

The $hash variable stores the System.Collections.Hashtable object. Get-ChildItem gets the file names from the C:\Files directory and sends the System.IO.FileInfo objects down the pipeline. Group-Object groups the objects using the Property value Extension. The CaseSensitive and AsHashTable parameters create the hash table and the keys are grouped using the case-sensitive keys .txt and .TXT.

Parameters

-AsHashTable

-AsString

-CaseSensitive

-Culture

-InputObject

-NoElement

-Property

Inputs

PSObject

You can pipe any object to Group-Object.

Outputs

Microsoft.PowerShell.Commands.GroupInfo or System.Collections.Hashtable

When you use the AsHashTable parameter, Group-Object returns a Hashtable object. Otherwise, it returns a GroupInfo object.

Notes

You can use the GroupBy parameter of the formatting cmdlets, such as Format-Table and Format-List, to group objects. Unlike Group-Object, which creates a single table with a row for each property value, the GroupBy parameters create a table for each property value with a row for each item that has the property value.

Group-Object doesn't require that the objects being grouped are of the same Microsoft .NET Core type. When grouping objects of different .NET Core types, Group-Object uses the following rules:

• Same Property Names and Types.

  If the objects have a property with the specified name, and the property values have the same .NET Core type, the property values are grouped by using the same rules that would be used for objects of the same type.

• Same Property Names, Different Types.

  If the objects have a property with the specified name, but the property values have a different .NET Core type in different objects, Group-Object uses the .NET Core type of the first occurrence of the property as the .NET Core type for that property group. When an object has a property with a different type, the property value is converted to the type for that group. If the type conversion fails, the object isn't included in the group.

• Missing Properties.

  Objects that don't have a specified property can't be grouped. Objects that aren't grouped appear in the final GroupInfo object output in a group named AutomationNull.Value.

Related Links

• about_Calculated_Properties
• about_Hash_Tables
• Compare-Object
• ForEach-Object
• Measure-Object
• New-Object
• Select-Object
• Sort-Object
• Tee-Object
• Where-Object