107 lines
3.1 KiB
Markdown
107 lines
3.1 KiB
Markdown
Multi-Line Literal Strings
|
|
==========================
|
|
|
|
{{#include ../links.md}}
|
|
|
|
A [string] wrapped by a pair of back-tick (`` ` ``) characters is interpreted _literally_.
|
|
|
|
This means that every single character that lies between the two back-ticks is taken verbatim.
|
|
|
|
This include new-lines, whitespaces, escape characters etc.
|
|
|
|
```js
|
|
let x = `hello, world! "\t\x42"
|
|
hello world again! 'x'
|
|
this is the last time!!! `;
|
|
|
|
// The above is the same as:
|
|
let x = "hello, world! \"\\t\\x42\"\n hello world again! 'x'\n this is the last time!!! ";
|
|
```
|
|
|
|
If a back-tick (`` ` ``) appears at the _end_ of a line, then it is understood that the entire text
|
|
block starts from the _next_ line; the starting new-line character is stripped.
|
|
|
|
```js
|
|
let x = `
|
|
hello, world! "\t\x42"
|
|
hello world again! 'x'
|
|
this is the last time!!!
|
|
`;
|
|
|
|
// The above is the same as:
|
|
let x = " hello, world! \"\\t\\x42\"\n hello world again! 'x'\n this is the last time!!!\n";
|
|
```
|
|
|
|
To actually put a back-tick (`` ` ``) character inside a multi-line literal [string], use two
|
|
back-ticks together (i.e. ` `` `).
|
|
|
|
```js
|
|
let x = `I have a quote " as well as a back-tick `` here.`;
|
|
|
|
// The above is the same as:
|
|
let x = "I have a quote \" as well as a back-tick ` here.";
|
|
```
|
|
|
|
|
|
String Interpolation
|
|
====================
|
|
|
|
```admonish warning.side.wide "Only literal strings"
|
|
|
|
Interpolation is not supported for normal [string] or [character] literals.
|
|
```
|
|
|
|
~~~admonish question.side.wide "What if I want `${` inside?"
|
|
|
|
🤦 Well, you just _have_ to ask for the impossible, don't you?
|
|
|
|
Currently there is no way to escape `${`. Build the [string] in three pieces:
|
|
|
|
```js
|
|
`Interpolations start with "`
|
|
+ "${"
|
|
+ `" and end with }.`
|
|
```
|
|
~~~
|
|
|
|
Multi-line literal [strings] support _string interpolation_ wrapped in `${` ... `}`.
|
|
|
|
`${` ... `}` acts as a statements _block_ and can contain anything that is allowed within a
|
|
statements block, including another interpolated [string]!
|
|
The last result of the block is taken as the value for interpolation.
|
|
|
|
Rhai uses [`to_string`] to convert any value into a [string], then physically joins all the
|
|
sub-strings together.
|
|
|
|
For convenience, if any interpolated value is a [BLOB], however, it is automatically treated as a
|
|
UTF-8 encoded string. That is because it is rarely useful to interpolate a [BLOB] into a [string],
|
|
but extremely useful to be able to directly manipulate UTF-8 encoded text.
|
|
|
|
```js
|
|
let x = 42;
|
|
let y = 123;
|
|
|
|
let s = `x = ${x} and y = ${y}.`; // <- interpolated string
|
|
|
|
let s = ("x = " + {x} + " and y = " + {y} + "."); // <- de-sugars to this
|
|
|
|
s == "x = 42 and y = 123.";
|
|
|
|
let s = `
|
|
Undeniable logic:
|
|
1) Hello, ${let w = `${x} world`; if x > 1 { w += "s" } w}!
|
|
2) If ${y} > ${x} then it is ${y > x}!
|
|
`;
|
|
|
|
s == "Undeniable logic:\n1) Hello, 42 worlds!\n2) If 123 > 42 then it is true!\n";
|
|
|
|
let blob = blob(3, 0x21);
|
|
|
|
print(blob); // prints [212121]
|
|
|
|
print(`Data: ${blob}`); // prints "Data: !!!"
|
|
// BLOB is treated as UTF-8 encoded string
|
|
|
|
print(`Data: ${blob.to_string()}`); // prints "Data: [212121]"
|
|
```
|