Template Strings

[RayPS]

Can we use template strings like

"`firstName` `lastName` is `age` years old."

instead of using many quotes and concatenate operators like

firstName & " " & lastName & " is " & age & " years old."

[gregory]

following the javascript string interpolation would make more sense:

`${firstname} ${lastname} is ${age} years old.`

[markmelville]

Bumping. I'd love this feature. Backticks are used to escape property names that have irregular characters. It might be not be feasible to use them for templates.

[tmdoit-zz]

I did some SQL query generators and moved to template literals (later to mustache) because of hard to read and maintain the result.

[Nenzyz]

Very dirty hack ready with some small issues.

It converts expression `...` into string with concatenating expression(s) found, if regex /(\${[^}]+})+/ matches, meaning substitution pattern found ${...}. Directly the whole expression changed into string concatenation etc.

`some ${1 + 1} thing ${2 - 2}`

will be internally represented as

"some " & ( 1 + 1 ) & " thing " & ( 2 - 2 ) & ""`

Any jsonata expression can be placed as a placeholder ${...}.

Again this is very dirty.

In parser.js near comment // test for quoted names (backticks) after name = path.substring(position, end);

                    // TI parts - Special case for `template strings` of JavaScript
                    //   no nesting templated are allowed, an least for now
                    // TODO: this is a VERY dirty hack for syntactic sugar
                    // TODO: different quotes should be avoided used in between substitutions 
                    //    i.e. `some ‘asd’ ${…} "asdasd" ‘asdas’ ${…}` 
                    //    such expression will not be able to process since part between two substitutions is used
                    //    "some 'asd'" & ( ${…} ) & "asdasd" 'asdas' & ( ${…}` ) & ""
                    //    this part `"asdasd" 'asdas'` can't be quoted correctly 
                    if (name.match(/(\${[^}]+})+/) != undefined) {
                        var before_path = path.slice(0, position - 1);
                        var after_path = path.slice(end + 1);

                        var iterations = name.split(/(\${[^}]+})+/g);
                        var iter_out = [];
                        iterations.forEach(el => {
                            if (el.substring(0,2) == "${" && el.slice(-1) == "}") {
                                iter_out.push(`& ( ${el.slice(2, el.length - 1)} ) &`);
                            } else {
                                var qchar = 
                                    (el.indexOf('"') == -1) ||
                                    (el.indexOf('"') >= el.indexOf("'") && el.indexOf('"') != -1 && el.indexOf("'") != -1) || 
                                    (el.indexOf("'") != -1) 
                                    ? '"' : "'";
                                iter_out.push(`${qchar}${el}${qchar}`);
                            }
                        });
                        path = "".concat(before_path, `${iter_out.join("")}`, after_path);
                        length = path.length;
                        end = path.indexOf(iter_out[0][0], position); // looking for a quote that is first char in first element
                        name = path.substring(position, end);
                        position = end + 1;
                        return create('string', name);
                    }
                    position = end + 1;
                    return create('name', name);
                }

My fork of jsonata is not on GitHub :(

[natcl]

Bump also, this would be awesome !

[iain-b]

FWIW, me too!

[kevinmata92]

Bump, agree templating would be nice!

[evbo]

Now that JSONata is used for AWS step functions this is extra helpful formatting s3 paths and such

[akishichinibu]

Bump, using template strings in a JSONata AWS step function definition will greatly enhance the readability.

[markmelville]

I realized the backticks are like the single quote in bash: everything inside them are treated as literal characters, so there is no way that template characters inside can be treated as interpolation markers. This issue is titled, "Template Strings", not "Template Strings with backticks". So here's a feature suggestion out of left field, use guillemets for template strings:

«{firstname} {lastname} is {$calculatedAge} years old.»

if you want literal curly braces or guillemets, that's when you use backticks because backticks are the escape sequence in JSONata!

«{name}, try string interpolation with an expression like this: `«{firstname} {lastname} is {$calculatedAge} years old.»`»

Don't like it? Then suggest the operator that JSONata should use for template strings. It's never going to be backticks.