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). The placeholder may be a variable name, or in some languages an arbitrary expression, in either case evaluated in the current context.

String interpolation is an alternative to building string via concatenation, which requires repeat quoting and unquoting; or substituting into a printf format string, where the variable is far from where it is used. Compare:

Two types of literal expression are usually offered: one with interpolation enabled, the other without. Non-interpolated strings may also escape sequences, in which case they are termed a raw string, though in other cases this is separate, yielding three classes of raw string, non-interpolated (but escaped) string, interpolated (and escaped) string. For example, in Unix shells, single-quoted strings are raw, while double-quoted strings are interpolated. Placeholders are usually represented by a bare or a named sigil (typically  or  ), e.g.   or , or with braces, e.g.  , sometimes both, e.g.  . In some cases additional formatting specifiers can be used (as in printf), e.g.  , and in some cases the formatting specifiers themselves can be interpolated, e.g.  . Expansion of the string usually occurs at run time.

Language support for string interpolation varies widely. Some languages do not offer string interpolation, instead using concatenation, simple formatting functions, or template libraries. String interpolation is common in many programming languages which make heavy use of string representations of data, such as Apache Groovy, Julia, Kotlin, Perl, PHP, Python, Ruby, Scala, Swift, Tcl and most Unix shells.

Algorithms
There are two main types of variable-expanding algorithms for variable interpolation:
 * 1) Replace and expand placeholders: creating a new string from the original one, by find–replace operations. Find variable reference (placeholder), replace it by its variable value. This algorithm offers no cache strategy.
 * 2) Split and join string: splitting the string into an array, merging it with the corresponding array of values, then joining items by concatenation. The split string can be cached for reuse.

Security issues
String interpolation, like string concatenation, may lead to security problems. If user input data is improperly escaped or filtered, the system will be exposed to SQL injection, script injection, XML external entity (XXE) injection, and cross-site scripting (XSS) attacks.

An SQL injection example: query = "SELECT x, y, z FROM Table WHERE id='$id' " If   is replaced with " ", executing this query will wipe out all the data in.

ABAP
The output will be:

Bash
The output will be:

Boo
The output will be:

C#
The output will be:

ColdFusion Markup Language
ColdFusion Markup Language (CFML) script syntax:

Tag syntax:

The output will be: I have 4 apples

CoffeeScript
The output will be:

Dart
The output will be:

Go
, Go does not have string interpolation. There have been some proposals for string interpolation in the next version of the language, Go 2. Instead, Go uses printf format strings in the  function, string concatenation, or template libraries like.

Groovy
In groovy, interpolated strings are known as GStrings: The output will be:

Haxe
The output will be:

Java
Java 21 does have interpolated strings thanks to JEP 430. In jshell you could use the constant STR of java.lang.StringTemplate directly. https://openjdk.org/jeps/430

JavaScript
JavaScript, as of the ECMAScript 2015 (ES6) standard, supports string interpolation using backticks. This feature is called template literals. Here is an example: The output will be:

Template literals can also be used for multi-line strings:

The output will be:

Julia
The output will be:

Kotlin
The output will be:

Nemerle
It also supports advanced formatting features, such as: The output will be:

Nim
Nim provides string interpolation via the strutils module. Formatted string literals inspired by Python F-string are provided via the strformat module, the strformat macro verifies that the format string is well-formed and well-typed, and then are expanded into Nim source code at compile-time. The output will be:

Nix
The output will be:

ParaSail
The output will be:

Perl
The output will be:

PHP
The output will be:

Python
Python supports string interpolation as of version 3.6, referred to as "formatted string literals". Such a literal begins with an  or   before the opening quote, and uses braces for placeholders: The output will be:

Ruby / Crystal
The output will be:

Rust
Rust does not have general string interpolation, but provides similar functionality via macros, referred to as "Captured identifiers in format strings", introduced in version 1.58.0, released 2022-01-13.

Rust provides formatting via the std::fmt module, which is interfaced with through various macros such as format!, write!, and print!. These macros are converted into Rust source code at compile-time, whereby each argument interacts with a formatter. The formatter supports positional parameters, named parameters, argument types, defining various formatting traits, and capturing identifiers from the environment.

The output will be:

Scala
Scala 2.10+ provides a general facility to allow arbitrary processing of a string literal, and supports string interpolation using the included  and   string interpolators. It is also possible to write custom ones or override the standard ones.

The  interpolator is a compiler macro that rewrites a format string with embedded expressions as an invocation of String.format. It verifies that the format string is well-formed and well-typed.

The standard interpolators
Scala 2.10+'s string interpolation allows embedding variable references directly in processed string literals. Here is an example:

The output will be:

Sciter (tiscript)
In Sciter any function with name starting from $ is considered as interpolating function and so interpolation is customizable and context sensitive:

Where  gets compiled to this:

Snobol
The output will be:

Swift
In Swift, a new String value can be created from a mix of constants, variables, literals, and expressions by including their values inside a string literal. Each item inserted into the string literal is wrapped in a pair of parentheses, prefixed by a backslash.

The output will be:

Tcl
The Tool Command Language has always supported string interpolation in all quote-delimited strings.

The output will be:

In order to actually format - and not simply replace - the values, there is a formatting function.

TypeScript
As of version 1.4, TypeScript supports string interpolation using backticks. Here is an example: The output will be: The  function can be used as a   function. The above example can be rewritten, thusly: The output remains the same.

Visual Basic
As of Visual Basic 14, string interpolation is supported in Visual Basic.

The output will be: