Template Literal Strings
In IDL, you can create string constants using single or double quotes. You can also create template literal strings using backtick characters. These template literal strings can contain IDL expressions (the "templates") and can span multiple lines, with all whitespace and line breaks preserved in the final string (hence the word "literal"). At runtime, IDL evaluates all of the expressions within the template literal string, converts each expression to a string, and then concatenates all of the strings to produce a scalar IDL string constant.
For example:
a = [1, 2, 3, 4, 5]
result = `There are ${total(a gt 2, /int)} matches in the array ${a}.`
print, result
IDL prints:
There are 3 matches in the array [1,2,3,4,5].
As a multiline example, save the following code into a file called planets.pro:
pro planets
name = 'Jupiter'
mass = 1900e24
result = `Planet:
name: ${name}
mass: ${mass} kg`
print, result
end
Here, the template literal string spans three lines, and the second and third lines have multiple spaces at the beginning. After running this routine, IDL prints:
Planet:
name: Jupiter
mass: 1.9E+27 kg
You can see that IDL constructed the final string using the exact line breaks and spacing from the source code.
Template Literal String Expressions
To embed an IDL expression within a template literal string, use the following format:
${expression}
This expression can be any valid IDL expression, including variables, arithmetic, function calls, or even nested template literal strings. Once the expression is evaluated, the following rules are used to convert the result to a string:
| Expression Result | Conversion | Example Input | Example Output |
|---|---|---|---|
| Scalar integer | Whitespace removed | `${2 + (3 * 4)}` | 14 |
| Scalar float, double, or complex | Whitespace and unnecessary trailing zeroes removed (except right after decimal) | `${4 * atan(1)}` | 3.1415927 |
| Scalar string | Unchanged | `${"IDL is cool!"}` | IDL is cool! |
| Array or List | [value1,value2,...] | `${[1, 2, 3]}` | [1,2,3] |
| Hash or Dictionary | {key1:value1,key2:value2,...} | `${hash("a",5,"b",6)}` | {a:5,b:6} |
| IDL object | object.toString( ) | `${BigInteger.Prime(40)}` |
613747182329 |
| !NULL | String "!NULL" | `${[ ]}` | !NULL |
Note: If the result is undefined then an error is thrown.
Note: If the result is an object that does not have a toString method then an error is thrown.
Expressions with Formats
In addition to the default formats, you can specify a format string to be used with your template expression, using the following syntax:
${expression,formatString}
Here, formatString is any valid IDL format string, using either FORTRAN or C-printf style format codes. For example:
print, `The value of Pi: ${!dpi,"%5.2f"}`
print, `The value of Pi: ${!dpi,"(f5.2)"}`
In both cases IDL prints:
The value of Pi: 3.14
For arrays, lists, or hashes, the format string is used to format each element, and then the elements are concatenated together as described in the table above. For example:
IDL> x = [1:5]
IDL> `The values are: ${x,"%5d"}`
The values are: [ 1, 2, 3, 4, 5]
Since the format is just an IDL string, it can contain non-formatting characters as well:
IDL> `The values are: ${x,"...%d..."}`
The values are: [...1...,...2...,...3...,...4...,...5...]
You can even use a template literal string for the format, and dynamically construct the format string:
IDL> x=!dpi & i=25 & j=15
IDL> `The value of pi is ${x,`%-${i}.${j}f`}`
The value of pi is 3.141592653589793
Escape Characters
In addition to regular characters and template expressions, you can also embed the following characters using the backslash escape code:
| Escape Code |
ASCII Character |
ASCII Code |
|---|---|---|
| \` |
Backtick |
96 |
| \$ | Dollar sign | 36 |
| \\ | Backslash | 92 |
| \b |
Backspace |
8 |
| \f | Formfeed | 12 |
| \n | Linefeed | 10 |
| \r |
Carriage return |
13 |
| \t |
Horizontal tab |
9 |
| \v |
Vertical tab |
11 |
| \xXX |
Hexadecimal code |
XX |
Note: The \xXX escape code lets you embed any character using a two-digit hexadecimal number in the range x00 to xFF. For characters in the extended ASCII range 128–255 (x80–xFF), IDL will embed the byte value in the string but the actual output character may look different on different output devices.
Note: Unrecognized escape codes will throw a syntax error.
Note: The escape code for dollar sign \$ is only necessary if the next character is a left brace { and you want to avoid invoking a template expression. Otherwise you can just embed dollar signs directly into your string without escaping them.
As an example of using escape characters:
name = 'New Horizons'
cost = 780.6e6
launch = 2006
result = `Spacecraft:\n\tName: ${name}\n\tCost: $${cost}\n\tYear: ${launch}`
print, result
IDL prints:
Spacecraft:
Name: New Horizons
Cost: $7.806E+08
Year: 2006
Version History
|
8.9.0 |
Introduced |