Text and Regular Expressions in PowerShell

PowerShell distinguishes sharply between text in single quotation marks and text in double quotation marks. PowerShell won't modify text wrapped in single quotation marks but it does inspect text in single quotation marks and may modify it by inserting variable contents automatically. Enclosing text in double quotation marks is the foremost and easiest way to couple results and descriptions.

The formatting operator -f, one of many specialized string operators, offers more options. For example, you can use -f to output text column-by-column and to set it flush. Other string commands are also important. They can replace selected text, change case, and much more.

Pattern recognition adds a layer of complexity because it uses wildcard characters to match patterns. In simple cases, you can use the same wildcards that you use in the file system. Substantially more powerful, but also more complex, are regular expressions.

Topics Covered:

• Defining Text
  • Special Characters in Text
    • Resolving Variables
    • Inserting Special Characters
      • Table 13.1: Special characters and "escape" sequences for text
  • "Here-Strings": Acquiring Text of Several Lines
  • Communicating with the User
    • Querying User Name and Password
      • Figure 13.1: Querying user passwords using the integrated secure dialog box
• Using Special Text Commands
  • String Operators
    • Table 13.2: Operators used for handling string
    • Formatting String
    • Setting Numeric Formats
      • Table 13.3: Formatting numbers
      • Table 13.4: Formatting date values
      • Table 13.5: Customized date value formats
    • Outputting Values in Tabular Form: Fixed Width
  • String Object Methods
    • Table 13.6: The methods of a string object
    • Analyzing Methods: Split() as Example
  • Using String Class Commands
    • Join(): Changing Arrays to Text
    • Concat(): Assembling a String Out of Several Parts
• Simple Pattern Recognition
  • Table 13.7: Using simple placeholders
• Regular Expressions
  • Describing Patterns
    • Table 13.8: Placeholders for characters
    • Quantifiers
      • Table 13.9: Quantifiers for patterns
    • Anchors
      • Table 13.10: Anchor boundaries
    • Recognizing IP Addresses
    • Validating E-Mail Addresses
  • Simultaneous Searches for Different Terms
  • Case Sensitivity
    • Table 13.11: Regular expression elements
  • Finding Information in Text
  • Searching for Several Keywords
  • Forming Groups
  • Further Use of Sub-Expressions
  • Greedy or Lazy? Detailed or Concise Results...
  • Finding String Segments
  • Replacing a String
  • Using Back References
  • Putting Characters First at Line Beginnings
  • Removing Superfluous White Space
  • Finding and Removing Doubled Words
• Summary

Defining Text

Use quotation marks to delimit it if you'd like to save text in a variable or to output it. Use single quotation marks if you want text to be stored in a variable in (literally) exactly the same way you specified it:

Text will have an entirely different character when you wrap it in (conventional) double quotation marks because enclosed special characters will be evaluated:

Special Characters in Text

If text is enclosed in double quotation marks, PowerShell will look for particular special characters in it. Two special characters are important in this regard: "$" and the special backtick character, "`".

Resolving Variables

If PowerShell encounters one of the variables from Chapter 3, it will assign the variable its value:

This also applies to direct variables, which calculate their value themselves:

Inserting Special Characters

The peculiar backtick character, "`", has two tasks: if you type it before characters that are particularly important for PowerShell, such as "$" or quotation marks, PowerShell will interpret the characters following the backtick as normal text characters. You could output quotation marks in text like this:

If one of the letters listed in Table 13.1 follows the backtick character, PowerShell will insert special characters:

"Here-Strings": Acquiring Text of Several Lines

Using "here-strings" is the best way to acquire long text consisting of several lines or many special characters. "Here-strings" are called by this name because they enable you to acquire text exactly the way you want to store it in a text variable, much like a text editor. Here-strings are preceded by the @" character and terminated by the "@ character. Note here once again that PowerShell will automatically resolve (assign variable values and evaluate backtick characters in) text enclosed by @" and "@ characters. If you use single quotation marks instead, the text will remain exactly the way you typed it:

Communicating with the User

If you'd like to request users to input text, use Read-Host:

Text acquired by Read-Host behaves like text enclosed in single quotation marks. Consequently, special characters and variables are not resolved. Manually use the ExpandString() method if you want to resolve the contents of a text variable later on, that is, have the variables and special characters in it replaced. PowerShell normally uses this method internally when you allocate text in double quotation marks:

If you'd like to use Read-Host to acquire sensitive data, passwords, use the -asSecureString parameter. The screen entries will be masked by asterisks. The result will be a so-called SecureString. To be able to work on the encrypted SecureString as a normal text entry, it must be changed to plain text first:

Querying User Name and Password

If you'd like to authenticate a user, such as query his name and password, use Get-Credential. This cmdlet uses the secure dialog boxes that are integrated into Windows to request user name and password:

The result is an object having two properties: the given user name is in UserName and the encrypted password is in Password as an instance of SecureString:

Figure 13.1: Querying user passwords using the integrated secure dialog box

Normally, Get-Credential is used if logon data are actually needed, such as to run a program under a particular user name:

However, the user context that creates the Secure String can turn it into readable text whenever you wish, as was the case for Read-Host. For this reason, you can also use Get-Credential to query sensitive information that you can work on subsequently in plain text:

Using Special Text Commands

Often, results need to be properly output and provided with descriptions. The simplest approach doesn't require any special commands: insert the result as a variable or sub-expression directly into text and make sure that text is enclosed in double quotation marks.

More options are offered by special text commands that PowerShell furnishes from three different areas:

• String operators: PowerShell includes a number of string operators for general text tasks, which you can use to replace text and to compare text (Table 13.2).
• Dynamic methods: the String data type, which saves text, includes its own set of text statements that you can use to search through, dismantle, reassemble, and modify text in diverse ways (Table 13.6).
• Static methods:finally, the String .NET class includes static methods bound to no particular text.

String Operators

The -f format operator is the most important PowerShell string operator. You'll soon be using it to format numeric values for easier reading:

All operators function in basically the same way: they anticipate data from the left and the right that they can link together. For example, you can use -replace to substitute parts of the string for other parts:

There are three implementations of the -replace operator; many other string operators also have three implementations. Its basic version is case insensitive. If you'd like to distinguish between lowercase and uppercase, use the version beginning with "c" (for case-sensitive):

The third type begins with "i" (for insensitive) and is case insensitive. This means that this version is actually superfluous because it works the same way as -replace. The third version is merely demonstrative: if you use -ireplace instead of -replace, you'll make clear that you expressly do not want to distinguish between uppercase and lowercase.

Formatting String

The format operator -f formats a string and requires a string, along with wildcards on its left side and on its right side, that the results are to be inserted into the string instead of the wildcards:

It is absolutely necessary that exactly the same results are on the right side that are to be used in the string are also on the left side. If you want to just calculate a result, then the calculation should be in parentheses. As is generally true in PowerShell, the parentheses ensure that the enclosed statement is evaluated first and separately and that subsequently, the result is processed instead of the parentheses. Without parentheses, -f would report an error:

You may use as many wildcard characters as you wish. The number in the braces states which value will appear later in the wildcard and in which order:

Setting Numeric Formats

The formatting operator -f can insert values into text as well as format the values. Every wildcard used has the following formal structure: {index[,alignment][:format]}:

• Index: This number indicates which value is to be used for this wildcard. For example, you could use several wildcards with the same index if you want to output one and the same value several times, or in various display formats. The index number is the only obligatory specification. The other two specifications are voluntary.
• Alignment: Positive or negative numbers can be specified that determine whether the value is right justified (positive number) or left justified (negative number). The number states the desired width. If the value is wider than the specified width, the specified width will be ignored. However, if the value is narrower than the specified width, the width will be filled with blank characters. This allows columns to be set flush.
• Format: The value can be formatted in very different ways. Here you can use the relevant format name to specify the format you wish. You'll find an overview of available formats below.

Using the formats in Table 13.3, you can format numbers quickly and comfortably. No need for you to squint your eyes any longer trying to decipher whether a number is a million or 10 million:

There's also a very wide range of time and date formats. The relevant formats are listed in Table 13.4 and their operation is shown in the following lines:

If you want to find out which type of formatting options are supported, you need only look for .NET types that support the toString() method:

For example, among the supported data types is the "globally unique identifier" System.Guid. Because you'll frequently require GUID, which is clearly understood worldwide, here's a brief example showing how to create and format a GUID:

Outputting Values in Tabular Form: Fixed Width

To display the output of several lines in a fixed-width font and align them one below the other, each column of the output must have a fixed width. A formatting operator can set outputs to a fixed width.

In the following example, Dir returns a directory listing, from which a subsequent loop outputs file names and file sizes. Because file names and sizes vary, the result is ragged right and hard to read:

The following result with fixed column widths is far more legible. To set widths, add a comma to the sequential number of the wildcard and after it specify the number of characters available to the wildcard. Positive numbers will set values to right alignment, negative numbers to left alignment:

String Object Methods

You know from Chapter 6 that PowerShell stores everything in objects and that every object contains a set of instructions known as methods. Text is stored in a String object, which includes a number of useful commands for working with text. For example, to ascertain the file extension of a file name, use LastIndexOf() to determine the position of the last "." character, and then use Substring() to extract text starting from the position:

Another approach uses the dot as separator and Split() to split up the path into an array. The result is that the last element of the array (-1 index number) will include the file extension:

Table 13.6 provides an overview of all the methods that include a string object.

Analyzing Methods: Split() as Example

You already know in detail from Chapter 6 how to use Get-Member to find out which methods an object contains and how to invoke them. Just as a quick refresher, let's look again at an example of the Split() method to see how it works.

Definition gets output, but it isn't very easy to read. Because Definition is also a string object, you can use methods from Table 13.6, including Replace(), to insert a line break where appropriate. That makes the result much more understandable:

There are six different ways to invoke Split(). In simple cases, you might use Split() with only one argument, Split(), you will expect a character array and will use every single character as a possible splitting separator. That's important because it means that you may use several separators at once:

If the splitting separator itself consists of several characters, then it has got to be a string and not a single Char character. There are only two signatures that meet this condition:

You must make sure that you pass data types to the signature that is exactly right for it to be able to use a particular signature. If you want to use the first signature, the first argument must be of the String[] type and the second argument of the StringSplitOptions type. The simplest way for you to meet this requirement is by assigning arguments first to a strongly typed variable. Create the variable with exactly the type that the signature requires:

Split() in fact now uses a separator consisting of several characters. It splits the string only at the points where it finds precisely the characters that were specified. There does remain the question of how do you know it is necessary to assign the value "None" to the StringSplitOptions data type. The simple answer is: you don't know and it isn't necessary to know. If you assign a value to an unknown data type that can't handle the value, the data type will automatically notify you of all valid values:

By now it should be clear to you what the purpose is of the given valid values and their names. For example, what was RemoveEmptyEntries() able to accomplish? If Split() runs into several separators following each other, empty array elements will be the consequence. RemoveEmptyEntries() deletes such empty entries. You could use it to remove redundant blank characters from a text:

Now all you need is just a method that can convert the elements of an array back into text. The method is called Join(); it is not in a String object but in the String class.

Using String Class Commands

Chapter 6 clearly defined the distinction between classes and objects (or instances). Just to refresh your memory: every String object is derived from the String class. Both include diverse methods. You can see these methods at work when you press (Tab) after the following instruction, which activates AutoComplete:

Get-Member will return a list of all methods. This time, specify the -Static parameter in addition:

You've already used static methods. In reality, the -f format operator corresponds to the Format() static method, and that's why the following two statements work in exactly the same way:

The Format() static method is very important but is usually ignored because -f is much easier to handle. But you wouldn't be able to do without two other static methods: Join() and Concat().

Join(): Changing Arrays to Text

Join() is the counterpart of Split() discussed above. Join() assembles an array of string elements into a string. It enables you to complete the above example and to make a function that removes superfluous white space characters from the string:

Concat(): Assembling a String Out of Several Parts

Concat() assembles a string out of several separate parts. At first glance, it works like the "+" operator:

But note that the "+" operator always acts strangely when the first value isn't a string:

If the first value of the calculation is a string, all other values will be put into the string form and assembled as requested into a complete string. If the first value is not a string—in the example, it was a date value—all the other values will be changed to this type. That's just what causes an error, because it is impossible to change "is a great date!" to a date value. For this reason, the "+" operator is an unreliable tool for assembling a string.

Concat() causes fewer problems: it turns everything you specify to the method into a string. Concat(), when converting, also takes into account your current regional settings; it will provide, for example, U.S. English date and time formats:

Simple Pattern Recognition

Recognizing patterns is a frequent task that is necessary for verifying user entries, such as to determine whether a user has given a valid network ID or valid e-mail address. Useful and effective pattern recognition requires wildcard characters that represent a certain number and type of characters.

A simple form of wildcards was invented for the file system many years ago and it still works today. In fact, you've doubtlessly used it before in one form or another:

路过

雷人

握手

鲜花

鸡蛋