Javascript 求逆值域的泛函方法

我正在为一个库编写一个模板实用程序，并试图以函数的方式（没有可变变量，理想情况下也没有中间状态）完成它这主要是一个学习练习，我知道已经有一些图书馆在做这项工作。

给定字符串：

"Hello, {{name}}! What are you doing on {{day}}?"`

我已经将模板标记与正则表达式相匹配，正则表达式与测距函数相结合，将标记的匹配作为“range”对象返回

[
  { start: 7, end: 14 },
  { start: 39, end: 45 }
]

我想将整个字符串定义为范围，以便将范围编译成函数列表

[
  { start: 0, end: 6 }
  { start: 7, end: 14, tag: true },
  { start: 15: end: 38 }
  { start: 39, end: 45, tag: true },
  { start: 46, end: 46 }
]

标记它们不是问题，但找到其他范围则是问题。这个任务显然可以通过for循环和一些计数器变量来完成，但您将改变状态<对于、

forEach

和

while

是不可能的

你将如何在不改变状态的情况下完成这项工作？是否有可能在一次过程中获得所有范围（而不是在第二次过程中使用正则表达式来查找反向范围）

最后，我将给出一个绑定函数列表，这些绑定函数如下所示：

[
  text('Hello, '),
  lookup('name'),
  text('! What are you doing on '),
  lookup('day'),
  text('?')
]

---

调用这些函数将导致一系列查找，这些查找将返回字符串值，而文本函数只是将返回其参数的绑定标识函数。

假设字符串格式正确（平衡的非嵌套

{{{

和

}

），您只需执行以下操作：

s.split(/{{|}}/g).map(function (t, i) {
    return i % 2 ? lookup(t) : text(t);
});

---

一件令人惊讶的事情可能是，当您用标记开始/结束字符串时，它用文本（“”）开始/结束数组。但是，这就是为什么可以这么简单地执行的原因。

假设您的字符串格式正确（平衡的非嵌套

{{

和

}

），您可以简单地执行以下操作：

s.split(/{{|}}/g).map(function (t, i) {
    return i % 2 ? lookup(t) : text(t);
});

---

一件令人惊讶的事情可能是，当您用标记开始/结束字符串时，它用文本（“”）开始/结束数组。但是，这就是为什么可以这么简单地执行的原因。

假设您的字符串格式正确（平衡的非嵌套

{{

和

}

），您可以简单地执行以下操作：

s.split(/{{|}}/g).map(function (t, i) {
    return i % 2 ? lookup(t) : text(t);
});

---

一件令人惊讶的事情可能是，当您用标记开始/结束字符串时，它用文本（“”）开始/结束数组。但是，这就是为什么可以这么简单地执行的原因。

假设您的字符串格式正确（平衡的非嵌套

{{

和

}

），您可以简单地执行以下操作：

s.split(/{{|}}/g).map(function (t, i) {
    return i % 2 ? lookup(t) : text(t);
});

一件令人惊讶的事情可能是，当您用标记开始/结束字符串时，它用文本（“”）开始/结束数组。然而，这就是为什么可以这么简单地完成的原因。

因为您需要“绑定函数列表”，这里有一种方法

function lookup() {
  return this.toUpperCase();
}
function text() {
  return this.toString();
}

function parse(input) {
    return input.split(/(?=\{\{)|\}\}/g).map(function (part) {
        var isPlaceholder = part.slice(0, 2) === '{{',
            txt = isPlaceholder ? part.slice(2) : part;
        return (isPlaceholder ? lookup : text).bind(txt);
    });
}

function materialize(parts) {
    return parts.map(function(f) { return f(); }).join("");
}

materialize(parse("Hello, {{name}}! What are you doing on {{day}}?"));
// -> "Hello, NAME! What are you doing on DAY?"

因为您需要“绑定函数列表”，这里有一种方法

function lookup() {
  return this.toUpperCase();
}
function text() {
  return this.toString();
}

function parse(input) {
    return input.split(/(?=\{\{)|\}\}/g).map(function (part) {
        var isPlaceholder = part.slice(0, 2) === '{{',
            txt = isPlaceholder ? part.slice(2) : part;
        return (isPlaceholder ? lookup : text).bind(txt);
    });
}

function materialize(parts) {
    return parts.map(function(f) { return f(); }).join("");
}

materialize(parse("Hello, {{name}}! What are you doing on {{day}}?"));
// -> "Hello, NAME! What are you doing on DAY?"

因为您需要“绑定函数列表”，这里有一种方法

function lookup() {
  return this.toUpperCase();
}
function text() {
  return this.toString();
}

function parse(input) {
    return input.split(/(?=\{\{)|\}\}/g).map(function (part) {
        var isPlaceholder = part.slice(0, 2) === '{{',
            txt = isPlaceholder ? part.slice(2) : part;
        return (isPlaceholder ? lookup : text).bind(txt);
    });
}

function materialize(parts) {
    return parts.map(function(f) { return f(); }).join("");
}

materialize(parse("Hello, {{name}}! What are you doing on {{day}}?"));
// -> "Hello, NAME! What are you doing on DAY?"

因为您需要“绑定函数列表”，这里有一种方法

function lookup() {
  return this.toUpperCase();
}
function text() {
  return this.toString();
}

function parse(input) {
    return input.split(/(?=\{\{)|\}\}/g).map(function (part) {
        var isPlaceholder = part.slice(0, 2) === '{{',
            txt = isPlaceholder ? part.slice(2) : part;
        return (isPlaceholder ? lookup : text).bind(txt);
    });
}

function materialize(parts) {
    return parts.map(function(f) { return f(); }).join("");
}

materialize(parse("Hello, {{name}}! What are you doing on {{day}}?"));
// -> "Hello, NAME! What are you doing on DAY?"

是否有可能在一次通过中获得所有范围

是-因为您可以将带有捕获组的正则表达式用于输入字符串：

var tag = /(\{\{.+?\}\})/;
var parts = str.split(tag);

然后，您可以直接将这些内容添加到您的函数中：

var res = parts.map(function(part) {
    return tag.test(part) ? lookup(part.slice(2, -2)) : text(part);
});

根本不需要范围：-）

是否有可能在一次通过中获得所有范围

是-因为您可以将带有捕获组的正则表达式用于输入字符串：

var tag = /(\{\{.+?\}\})/;
var parts = str.split(tag);

然后，您可以直接将这些内容添加到您的函数中：

var res = parts.map(function(part) {
    return tag.test(part) ? lookup(part.slice(2, -2)) : text(part);
});

根本不需要范围：-）

是否有可能在一次通过中获得所有范围

是-因为您可以将带有捕获组的正则表达式用于输入字符串：

var tag = /(\{\{.+?\}\})/;
var parts = str.split(tag);

然后，您可以直接将这些内容添加到您的函数中：

var res = parts.map(function(part) {
    return tag.test(part) ? lookup(part.slice(2, -2)) : text(part);
});

根本不需要范围：-）

是否有可能在一次通过中获得所有范围

是-因为您可以将带有捕获组的正则表达式用于输入字符串：

var tag = /(\{\{.+?\}\})/;
var parts = str.split(tag);

然后，您可以直接将这些内容添加到您的函数中：

var res = parts.map(function(part) {
    return tag.test(part) ? lookup(part.slice(2, -2)) : text(part);
});

---

根本不需要范围：-）

我知道这是一个学习练习，但是否有特定的理由获取子字符串的位置？如果可以进行其他操作，则不需要。我的目的是跟踪子字符串索引，以便稍后将其切分，以从以后构建就地模板函数。

replace

方法非常灵活，因为它可以将回调函数作为替换参数，使用它时，您不需要知道索引是什么。警告！不推荐使用

“你好，{{name}！你在{day}上做什么？”.match（/\{{w+}}}}.+？（？=\{{\w+}}}}}}.$）/g）

我在想这样的事情：（没有建立函数列表的步骤）我知道这是一个学习练习，但是否有特定的理由获得子字符串的位置？如果可以进行其他操作，则不会。我的目的是跟踪子字符串索引，以便稍后将其切分，以从以后构建就地模板函数。

replace

方法非常灵活，因为它可以将回调函数作为替换参数，使用它时，您不需要知道索引是什么。警告！不推荐使用

“你好，{{name}！你在{day}上做什么？”.match（/\{{w+}}}}.+？（？=\{{\w+}}}}}}.$）/g）

我在想这样的事情：（没有建立函数列表的步骤）我知道这是一个学习练习，但是否有特定的理由获得子字符串的位置？如果可以进行其他操作，则不会。我的目的是跟踪子字符串索引，以便稍后将其切分，以从以后构建就地模板函数。

replace

方法非常灵活，因为它可以将回调函数作为替换参数，使用它时，您不需要知道索引是什么。警告！不推荐

“你好，{{{name}}！你在{{day}}上做什么？”.match（/\{{w+}}}}.+？（？={{{\w+}}}}}}}$）/g）

我在想这样的事情：（没有建立函数列表的步骤）我知道这是一个学习练习，但获得函数列表的位置有什么特别的原因吗