代码之家  ›  专栏  ›  技术社区  ›  Michael Scott Asato Cuthbert

在JS中标记的模板字符串中插入一个正常值

  •  0
  • Michael Scott Asato Cuthbert  · 技术社区  · 3 年前

    Javascript标记的模板字符串如下

    html`<h1>hello ${name}</h1>`;
    

    是非常棒的方法,可以对每个插值变量进行有趣的处理,而不会使它们成为字符串的一部分

    `<h1>hello ${name}</h1>;
    

    如果 const name = 'Mary'; 将产生一个无法区分的字符串 '<h1>hello Mary</h1>' 。在标记的模板中,变量被单独保存,以便以后可以对其进行操作。Lit(Lit元素,Lit html)广泛使用它们,通常它们都很棒。

    然而,有时人们会想把一个变量放进去,就好像它是普通文本一样,而不是触发插值。例如:

    const main_site_header_level = 'h1';
    return html`<$${main_site_header_level}>hello ${name}</$${main_site_header_level}>`;
    

    我在哪里使用(不存在) $${variable} 以指示执行插值,就好像它只是一个普通的后引号字符串一样。

    有办法做这样的事情吗?它违背了标记文字的规范,但偶尔也会非常有用。

    1 回复  |  直到 3 年前
        1
  •  1
  •   Michael Scott Asato Cuthbert    3 年前

    您似乎需要两个级别的模板处理:某些值“立即”被替换,其余的则移交给标记函数( html 在您的情况下)。

    这个 immediate 下面代码中的函数将一个标记函数作为参数,并返回另一个标记函式,该函数只将“非立即数”值传递给给定的标记函数。代替(不存在的)符号 $${variable} ,这使用 ${{immediate:variable}} .

    function html(template, ...values) {
      console.log(template, ...values);
      return "";
    }
    function immediate(f) {
      return function(template, ...values) {
        const v = [];
        const raw = [...template.raw];
        template = [...template];
        for (let i = 0, j = 0; i < values.length; i++) {
          if (values[i] && values[i].immediate !== undefined) {
            template.splice(j, 2, template[j] + `${values[i].immediate}` + template[j + 1]);
            raw.splice(j, 2, raw[j] + `${values[i].immediate}` + raw[j + 1]);
          } else {
            v.push(values[i]);
            j++;
          }
        }
        template.raw = raw;
        return f(template, ...v);
      };
    }
    const main_site_header_level = 'h1';
    const name = 'world';
    html`<${main_site_header_level}>hello ${name}</${main_site_header_level}>`;
    immediate(html)`<${{immediate:main_site_header_level}}>hello ${name}</${{immediate:main_site_header_level}}>`;
    

    当执行此操作时,它输出

    [ '<', '>hello ', '</', '>' ] h1 world h1  // seen by the tag function html
    [ '<h1>hello ', '</h1>' ] world  // seen by the tag function immediate(html)
    

    (写完这篇文章后,似乎重复了作者自己的答案。)

        2
  •  0
  •   Michael Scott Asato Cuthbert    3 年前

    除非在Javascript中有其他方法,否则最好的方法似乎是用包装器来装饰原始函数,以处理文本标记。假设 $${variable} 就是我们想要的,像这样的东西似乎是诀窍:

    export function literal_aware_tag(func) {
        return (strings, ...values) => {
            const new_strings = [];
            const new_values = [];
            const new_raw = [];
            new_strings.raw = new_raw;
            const len = strings.length;
            let cur_str = '';
            let cur_raw = '';
            for (let i = 0; i < len - 1; i++) {
                if (strings[i].endsWith('$')) {
                    cur_str += strings[i].slice(0, -1) + values[i];
                    cur_raw += strings.raw[i].slice(0, -1) + values[i];
                } else {
                    new_strings.push(cur_str + strings[i]);
                    new_raw.push(cur_raw + strings.raw[i]);
                    new_values.push(values[i]);
                    cur_str = '';
                    cur_raw = '';
                }
            }
            new_strings.push(cur_str + strings[len - 1]);
            new_raw.push(cur_raw + strings.raw[len - 1]);
            return func(new_strings, ...new_values);
        };
    }
    

    或在TypeScript中:

    declare type TemplateTag = (strings: TemplateStringsArray, ...values: any[]) => any;
    
    export function literal_aware_tag(func: TemplateTag): TemplateTag {
        return (strings: TemplateStringsArray, ...values) => {
            const new_strings = [];
            const new_values = [];
            const new_raw = [];
            (new_strings as any).raw = new_raw;
            const len = strings.length;
            let cur_str = '';
            let cur_raw = '';
            for (let i = 0; i < len - 1; i++) {
                if (strings[i].endsWith('$')) {
                    cur_str += strings[i].slice(0, -1) + values[i];
                    cur_raw += strings.raw[i].slice(0, -1) + values[i];
                } else {
                    new_strings.push(cur_str + strings[i]);
                    new_raw.push(cur_raw + strings.raw[i]);
                    new_values.push(values[i]);
                    cur_str = '';
                    cur_raw = '';
                }
            }
            new_strings.push(cur_str + strings[len - 1]);
            new_raw.push(cur_raw + strings.raw[len - 1]);
            return func(<TemplateStringsArray><any> new_strings, ...new_values);
        };
    }
    

    然后,using应用程序可以用以下内容来装饰非文字感知标记:

    import {html as original_html} from 'lit';
    
    const html = literal_aware_tag(original_html);
    
    function my_func(tag, value) {
        return html`<$${tag}>${value}</$${tag}>`;
    }
    

    这似乎是标记文字的通用解决方案。

    对于Lit的具体示例( lit-html )这种用法将使使Lit如此快速的缓存函数无效,但在某些情况下,插入无法放入Lit语法的文字文本是值得的。(尤其是在装饰 css 标记以包括内部样式,如某个字体族集,该样式存储在变量中一次,并且在应用程序运行时预计不会更改,但避免多次对其进行硬编码,但仍允许将更改的应用程序部分运行)。

    推荐文章