AND ARRAY SUBEXPRESSIONS in C#.NET

Creation Code 3 of 9 in C#.NET AND ARRAY SUBEXPRESSIONS

So far we ve seen a variety of situations where collections of expressions or statements have been grouped together. We ve even used these grouping constructs in string expansions back in chapter 3. Now we ll look at them in more detail. In fact, there are three ways of grouping expressions in PowerShell, as shown in table 5.3.

Table 5.3 Expression and statement grouping operators Results Description Parentheses group expression operations and may contain either a simple expression or a simple pipeline. Subexpressions group collections of statements as opposed to being limited to a single expression. If the contained statements return a single value, it will be retuned as a scalar. If the statements return more than one value, they will be accumulated in an array. The array subexpression operator groups collections of statements in the same manner as the regular subexpression operator, but with the additional behavior that the result will always be returned as an array.

Operator Example ( )

(2+2)*3 12 (get-date).dayofweek Returns the current week day. $($p = a* ; get-process $p ) Returns the process objects for all processes starting with the letter a.

$( )

@( )

@( dir c:\; dir d:\)

The first grouping notation is the simple parenthetical notation. As in most languages, the conventional use for this notation is to control the order of operations, as shown by the following example:

PS (1) > 2+3*4 14 PS (2) > (2+3)*4 20

The parentheses in the second expression cause the addition operation to be performed first. In PowerShell, parentheses also have another use. Looking at the syntax specification for parenthetical expressions illustrates this:

( <pipeline> )

From the syntax, we can see that pipelines are allowed between simple parentheses. This allows us to use a command or pipeline as a value in an expression. For example, to obtain a count of the number of files in a directory, we can use the dir command in parentheses, then use the count property to get the number of objects returned.

Using a pipeline in the parentheses lets us get a count of the number of files matching the wildcard pattern *.doc .

People familiar with other languages tend to assume that the expression (1,2,3,4) is an array literal in PowerShell. In fact, as was discussed at length in chapter 3, this is not the case. The comma operator, discussed in the next section, allows you to easily construct arrays in PowerShell, but there are no array literals as such in the language. All that the parentheses do is control the order of operations. Otherwise, there is nothing special about them. In fact, the precedence of the comma operator is such that you typically never need parentheses for this purpose. More on that later.

Now let s move on to the next set of grouping constructs the subexpressions. There are two forms of the subexpression construct, as shown in the following: $( <statementList> ) @( <statementList> ) The syntactic difference between a subexpression (either form) and a simple parenthetical expression is that you can have any list of statements in a subexpression instead of being restricted to a single pipeline. This means that you can have any PowerShell language element in these grouping constructs, including loop statements. It also means that you can have several statements in the group. Let s look at an example. Earlier in this chapter, we looked at a short piece of PowerShell code that

calculates the numbers in the Fibonacci sequence below 100. At the time, we didn t count the number of elements in that sequence. We can do this easily using the subexpression grouping construct.