String interpolation (included): Difference between revisions

{{basic data operation}}

Given a string and defined variables or values, [[wp:String literal#Variable_interpolation|string interpolation]] is the replacement of defined character sequences in the string by values or variable values.

: For example, given an original string of <code>"Mary had a X lamb."</code>, a value of "big", and if the language replaces X in its interpolation routine, then the result of its interpolation would be the string <code>"Mary had a big lamb"</code>.

:(Languages usually include an infrequently used character or sequence of characters to indicate what is to be replaced such as "%", or "#" rather than "X").

 

# Use your languages inbuilt string interpolation abilities to interpolate a string missing the text <code>"little"</code> which is held in a variable, to produce the output string <code>"Mary had a little lamb"</code>.

# If possible, give links to further documentation on your languages string interpolation features.

 

<small>Note: The task is not to create a string interpolation routine, but to show a language's built-in capability.</small>

 

=={{header|Ada}}==

use Ada.Strings, Ada.Text_IO;

procedure String_Replace is

Put_Line (Fixed.Replace_Slice (

Original, Index, Index + Tbr'Length - 1, New_Str));

 

Alternatively

 

 

=={{header|Aikido}}==

printf ("Mary had a %s lamb\n", little)

 

// alternatively

 

=={{header|ALGOL 68}}==

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - requires formatted transput}}

'''string'''s are simply '''flex''' arrays of '''char'''. '''format'''s on the other hand take on some of the properties of '''proc'''edures including the scoping rules.

# as a STRING #

STRING extra = "little";

# or: use simply use STRING concatenation #

print(("Mary had a "+extra+" lamb.", new line))

{{out}}

<pre>

Mary had a little lamb.

</pre>

=={{header|AutoHotkey}}==

LIT = little

string = Mary had a %LIT% lamb.

string := "Mary had a" LIT " lamb."

 

 

Documentation: [http://www.autohotkey.com/docs/Variables.htm#Variables Variables] (see '''Storing values in variables''' and '''Retrieving the contents of variables''')

=={{header|AWK}}==

String interpolation is usually done with functions sub() and gsub(). gawk has also gensub().

BEGIN {

str="Mary had a # lamb."

gsub(/#/, "little", str)

print str

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

call :interpolate %1 %2 res

set str=%~2

set %3=!pat:X=%str%!

 

''Demo''

 

=={{header|Bracmat}}==

Use pattern matching to find the part of the string up to and the part of the string following the magic X. Concatenate these parts with the string "little" in the middle.

 

 

=={{header|C}}==

Include the <code><stdio.h></code> header to use the functions of the [[wp:Printf|printf]] family:

 

int main() {

printf("Mary had a %s lamb.\n", extra);

return 0;

 

=={{header|C++}}==

#include <iostream>

 

std::cout << "String after replacement: " << newString << " \n" ;

return 0 ;

 

 

{

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. interpolation-included.

 

 

GOBACK

 

=={{header|Coco}}==

As CoffeeScript, but [https://github.com/satyr/coco/wiki/additions#wiki-variable-interpolation-x the braces are optional if the expression to be interpolated is just a variable]:

 

 

=={{header|CoffeeScript}}==

size = 'little'

console.log "Mary had a #{size} lamb." # Mary had a little lamb.

Multi-line strings and arbtrary expressions work: #{ 5 * 4 }

"""

 

=={{header|Common Lisp}}==

 

More documentation on the [http://www.cs.cmu.edu/Groups/AI/html/hyperspec/HyperSpec/Body/fun_format.html FORMAT] function.

 

=={{header|D}}==

import std.stdio, std.string;

 

"Mary had a %s lamb.".format("little").writeln;

"Mary had a %2$s %1$s lamb.".format("little", "white").writeln;

{{out}}

<pre>Mary had a little lamb.

 

=={{header|Delphi}}==

 

uses

writeln(Output);

 

{{out}}

<pre>Mary had a little lamb.

 

=={{header|DWScript}}==

{{out}}

<pre>Mary had a little lamb.</pre>

 

=={{header|E}}==

 

 

The <code>`...`</code> syntax in general may be used as a sort of syntax extension; string interpolation is just the default case. [http://www.erights.org/elang/grammar/quasi-overview.html More information on E quasi-literals.] (Note that this documentation may be somewhat out of date.)

The above code is equivalent to (expands into):

 

 

If an identifier precedes the opening <code>`</code>, then it replaces <code>simple</code>; the quasiParser may be an arbitrary user-defined object. In this way, E provides lightweight syntax for embedding other languages: XML, JSON, GUI layouts, regular expressions, etc.

=={{header|EchoLisp}}==

'''format''' and '''printf''' use replacement directives to perform interpolation. See [http://www.echolalie.org/echolisp/help.html#format format specification] in EchoLisp documentatiuon.

;; format uses %a or ~a as replacement directive

(format "Mary had a ~a lamb" "little")

(format "Mary had a %a lamb" "little")

→ "Mary had a little lamb"

 

=={{header|ECL}}==

IMPORT STD;

STD.Str.FindReplace('Mary had a X Lamb', 'X','little');

 

 

=={{header|Elixir}}==

Elixir borrows Ruby's #{...} interpolation syntax.

x = "little"

IO.puts "Mary had a #{x} lamb"

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

sequence s

s = sprintf("Mary had a %s lamb.",{lambType})

See

[http://openeuphoria.org/docs/std_text.html#_3233_sprintf sprintf],

=={{header|F_Sharp|F#}}==

[http://msdn.microsoft.com/en-us/library/ee370560(VS.100).aspx Documentation]

 

=={{header|Factor}}==

 

SYMBOL: little

"little" little set

 

 

I tried to be as specific as possible here. The challenge says to use a ''variable'' so that is what I used. It could have been done more cleanly using a CONSTANT.

 

 

CONSTANT: little "little"

 

 

=={{header|Fantom}}==

Interpolating a variable value into a string is done by using a $ prefix on the variable name within a string. For example:

 

fansh> x := "little"

little

fansh> echo ("Mary had a $x lamb")

Mary had a little lamb

 

Documentation at: [http://fantom.org/doc/docLang/Literals.html#interpolation Fantom website]

 

=={{header|Fortran}}==

 

write (*,*) trim(inter("Mary had a X lamb.","X","little"))

end function inter

 

=={{header|FreeBASIC}}==

It is also possible to use C library functions such as printf or sprintf, which allow more conventional string interpolation,

as easily as if they were part of FB itself:

 

#Include "crt/stdio.bi" '' header needed for printf

x = "little"

printf("Mary also had a %s lamb", x)

 

{{out}}

 

=={{header|Frink}}==

 

=={{header|FunL}}==

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=29bc3d7010d216a49382a47cdeeec15f Click this link to run this code]'''

 

Print Subst("Mary had a &1 lamb", "little")

 

Output:

<pre>

This kind of string interpolation is indeed a strong feature in Gastona. We add one more

indirection in the sample just to ilustrate it.

 

<how> //little

<main> //Mary @<what>

{{out|Output}}

<pre>

=={{header|Go}}==

Doc: [http://golang.org/pkg/fmt/ http://golang.org/pkg/fmt/]

package main

 

fmt.Println(out)

}

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

No such facilities are defined in Haskell 98, but the <code>base</code> package distributed with GHC provides a <code>[http://hackage.haskell.org/packages/archive/base/latest/doc/html/Text-Printf.html#v:printf printf]</code> function.

 

 

 

=={{header|HicEst}}==

[http://www.HicEst.com/EDIT Further documentation on HicEst string interpolation function EDIT()]

 

output_string = original

 

=={{header|Icon}} and {{header|Unicon}}==

Icon and Unicon are descended from a line of languages with a wealth of string manipulation capabilities. [http://www.cs.arizona.edu/icon/ftp/doc/lb1up.pdf See The Icon Programming Language, 3rd Edition; Griswold and Griswold; Chapter 3 String Scanning]

s3 := "little"

s1 := "Mary had a humongous lamb."

s1 ?:= tab(find(s2)) || (=s2,s3) || tab(0) # replaces the first instance of s2 with s3

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/strings.icn Note the strings library includes convenient procedures for string replacement] such as replace(s1,s2,s3) which replaces all occurrences of s2 in s1 with s3 and replacem(s1,s2,s3,...) which replaces multiple pairs.

=={{header|J}}==

The <code>strings</code> and <code>printf</code> scripts are part of the base library.

'Mary had a %s lamb.' sprintf <'little'

Mary had a little lamb.

Mary had a little lamb.

'Mary had a %s lamb.' rplc '%s';'little'

 

Documentation:

The comments in these library files give brief descriptions of their contents, and you can browse them using open:

 

 

Alternatively, both [http://www.jsoftware.com/docs/help602/user/script_strings.htm strings] and [http://www.jsoftware.com/help/jforc/input_and_output.htm#_Toc191734427 printf] have various web pages describing them, and printf has a lab demonstrating its use (from J's IDE's menu, go Studio -> Labs... and then look in the System category).

 

=={{header|Java}}==

String little = "little";

String replaced = original.replace("X", little); //does not change the original String

//Alternative:

String formatted = String.format("Mary had a %s lamb.", little);

 

=={{header|JavaScript}}==

var little = "little";

 

Or,

 

var X = "little";

 

=={{header|jq}}==

 

'''Documentation''': [http://stedolan.github.io/jq/manual/#Stringinterpolationfoo String interpolation]

 

=={{header|Julia}}==

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

// it must be treated as an expression

println("Mary had a ${s}r lamb") // not $sr

 

{{out}}

Mary had a littler lamb

</pre>

 

=={{header|Lasso}}==

Lasso doesn't really have built-in string interpolation, but you can use the built-in email mail-merge capability:

{{out}}

<pre>Mary had a little lamb</pre>

 

=={{header|LiveCode}}==

Livecode has a [http://docs.runrev.com/Function/merge merge] function for interpolation

put merge("Mary had a [[str]] lamb.")

 

 

=={{header|Lua}}==

There is no default support for automatic interpolation of variables names being used as placeholders within a string. However, interpolation is easily emulated by using the [string.gsub] function:

 

 

=== Literal characters ===

Interpolation of literal characters escape sequences does occur within a string:

 

 

StringReplace["Mary had a X lamb.", {"X" -> Extra}]

 

=={{header|Maxima}}==

 

=={{header|Nemerle}}==

Nemerle has a few ways to accomplish this. It provides an implementation of '''printf()''', $ interpolation within the '''print()''' method, and the most general use is $ interpolation within $ quoted strings.

using System.Console;

using Nemerle.IO; // contains printf() and print()

WriteLine($"Mary had a $extra lamb.");

}

 

=={{header|NetRexx}}==

The Built In Functions (BIFs) of [[NetRexx]] can be employed to manipulate strings quite successfully but for more flexible string interpolation a function package like Java's MessageFormat should be used.

 

options replace format comments java crossref savelog symbols

 

return

{{out}}

<pre style="height: 5ex; overflow:scroll;">

 

=={{header|Nim}}==

 

var str = "little"

 

 

var str: string = "little"

echo fmt"Mary had a {str} lamb"

 

=={{header|OCaml}}==

The OCaml standard library provides the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Printf.html Printf]:

 

 

=={{header|OOC}}==

In a String all expressions between #{...} will be evaluated.

main: func {

X := "little"

"Mary had a #{X} lamb" println()

}

 

=={{header|Oz}}==

String interpolation is unidiomatic in Oz. Instead, "virtual strings" are used. [http://www.mozart-oz.org/documentation/op/node4.html Virtual strings] are tuples of printable values and are supported by many library functions.

 

X = "little"

in

 

=={{header|PARI/GP}}==

The Pari library has string interpolation, which extends C's:

string_interpolate(GEN n)

{

pari_printf("The value was: %Ps.\n", n);

GEN s = pari_sprintf("Storing %Ps in a string", n);

 

{{works with|PARI/GP|version 2.4.4 and above}}

GP can also interpolate strings:

 

=={{header|Perl}}==

print "Mary had a $extra lamb.\n";

 

=={{header|Phix}}==

string s = sprintf("Mary had a %s lamb.",{size})

{{out}}

<pre>

"Mary had a little lamb."

</pre>

 

=={{header|PHP}}==

$extra = 'little';

echo "Mary had a $extra lamb.\n";

printf("Mary had a %s lamb.\n", $extra);

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

sit: Proc Options(main);

/*********************************************************************

Return(res);

End;

{{out}}

<pre>

=={{header|PowerShell}}==

Using the format (-f) operator:

 

Using format string with the WriteLine static method

 

Using the format method of the string type

 

Note: numeric and date/time formats can be specified with {index:formatString} (i.e. {0:###,###})

 

=={{header|Prolog}}==

format('Mary had a ~w lamb.', [Extra]), % display result

 

Using [http://www.swi-prolog.org/pack/list?p=func library(func)] for SWI-Prolog:

 

 

Using [http://www.swi-prolog.org/pack/list?p=interpolate library(interpolate)] for SWI-Prolog:

 

 

=={{header|PureBasic}}==

The function [http://www.purebasic.com/documentation/string/replacestring.html ReplaceString()] is built-in and can have both constants and variables as parameters.

''' Implemented in a program context

Define txt$, txtvar.s="little"

 

Mary:

Data.s "Mary had a X lamb."

 

=={{header|Python}}==

 

Using the % [http://docs.python.org/library/stdtypes.html#string-formatting-operations string interpolation operator]:

>>> extra = 'little'

>>> original % extra

 

Using the [http://docs.python.org/library/string.html#string-formatting .format method of strings]:

>>> extra = 'little'

>>> original.format(**locals())

Using the format method, but replace by an expressions position as an argument to the format method call instead of by name:

>>> extra = 'little'

>>> original.format(extra)

 

Using the [http://docs.python.org/library/string.html#template-strings Template] class of the string module:

>>> original = Template('Mary had a $extra lamb.')

>>> extra = 'little'

>>> original.substitute(**locals())

 

Using the new [https://docs.python.org/3/whatsnew/3.6.html#whatsnew36-pep498 f-strings] string literal available from Python 3.6:

>>> f'Mary had a {extra} lamb.'

'Mary had a little lamb.'

 

=={{header|Racket}}==

See the documentation on [http://docs.racket-lang.org/reference/Writing.html?q=printf#%28def._%28%28quote._~23~25kernel%29._fprintf%29%29 fprintf] for more information on string interpolation in Racket.

 

#lang racket

 

(format "Mary had a ~a lamb" "little")

 

=={{header|REBOL}}==

size: "little"

build-markup str

;REBOL3 also has the REWORD function

str: "Mary had a $size lamb"

 

=={{header|REXX}}==

<br>However, interpolation can be emulated using the &nbsp; '''changestr''' &nbsp; function:

 

/*the string to be replaced is */

replace = "little" /*usually a unique character(s) */

say 'original4 =' original4

say 'replaced4 =' new3

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>'''output'''

 

=={{header|Ring}}==

aString =substr("Mary had a X lamb.", "X", "little")

see aString + nl

 

=={{header|Ruby}}==

=> "little"

irb(main):002:0> "Mary had a #{extra} lamb."

=> "Mary had a little lamb."

irb(main):003:0> "Mary had a %s lamb." % extra

 

Documentation:

 

=={{header|Run BASIC}}==

a$ = word$(a$,1,"X")+"little"+word$(a$,2,"X")

 

=={{header|Rust}}==

Rust has very powerful string interpolation. [https://doc.rust-lang.org/beta/std/fmt/ Documentation here.]

println!("Mary had a {} lamb", "little");

// You can specify order

// Or named arguments if you prefer

println!("{name} had a {adj} lamb", adj="little", name="Mary");

 

=={{header|Scala}}==

{{libheader|Scala}}

 

 

import util.matching.Regex._

println("Split : " + "Mary had a ${x} lamb.".split("""\$\{([^}]+)\}""").mkString(size))

}

Documentation:

* Scala 2.10.0: [http://docs.scala-lang.org/overviews/core/string-interpolation.html string interpolation]

 

=={{header|Sed}}==

# Usage example: . interpolate "Mary has a X lamb" "quite annoying"

 

=={{header|Seed7}}==

 

const proc: main is func

replaced := replace(original, "X", little);

writeln(replaced);

 

{{out}}

<pre>

Mary had a little lamb

</pre>

 

=={{header|Sidef}}==

 

or:

 

See: [https://github.com/trizen/sidef/wiki#strings documentation]

 

=={{header|SNOBOL4}}==

Every statement in SNOBOL can is a subset of pattern replacement having a subject (s1 in this case), object (s2), and replacement (s3).

s2 = "humongous"

s3 = "little"

s1 s2 = s3

See [ftp://ftp.cs.arizona.edu/snobol/gb.pdf The SNOBOL4 Programming Language; Griswold, Poage, Polonsky; Chapter 2 Pattern Matching]

 

See '''[https://www.stata.com/help.cgi?mf_printf printf]''' in Stata help.

 

 

=={{header|Swift}}==

 

=={{header|Tcl}}==

String interpolation is a fundamental operation of the Tcl language itself, and is carried out in a <tt>"</tt>double-quoted<tt>"</tt> program strings as well as bare-words. Thus, interpolation of the string from a variable is carried out with the <tt>$</tt> syntax and the string result of a command is interpolated with the <tt>[…]</tt> syntax.

puts "Mary had a $size lamb."

 

lindex $args [expr {int(rand()*[llength $args])}]

}

When more sophisticated control is required the <code>format</code> command can be used, which is very similar to the standard [[C]] library's <code>sprintf</code> function:

 

A third approach is to use <code>string map</code>.

 

Tcl also supports variable variable names. Even more powerful is nested interpolation with the <tt>subst</tt> command.

set daddy myself; set mommy {lil' bro}

set fun1 \[string\ to

set middle upper

set fun3 {aNd]}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

 

PRINT sentence_old

PRINT sentence_new

{{out}}

<pre>

Within the Unix shell, interpolation only occurs within doublequotes. Strings enclosed in singlequotes will not be subject to interpolation. Note that within the shell, a string may be used bare. If this is done each word within the string is treated separately, and any variable references or escape sequences will be substituted for their values:

 

echo Mary had a $extra lamb.

echo "Mary had a $extra lamb."

 

A ''parameter substitution'', like <code>$extra</code> or <code>${extra}</code>, interpolates its value into some string. This happens outside quotes or inside "double quotes". The other form of interpolation is [http://www.openbsd.org/cgi-bin/man.cgi?query=printf&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html printf(1)] with <code>%s</code>.

 

==={{header|C Shell}}===

echo Mary had a $extra lamb.

echo "Mary had a $extra lamb."

 

C Shell has <code>$extra</code> and <code>${extra}</code>. There are also modifiers, like <code>$file:t</code>; [http://www.openbsd.org/cgi-bin/man.cgi?query=csh&apropos=0&sektion=1&manpath=OpenBSD+Current&arch=i386&format=html csh(1) manual] explains those.

=={{header|Ursala}}==

Expressions like this

evaluate to a list of character strings beginning with <code>foo</code> and ending

with <code>bar</code>, where <code>foo</code> and <code>bar</code> are literal text (possibly multiple lines)

and <code>x</code> is any expression evaluating to a list of character

strings. Using a dot like this

makes it a function returning a list of character strings consisting

of the output from the function <code>f</code> bracketed by the literal text <code>foo</code>

and <code>bar</code>. In this task, the identity function, <code>~&</code>, is used for <code>f</code>.

 

#show+

 

These operators are parsed like parentheses.

{{out}}

<pre>

Mary had a little lamb.

</pre>

 

 

=={{header|Verbexx}}==

//

// The @INTERPOLATE verb processes a string with imbedded blocks of code. The code

@SAY (@INTERPOLATE "Mary had a { v } lamb");

 

 

=={{header|Visual Basic .NET}}==

 

Dim name as String = "J. Doe"

Dim balance as Double = 123.45

Dim prompt as String = String.Format("Hello {0}, your balance is {1}.", name, balance)

Console.WriteLine(prompt)

 

=={{header|zkl}}==

Generates a new string. For more info, refer to manual in the downloads section of [http://zenkinetic.com/ zenkinetic.com zkl page]

 

{{omit from|8086 Assembly}}

{{omit from|80386 Assembly}}

{{omit from|bc|No built-in string interpolation in bc}}

{{omit from|dc|No built-in string interpolation in dc}}

{{omit from|GUISS}}

{{omit from|Unlambda|Does not have built-in string interpolatiopn (or built-in strings, for that matter).}}

{{omit from|Z80 Assembly}}