When to cite in PowerShell - Simple Talk (2023)

When do you need to use quotes in PowerShell or not? And if you need them, do you need single quotes or double quotes? At first glance, you might think that this is PowerShell's own help pageabout_Quoting_RulesI would answer both, but it's not! It mainly covers part of the topicString-Interpolationjhere ropes(which we will discuss below). In other words, it assumes you need quotes, and then explains some of the factors that affect which one to choose, single or double. But it completely ignores the big picture. In the meantime, check out StackOverflowWhen do I need to use quotes in PowerShell?This begs the canon question, but gives little insight into the answer. Therefore, this article is here to gather the entire topic of PowerShell citations in one place for a useful reference resource.

Do you need offers?

Let's start with an example. Consider listing the details of some files with theget childcmdlet - I am using sulsAlias ​​to minimize the presence of the cmdlet name and only focus on the elements we quote or not. Which of these is a valid PowerShell and lists the details of the two files in question?

The answer is (A), (C) and (D); Assuming the appropriate files exist, they all return exactly the same result (they throw different error messages if the files don't exist). Since cases (C) and (D) work correctly, you can see that the cmdlet doesn't need quotes when it is first sent, but can use them. So let's focus on the two main cases: case (A) where quotes are needed and case (D) where quotes are not needed:

To understand the difference, you need to know PowerShell's two parsing modes,command analysisjrun analysis🇧🇷 These two modes work together to allow PowerShell to ascriptsLanguage coexist peacefully with PowerShell asshellLanguage that allows you, as a user, to move code between a script and the command line and make it work. That is, in a script (program), literal strings of characters between quotation marks must be entered like this...

it's pretty reasonable. On the command line, however, this would be annoying for some and intolerable for others. You should be able to write:

Also, like any good shell, you should be able to write expressions like5 + 2and get a reply from7, the writer"Hello World"and takeHello Worldhe repeated again. However, if you type a cmdlet name, for exampleget process, it should execute the command and not just repeat the characters„get process„🇧🇷 Easy, you say, because omitting the quotes indicates it's a command to be run, right? But what if you might want to run a command with a space?C:\Program\xyz.exe🇧🇷 Well, without the quotes, PowerShell would just try to runC:\ProgramimpostorFiles\xyz.exeas the first argument. So it should clearly have spaces, but if you try "C:\Programme\xyz.exeit just repeats itself. Ufa!

PowerShell's two parsing modes make it easy to declutter and manage your commands and scripts. According to Keith Hill's seminal article,Understanding PowerShell scan modes:

“First [you] have to parse it like a traditional shell, which doesn't require enclosing strings (filenames, directory names, process names, etc.) in quotes. Second, you must be able to parse like a traditional language in which strings are quoted and expressions appear as if they were found in a programming language. The former is called command parsing mode and the latter is called expression parsing mode in PowerShell. It's important to understand what mode you're in and, more importantly, how to manipulate the analysis mode."

The rules for choosing a mode (or determining which one you're in) are simple:

• Start with a letter, underscore, ampersand, period, or backslash => command parsing mode
• Start with anything else => expression analysis mode

Note that leading spaces in the line (or more specifically in the declaration) do notnocount to determine the beginning, so "beginning" above really means the first non-space character in the declaration.

Examples:

The last three lines above show the problem of whitespace in an executable path and how to work around the problem: (line 5) start the line with the call operator ( & ) and enclose the string in double quotes or (line 6) escape Enclose any spaces within the string that precede each of them with back quotes (`). When you escape a space, it behaves like any other character in the string, so you don't have to quote the string.

You can also freely mix command analysis with expression analysis if needed. Consider this short line:

It starts parsing the command, and PowerShell recognizes a conditional (if) statement. The parentheses restart the mode determination process, so the exclamation mark inside the parentheses forces parsing of the expression, negates something, that something starts parentheses again and restarts the mode determination. Within these brackets, the letter "G" indicates the analysis of the command, that isTake it-loaded toolsis executed, its result is negated, so the condition is continued or not. Here's another example, this is an actual line of code I extracted from one of my open source scripts, showing various nested expressions with different parsing modes ("exp" to parse expression mode; "cmd" to parse command mode) :

Need to quote arguments for a command?

Now that you know the parsing modes, go back to the two equivalent ways to get the file details:

Using the parsing mode rules, case (A) begins in expression mode. evaluate"one.txt“, „b.txt“as an expression and returns a list; this list is used as input to ls(get child🇧🇷 The pipeline is another place that redefines the purpose of analysis, solsit is recognized and executed as a command. In case (D) it starts in command analysis mode and runs againls🇧🇷 This is fantastic...but why not the arguments forlsNeed quotes?The answer can be extractedPowerShell version 3.0 language specification, Section 8.2:

"A command invocation consists of the command name followed by zero or more arguments. The rules for arguments are as follows: ... An argument that is not an expression but contains any unescaped text without spaces,is treated as if it were enclosed in double quotes🇧🇷 [emphasis added]

The phrase "unescaped empty text" is pretty tricky, and I contend, a bit misleading. What you say is:

1. Text that is not a space is assumed to be quoted, i.e. H. a string literal likea BC.
2. Text escaped by spaces is also considered a string literal, e.gtwo words.
3. BTW, if there is an unescaped white space (liketwo words) Whitespace is considered a boundary between arguments, so apply (1) and (2) to each argument separately: bothOut ofjWordsYou will be consideredcordaLiteral from (1).

The definition ofExpressionis detailed in Section 7 of the specification, but the rules for determining the parsing mode are similar; just say thata.txtesnoan expression, then it's like typing "a.txt".

Of course, if any of your filenames contain spaces, you'll need to include the quotes explicitly. It's unreasonable to expect that PowerShell can figure out that "a file.text" is a name here:

Then you must do the following:

If you'd rather avoid double quotes, you always have the option to escape embedded spaces by backticking each space:

Do you need to quote the goal of a task?

Which of the two assignment statements shown is legitimate?

ThroughPowerShell version 3.0 language specification, Section 7.11, the syntax of the assignment statement is:

Expression operator declaration

The operator in this case is the equal sign (=). So the right side of equal is theExplanationComponent. You usually think of a statement starting at the beginning of a line, but this is an example of the opposite; Declarations can even be made within a line! As you have seen, the beginning of a declaration implies the beginning of the analysis of the determination. In (A), the utterance starts with double quotes, so the expressive mode and the literal mode are considered.olaIt is recognized. However, in (B) the first character of the instruction is a letter, which means that the command mode is applied and an attempt is made to execute itola, that's not what you want.

Therefore, assignments require citations.

Need to quote components of an expression?

Which of the following expressions are legitimate?

Each line begins with a quoted string. So when the parsing determination occurs, all of these lines start in expression parsing mode. The real question here is what happens after the operator, whether it's an arithmetic operator (A and C) or a comparison operator (B and D), are the quotes necessary? The answer here is simple if you think about it: it starts in expression mode when it finds the left argument, goes on and finds the operator, then goes on and finds the right argument. Nothing overrides the parsing rule, so the argument on the right must still be a legitimate expression, which means that if you want a string literal, you have to wrap it as such with quotes for A and B to be valid . (If you want to run a function called insteadFoo, then you have to camouflage it as such, in the clothes of the expression so to speak, by putting it in a subexpression where the parsing specifier can be redefined, so:'aaa' + (fu).

Which quotation marks to use?

You have found that you need offers; The next determination is whether you need single quotes (') or double quotes ("). Doubles for interpolated (or interpreted) strings.

Let's examine this in detail. For this first example, I'm borrowing the PowerShell help page,about_Quoting_Rules, format it a bit for clarity. Assuming you have defined the variablePSEU5 before running any of these:

This first group (1a) shows the effect of a string enclosed in double quotes. All built-in variables are interpolated (or interpreted if you prefer) so the output differs from the input. Line (1b), on the other hand, shows that the single-quoted string is entirely static: the output is identical to the input and no interpolation takes place. Line (1c) shows that you can indeed mix interpolation with literals: precede each dollar sign with a backtick to prevent it from starting an interpolation for that instance.

This second group shows the analogous expressions, but this time with aPSsubexpression. Within a quoted string, everything inside the subexpression is evaluated, showing that it can have much more than just an interpolated variable name. Of course, the example above is just to keep the subexpression concise. However, such a subexpression is often needed when you want to interpolate an object's property. say you have one$ processObject ($ processo = get-process -winword-Name) and want to embed the company name associated with the process in a string.

Everyone tries to cope with (3a) first, but don't try when your boss is watching or you'll have one of those awkward moments. :-) String interpolation starts at the dollar sign and ends at the first character that cannot be part of a simple variable name, in this case the period. As soon$ processIt's just interpolated, and since it's a complex object, you get the type name and the process name. Use a subexpression to get what you really want, as in (b).

In addition to variable interpolation, strings also belong in double quotesInterpretation of special characters🇧🇷 That when you write`tA tab stop is generated within a string enclosed in double quotes. Special characters within a single-quoted string are not interpreted, but are displayed exactly as you typed them. To seeabout_Special_Charactersfor other special characters. I highlighted those`tJust to clarify:

Insert quotation marks within quotation marks

Sometimes you just need to put literal quotes inside a string literal. The table below shows all the combinations and how to manipulate the input to get the desired output. In (5a) and (5b) it can be seen that including theMiscellaneousQuotation marks that you do not use to delimit the string require no special action. (6a) and (6b) show how to enclose double quotes inside double quotes. You have two choices: repeat the double quote (6a) or escape the double quote (6b) with a backtick. Finally, inserting single quotes into single quotes allows only one option, duplicating the single quote (7a). You can't escape with a backtick (7b) because within a single quoted string, everything is literal, including the backtick, so the single quote prematurely terminates the string!

A special note on (7a): there seems to be a double quote in the middle that magically turns into a single quote on output. But it is not like that! It's just two single quotes next to each other. So the technique is the same for strings with single or double quotes: duplicate the same quote to get a single quote in the output.

multiline strings

With PowerShell you can create strings that span multiple lines (as many scripting languages ​​do) by ahere chain🇧🇷 ONEhere chain, Öhere document, is simply a piece of text embedded in your program that is treated as if it came from a separate file; in other words, it's correcthere🇧🇷 Strings here from PowerShell can be constructed with either single or double quotes, and behave as you might expect by now: in single quotes, they're pure literals; Double quotes allow interpolation of variables, subexpressions, and special characters.

A string here should be formatted like this:

That is, nothing but spaces and can follow the opening token (@"). And most importantly, the closing token must be the first character of the line, with no leading space! The string value here is anything delimited between the two<ENTER>shown above.

In fact, you can embed newlines in a regular string just as easily as you can embed a string here, but a string here has one major advantage: you can freely embed double quotes like any other character (8a, 8c) without the need for double or escaping.

A word about format strings

For the sake of completeness, the .NET standard format string is worth mentioning. For example in C# you can do something like this...

... which could look like this:

dieConsole.WriteLinedoes really is with thatString.Formatmethod that takes a format string containing placeholders, followed by a list of objects to fill in those placeholders. You can useString.Formatin PowerShell with the rather succinct-FOperator. This is the PowerShell equivalent:

Effectively this does exactly the same thing as this:

...then you can concludehave toUse a string enclosed in double quotes when using -f (String.Format) operator. But not! In this case, single or double quotes will suffice:

In this particular case, why is the single-quoted string acting as live code and not just a string literal? The answer is that it isno🇧🇷 It's really just a string literal, character by character. These placeholders are plain text as far as the string is concerned; and theString.Formatmethod that reads this string and treats these placeholders differently.

summary

Strings are such an important concept in any language that it's important to have a good foundation in the basics. As a scripting language, PowerShell tends to be more flexible to use and covers a variety of scenarios. In this article, I've put everything in one place so you can easily learn everything you need to know and have a single source to refer to if you have any questions about strings. So go back and look at your own code. You'll probably find that you can eliminate a lot of confusion by removing a lot of unnecessary quotes!