PowerShell cmdLet Select-String

Common usages

Find lines in current directory that contain pattern.

select-string pattern *

Search in files with given extensions only:

select-string -list pattern *.sql
select-string -list pattern *.sql, *.config

Unfortunately, select-string pattern * throws an error message if select-string pattern * is executed in a directory that contains sub-directories: select-string : The file P:\ath\to\subdirectory cannot be read: Access to the path 'P:\ath\to\subdirectory' is denied.

Therefore, it is advisable to use a pipeline that pipes the result of get-childItem into the select-string cmdLet;

get-childItem * | select-object pattern

Use -list to report only the first occurence of a found pattern;

get-childItem * | select-string -list pattern

Show filenames only. filename is a property of the returned MatchInfo objects:

select-string -list pattern * | select-object -list filename
get-childitem -recurse | select-string -list pattern * | select-object -list filename

More properties, such as lineNumber can be added to the result:

select-string -list pattern * | select-object lineNumber, filename

Search recursively in or below the current directory:

get-childItem -recurse | select-string pattern

By default, select-string searches case-insensitively. Case sensitiveness can be turned on with -caseSensitive:

get-childItem -recurse | select-string -caseSensitive pattern

Find strings in an array

The following simple pipeline pipes a string array into select-string and uses a regular expression to find all strings that don't have the letter e:

'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten' | select-string '^[^e]*$'

Github repository about-PowerShell, path: /cmdlets/string/select/string-array.ps1

This pipeline prints:

two
four
six

Similarly, such a pipeline can also be used to find numbers that have at least two digits:

42, 128, 1, 44 | select-string \d\d

Selecting lines in files

With the -path option, select-string searches for text in files, line by line:

select-string -path .\*.txt 'regexp'

Whe using select-string on files, the output includes the name of the file and the line number where the text was found:

bar.txt:603:quod erat
foo.txt:109:demonstrandum
foo.txt:721:etc etc etc

Selecting objects with specific property values (-inputObject parameter)

The following object creates an array of psCustomObjects and then uses the -inputObject option of select-object to find the property-values of the property val_2 that contain the letter a:

$objs  = `
     ( new-object psObject -property @{ val_1 = 'one'   ; val_2 = 'two'   ; val_3 = 'three' } ) ,
     ( new-object psObject -property @{ val_1 = 'foo'   ; val_2 = 'bar'   ; val_3 = 'baz'   } ) ,
     ( new-object psObject -property @{ val_1 = 'abcde' ; val_2 = 'fghij' ; val_3 = $null   } ) ;

$objs | select-string -inputObject { $_.val_2 } -pattern 'a'

Github repository about-PowerShell, path: /cmdlets/string/select/psCustomObject.ps1

This approach also works on non-psCustomObjects. The following example pipes the result of get-winEvent into select-object to find messages that contain the word failed.

get-winEvent application | select-string -inputObject {$_.message} -pattern 'Failed'

Github repository about-PowerShell, path: /cmdlets/string/select/get-winEvent_inputObject.ps1

Displaying lines before and after matched line

The -context option takes an array of one or two integers that specify how many lines before and after a matched line should be displayed (and thus provides the functionality that grep offers with its -A, -B and -C options).

Display two lines before and two lines after the matched string:

get-childItem -recurse -include *.sql | select-string  from -context 2

Display one line before and two lines after the matched string:

get-childItem -recurse -include *.sql | select-string  from -context 1,2

In the displayed result, a leading greater than (>) indicates the line that actually matched:

  dir-one\abc.sql:4:  sal.amount
> dir-one\abc.sql:5:from
  dir-one\abc.sql:6:  sales    sal                            join
  dir-one\abc.sql:7:  customer cus on sal.cust_id = cus.id;
  dir-two\dir with spaces\def.sql:7:   t2.baz
> dir-two\dir with spaces\def.sql:8:from
  dir-two\dir with spaces\def.sql:9:   t1                    left join
  dir-two\dir with spaces\def.sql:10:   t2 on t1.id = t2.id_1;

Simulating the Linux strings functionality

The following example tries to approximately simulate the Linux strings shell command.

The task I have given myself is to extract the words with excactly 5 letters from the following file (named text):

one two three
four five six
seven eight nine
ten elevent twelve.

Github repository about-PowerShell, path: /cmdlets/string/select/strings/text

Of course, these words are three, seven and eight.

This can be achieved with the following pipeline

foreach($matchedLine in
   get-content text       |
   select-string -allMatches '\b\w{5}\b'
) {
   foreach ($matchedWord in $matchedLine.matches) {
      "$($matchedLine.lineNumber): $matchedWord"
   }
}

Github repository about-PowerShell, path: /cmdlets/string/select/strings/strings.ps1

Explanation: first, the text of the file is read with get-content and then piped into select-string.

The pattern that matches exactly 5 times is \b\w{5}\b:

\b matches a word boundary
\w matches any letter (and digits)
{5} specifies to match the previous atom exactly five times

select-string is given the -allMatches option because there are lines where this pattern matches multiple times and I want to capture them all.

The result of this select-string operation is processed in a foreach statement that iterates over each line that matched at least once. This line is assigned to $matchedLine.

In order to find the matched words, another foreach statement that iterates over $matchedLine.matches and assigns each match to $matchedWord.

Finally, the line number and the matched word can then be printed:

1: three
3: seven
3: eight

Recursive search for a pattern (grep -R)

The following pipeline tries to demonstrate how select-string, in conjunction with get-childItem might be used to recursively search for text patterns in files that are located in and below a given directory. Thus, it sort of does what is known in the shell universe as grep -R.

get-childItem                                        <# Get a list of files                         #> `
  -recurse                                           <# recursively                                 #> `
  ..\..                                              <# start two directories further up            #> `
  -include '*.ps1'                                   <# Only interested in PowerShell scripts       #> |
  select-string                                      <# pipe found files into select-string         #> `
 'foo.*bar' `                                        <# find files that contain foo followed by bar #> |
  format-table                                       <# Pipe to format-table for nice output        #> `
  lineNumber                                         <# We want lineNumber                          #> ,
  @{name='rel. path' ;                               <# relative path                               #> `
   expression={ resolve-path -relative $_.path }}    <#(which is returned by resolve-path …)        #> ,
   line                                              <# and the text of the matching line           #>

Github repository about-PowerShell, path: /cmdlets/string/select/grep-recursively.ps1

When executed, these cmdLets might print something like

LineNumber rel. path                      Line
---------- ---------                      ----
         1 ..\..\gridView\out\array.ps1   'foo', 'bar', 'baz' | out-gridView -title 'An array'
         4 ..\..\json\convertTo\basic.ps1   bla = 'foo', 'bar', 'baz'
         6 .\grep-recursively.ps1          'foo.*bar' `                                        <# find files that contain foo followed by bar #> |
         1 ..\..\write-host.ps1           write-host "Foo bar baz" -foregroundColor red -backgroundColor yellow
        15 ..\..\write-host.ps1           write-host "foo bar" -noNewline
        17 ..\..\write-host.ps1           # foo bar baz

Grepping STDOUT of executables

Normally, select-string can be used to find lines produced in an executable's stdout that match a given regular expression:

PS:\> cmd    /c dir c:\Windows\System32 | select-string '\.msc$'
2022-05-07  06:20 AM            41,587 azman.msc
2022-05-07  06:20 AM            63,081 certlm.msc
2022-05-07  06:20 AM            63,070 certmgr.msc
…
2022-05-07  06:19 AM           115,109 WF.msc
2022-05-07  06:19 AM           144,673 WmiMgmt.msc

However, when using the /u option to force output in Unicode, the following select-string does not match anything anymore:

PS:\> cmd /u /c dir c:\Windows\System32 | select-string '\.msc$'
PS:\>

In that case, the following change needs to be made in a PowerShell session for select-string to match again:

PS:\> [Console]::OutputEncoding = [Text.Encoding]::Unicode
PS:\> cmd /u /c dir c:\Windows\System32 | select-string '\.msc$'