Javascript 为什么这个构造函数（使用“新函数”）会中断？

我是JS的新手，正在尝试构建一个模板函数（MOOC中的赋值），该函数基本上返回一个函数，该函数基于输入字符串和分隔符返回呈现的模板

不管怎么说，这是我目前掌握的代码，我不知道它为什么会被破坏。。我真的尝试了我能想到的一切

var template = function(stringToParse, options) {

    // find out if custom delimiters are being used
    if (typeof options != 'undefined') {
        var openDelim = options.open;
        var closeDelim = options.close;
    } else {
        var openDelim = '*(';
        var closeDelim = ')*';
    }

    // get the length of the closing delim for parsing later
    var delimCharLen = closeDelim.length;

    // helper function
    function parseOutFiller(_array) {

        // get an array of the indices of each closing delim in the string
        var closingDelims = [];
        for (i=0; i < _array.length; i++) {
            closingDelims.push(_array[i].indexOf(closeDelim));
        }

        // remove the filler text leading up to the closing dim in each substring
        for (i = 0; i < _array.length; i++) {
            if (closingDelims[i] > 0) {
                _array[i] = _array[i].slice(closingDelims[i] + delimCharLen)
            }
        }

        return _array
    }

    // split array, get the closing indices, and parse out the filler text
    var splitArray = stringToParse.split(openDelim);
    var parsedString = parseOutFiller(splitArray);

    return new Function("var locParsedString = [" + parsedString + "];\
                         var inputCopy = [];\
                         for (i=0; i < arguments.length-1; i++) {\
                             inputCopy.push(arguments[i])\
                         }\
                         var templateString = '';\
                         for (i=0; i < inputCopy.length; i++) {\
                             templateString += locParsedString[i];\
                             templateString += inputCopy[i];\
                         }\
                         templateString += locParsedString[locParsedString.length-1];\
                         nRepeat = arguments[arguments.length-1];\
                         for (i=0; i < nRepeat; i++) {\
                             console.log(templateString);\
                         }"
                       )
}

var模板=函数（stringToParse，选项）{
//了解是否正在使用自定义分隔符
如果（选项类型！=“未定义”）{
var openDelim=options.open；
var closeDelim=options.close；
}否则{
var openDelim='*（'；
var closeDelim='）*'；
}
//获取结束delim的长度，以便稍后进行分析
var delimCharLen=闭合delim.长度；
//辅助函数
函数parseOutFiller（_数组）{
//获取字符串中每个结束字符的索引数组
var closingDelims=[]；
对于（i=0；i<\u array.length；i++）{
push（_数组[i].indexOf（closeDelim））；
}
//删除每个子字符串中通向关闭dim的填充文字
对于（i=0；i<\u array.length；i++）{
if（closingDelims[i]>0）{
_数组[i]=_数组[i]。切片（closingDelims[i]+delimCharLen）
}
}
返回数组
}
//拆分数组，获取结束索引，并解析出填充文本
var splitArray=stringToParse.split（openDelim）；
var parsedString=parseOutFiller（拆分数组）；
返回新函数（“var locParsedString=[”+parsedString+”]\
var-inputCopy=[]\
对于（i=0；i

然后当我运行它时

var string = "Is <<! thing !>> healthy to <<! action !>>?";
var logResult = template(string, {open: '<<!', close: '!>>'});

logResult('this', 'eat', 3)

/*

Which should print:

"Is this healthy to eat?"
"Is this healthy to eat?"
"Is this healthy to eat?"

*/

var string=“健康吗？”；
var logResult=template（字符串，{open:''}）；
logResult（'this'，'eat'，3）
/*
其中应打印：
“这吃起来健康吗？”
“这吃起来健康吗？”
“这吃起来健康吗？”
*/

---

提前谢谢

不要使用new Function（），只需使用return Function（）{}。 这样，就不需要在函数内部创建locParserString。您可以直接使用parsedString：

var template = function(stringToParse, options) {

    // find out if custom delimiters are being used
    if (typeof options != 'undefined') {
        var openDelim = options.open;
        var closeDelim = options.close;
    } else {
        var openDelim = '*(';
        var closeDelim = ')*';
    }

    // get the length of the closing delim for parsing later
    var delimCharLen = closeDelim.length;

    // helper function
    function parseOutFiller(_array) {

        // get an array of the indices of each closing delim in the string
        var closingDelims = [];
        for (i=0; i < _array.length; i++) {
            closingDelims.push(_array[i].indexOf(closeDelim));
        }

        // remove the filler text leading up to the closing dim in each substring
        for (i = 0; i < _array.length; i++) {
            if (closingDelims[i] > 0) {
                _array[i] = _array[i].slice(closingDelims[i] + delimCharLen)
            }
        }

        return _array
    }

    // split array, get the closing indices, and parse out the filler text
    var splitArray = stringToParse.split(openDelim);
    var parsedString = parseOutFiller(splitArray);

    return function () {
        var inputCopy = [];
        for (i=0; i < arguments.length-1; i++) {
            inputCopy.push(arguments[i])
        }
        var templateString = '';
        for (i=0; i < inputCopy.length; i++) {
            templateString += parsedString[i];
            templateString += inputCopy[i];
        }
        templateString += parsedString[parsedString.length-1];
        nRepeat = arguments[arguments.length-1];
        for (i=0; i < nRepeat; i++) {
            console.log(templateString);
        }
    };

}

var模板=函数（stringToParse，选项）{
//了解是否正在使用自定义分隔符
如果（选项类型！=“未定义”）{
var openDelim=options.open；
var closeDelim=options.close；
}否则{
var openDelim='*（'；
var closeDelim='）*'；
}
//获取结束delim的长度，以便稍后进行分析
var delimCharLen=闭合delim.长度；
//辅助函数
函数parseOutFiller（_数组）{
//获取字符串中每个结束字符的索引数组
var closingDelims=[]；
对于（i=0；i<\u array.length；i++）{
push（_数组[i].indexOf（closeDelim））；
}
//删除每个子字符串中通向关闭dim的填充文字
对于（i=0；i<\u array.length；i++）{
if（closingDelims[i]>0）{
_数组[i]=_数组[i]。切片（closingDelims[i]+delimCharLen）
}
}
返回数组
}
//拆分数组，获取结束索引，并解析出填充文本
var splitArray=stringToParse.split（openDelim）；
var parsedString=parseOutFiller（拆分数组）；
返回函数（）{
var-inputCopy=[]；
对于（i=0；i

真的没有理由用那样的字符串来构建函数。我的意思是，我也认为这很不合理，但这就是他们在课堂上教授函数的方式。你应该抱怨。一般来说，这样的方法会被实际的专业程序员一致反对。@Pointy good know！！谢谢：）啊，真管用——谢谢！根据我自己的理解，使用

新函数

构造函数有什么好处吗？还是在某些情况下使用is更好？这个类让我们专门使用这个（

新函数

），但是这非常简单（而且更干净！）@Zach从一系列源代码构建代码只在非常罕见的情况下才是必要的。