Javascript 不可预测的行为车把助手反向循环

我为一个把手模板创建了这个助手函数

Handlebars.registerHelper('reverse_for', function(from, to, decrease, block) {
    var result = '';
    for(var i = from; i >= to; i -= decrease)
        result += block.fn(i);
    return result;
});

<div class="form-group">
    <label>Bar Width {{baseComponents.bar.product.max_width}} - {{baseComponents.bar.product.min_width}}</label>
    <select class="form-control csb-bar-width-selector">
        {{#reverse_for baseComponents.bar.product.max_width baseComponents.bar.product.min_width 1}}
            <option value="{{this}}">{{this}} inches</option>
        {{/reverse_for}}
    </select>
</div>

这套守则似乎是不合理的。它有时工作，有时不返回handlebar.js模板中{{this}}的值，尽管它有正确的输入和正确数量的项目循环

这就是我在handlebar.js模板中输出它的方式

Handlebars.registerHelper('reverse_for', function(from, to, decrease, block) {
    var result = '';
    for(var i = from; i >= to; i -= decrease)
        result += block.fn(i);
    return result;
});

<div class="form-group">
    <label>Bar Width {{baseComponents.bar.product.max_width}} - {{baseComponents.bar.product.min_width}}</label>
    <select class="form-control csb-bar-width-selector">
        {{#reverse_for baseComponents.bar.product.max_width baseComponents.bar.product.min_width 1}}
            <option value="{{this}}">{{this}} inches</option>
        {{/reverse_for}}
    </select>
</div>

同样，它有时也会起作用。这里有一个例子，它第一次工作，但不是第二次。当我重新加载时，它可能完全工作，或者根本不工作

同样，有时{{this}}输出的值正确，有时则不正确。我认为问题在于helper函数以及如何构建结果。感谢您的帮助

Handlebars.registerHelper('reverse_for', function(from, to, decrease, options) {
    var result = String('');
    for(var i = parseInt(from); i >= parseInt(to); i -= parseInt(decrease))
    {
        result += String(options.fn({'index':parseInt(i)}));
    }
    return result;
});

似乎没有问题

在我现在使用的模板中

{{ index }}

而不是

{{ this }}

输出值

parseInt和字符串转换似乎不会影响非理性结果，但将其作为仅包含索引键的对象返回似乎没有这种奇怪的行为

      Handlebars.registerHelper('each_reverse',function (context, options) {
      var fn = options.fn, inverse = options.inverse;
      var length = 0, ret = "", data;

      if (Handlebars.Utils.isFunction(context)) { context = context.call(this); }

      if (options.data) {
        data = Handlebars.createFrame(options.data);
      }

      if(context && typeof context === 'object') {
        if (Handlebars.Utils.isArray(context)) {
            length=context.length;
          for(var j = context.length-1; j >= 0; j--) {//no i18n
            if (data) {
              data.index = j;
              data.first = (j === 0);
              data.last  = (j === (context.length-1));
            }
            ret = ret + fn(context[j], { data: data });
          }
        } else {
                var keys = Object.keys(context);
                length=keys.length;
                for(j=length; j>=0;j--)
                {
                    var key = keys[j-1]
                    if(context.hasOwnProperty(key)) {
                        if(data) { 
                            data.key = key; 
                            data.value = context[key];
                            data.index = j;
                            data.first = (j === 0);
                          }
                          ret += fn(context[key], {data: data});
                    }
                }
        }
      }

      if(length === 0){
        ret = inverse(this);
      }

      return ret;
    } );