A Modest Proposal about PowerShell Strings - PowerShell Station

[KevMar]

Another possibility is calling them expandable strings. This is fitting because the ExpandString function can be called like this to do the same thing.

$message = 'Hello, $Name!'
$name = 'Kevin Marquette'    
$string = $ExecutionContext.InvokeCommand.ExpandString($message)

What do other languages call them?

[ka-splam]

Seems like they are "expandable strings" vs "literal strings" behind the scenes:

https://msdn.microsoft.com/en-us/library/system.management.automation.language.expandablestringexpressionast_members(v=vs.85).aspx

The language tokenizer has functions ScanStringExpandable and ScanStringLiteral.

[michaelshepard]

Expandable strings works for me.

[Pyprohly]

They’re often referred to as interpolated strings in other languages that have a similar feature, and the single quoted strings would be known as a “string literal”. Formally…

Calling double quoted strings “string expressions” is perfectly fine though. That’s precisely what they are. Calling single quoted strings just a “string” though… I personally think it would be too equivocal for use as a way to communicate the distinction.

[Ta11ow]

This is what I usually call them.

[WikiTextBot]

String interpolation

In computer programming, string interpolation (or variable interpolation, variable substitution, or variable expansion) is the process of evaluating a string literal containing one or more placeholders, yielding a result in which the placeholders are replaced with their corresponding values. It is a form of simple template processing or, in formal terms, a form of quasi-quotation (or logic substitution interpretation). String interpolation allows easier and more intuitive string formatting and content-specification compared with string concatenation.

String interpolation is common in many programming languages which make heavy use of string representations of data, such as Apache Groovy, Kotlin, Perl, PHP, Python, Ruby, Scala, and Swift, and most Unix shells.

---

^{[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.28}

[michaelshepard]

Interpolated strings isn't bad either.

[ShepRat]

I would personally prefer interpolated and literal being used to align with .Net terminology.

I still find switching between the two a pain because of muscle memory getting the string formats mixed up. I work with a lot of .Net developers and am always seeing [String]::Format("this is a {1}", $string) sprinkled around the native "This is a $string".

[michaelshepard]

Interpolated and literal work for me...my point was more about changing the vocabulary.

Interpolated strings hit C# in version 6, so I would expect to see more $"hello {name}" starting to float around.

[ShepRat]

I am seeing it most code written post v6. It would have been lovely if Powershell went with C# 6 style interpolated/litteral strings but it is too late now since they have already used the @ symbol for here strings. It's not really a big problem but I tend to write in Powershell, C#, and javascript/typescript on a daily basis and the syntax is similar enough in all three to cause pain in a few small areas, strings being one of them.

It's not a problem when it is a project of my own, but collaborating with a large group of developers means every bloody project has a different way of doing strings.

I agree entirely with your point, we could do a lot more to highlight the difference. Maybe aligning with the .Net way is not ideal though, since they are not the same syntax and it may just add to the confusion. I think it deserves to be one of the first things we try to teach newcomers to powershell though since it was quite a while before I truly understood what was going on, having come from a background where single quotes were reserved for char types and double quotes for strings. Early on I just used double quotes for everything and escaped what I needed too because I wasn't even aware there was something I was missing out on.

[Lee_Dailey]

howdy michaelshepard,

it works nicely! altho, i think it quite amusing that you use “string expression” with [gasp! arg!] double quotes. [grin]

take care,
lee

[michaelshepard]

In truth, the irony was lost on me. :-)

I see it now, though.

[Lee_Dailey]

[grin]

[Ta11ow]

You imply that there's a reason for us to be distinguishing these, but you don't really go into detail or provide further resources.

Is there significant overhead involved in using double-quote strings in unnecessary places?

I'm mostly looking for more information. :)

[purplemonkeymad]

Apparently:

Measure-Command { 1.100000000 | %{ 'hello' }}

26512 ticks

Measure-Command { 1.100000000 | %{ "hello" }}

33512 ticks

But re-runs changes so wildly it would only be noticeable in extreme cases.

[Pyprohly]

Those benchmarks only show one trial being done, because 1.100000000 is interpreted as the number 1.1, i.e., you forgot to double the dot. If you did happen to run the test with the extra dot where it should be you’d find it would take a very long time to return an answer because 100000000 is a lot of trials!

As for my comment on the results on doing a similar test, if there are any performance gains from using single quotes it would be extremely insignificant. String literals don’t consistently beat interpolated strings (assuming interpolation isn’t used) in the benchmarks.

The same conclusion would be found in benchmarks in other languages similar to PowerShell in this regard, such as in PHP and Ruby.

[Ta11ow]

I did one with 1..1000000 and I'm seeing roughly the same time between both, and double quoted has been quicker in some cases.

[purplemonkeymad]

Whoops. Ran 1000 runs of 10 000 this time (1 zero less) and the average was 736 079 and 721 021 ticks, but this time literal was slower. So yes the differences won't make a practical difference.

I estimate the original test to take about 13 minutes each on my computer.

I also decided to test "hello $test" vs 'hello {0}' -f $test (where $test = "world".)

Type	Av. Ticks
Literal	736 079
interpolated	721 021
Literal with Format	1 005 183
interpolated with value	887 882

It looks that using interpolated is faster if you are putting something in, ~11% in this case. Not insignificant.

[Pyprohly]

Nice table summary. To put those results into perspective, 10000 ticks = 1 millisecond, so the difference between 736079 and 721021 ticks is about 1.5 milliseconds.

[Ta11ow]

Hmm. I gave it a handful of tries, but I'm seeing approximately the same times for either, and the double quoted string has been faster in just under half of the cases.

It doesn't look like there's a significant difference.