Angularjs 如何检查表达式在求值后是否有值

假设我有一个以下模板：

"foo['x'] = '{{ myVar }}';"

是否有一种角度的方法来检查根据我当前的范围进行评估是否会给myVar带来一些价值？我有一系列这样的小模板，我只想在值为真时将它们包含在文档中。我希望$interpole、$parse或$eval可能在这里派上用场。我确信$interpolate是无用的。另外两个呢？也许至少可以得到赋值/表达式的名称

编辑

---

我说得不够具体。我试图实现的是提前检查，例如，对当前范围求值的模板{{myVar}}是否会返回空字符串或范围变量的值（如果存在）。这个案例非常具体——当遍历一组短模板时，我想知道模板是否会返回空字符串，如果不是，则只在最终html中包含它。

我不确定您想要实现什么，但是如果您想检查myVar在当前范围内是否真实，您可以：

{{myVar ? "aw yiss" : "nope"}}

---

如果myVar为truthy，则计算为aw-yiss，否则为nope。

我最终使用了一个修改过的$interpolate提供程序，但可能有人知道一个较短的解决方案：

app.provider('customInterpolateProvider', [

  function $InterpolateProvider() {

    var startSymbol = '{{';
    var endSymbol = '}}';

    this.startSymbol = function(value){
      if (value) {
        startSymbol = value;
        return this;
      } else {
        return startSymbol;
      }
    };

    this.endSymbol = function(value){
      if (value) {
        endSymbol = value;
        return this;
      } else {
        return endSymbol;
      }
    };

    this.$get = ['$parse', '$sce', function($parse, $sce) {
      var startSymbolLength = startSymbol.length,
          endSymbolLength = endSymbol.length;

      function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) {
        allOrNothing = !!allOrNothing;
        var startIndex,
            endIndex,
            index = 0,
            expressions = [],
            parseFns = [],
            textLength = text.length,
            exp;

        var getValue = function (value) {
          return trustedContext ?
            $sce.getTrusted(trustedContext, value) :
            $sce.valueOf(value);
        };

        var stringify = function (value) {
          if (value == null) {
            return '';
          }
          switch (typeof value) {
            case 'string':
              break;
            case 'number': 
              value = '' + value;
              break;
            default: 
              value = angular.toJson(value);
          }

          return value;
        };

        var parseStringifyInterceptor = function(value) {
          try {
            return stringify(getValue(value));
          } catch(err) {
            console.err(err.toString());
          }
        };

        while(index < textLength) {
          if ( ((startIndex = text.indexOf(startSymbol, index)) !== -1) &&
               ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) !== -1) ) {
            exp = text.substring(startIndex + startSymbolLength, endIndex);
            expressions.push(exp);
            parseFns.push($parse(exp, parseStringifyInterceptor));
            index = endIndex + endSymbolLength;
          } else {
            break;
          }
        }

        if (!expressions.length && !text.contains(startSymbol) && !text.contains(endSymbol)) {
          expressions.push(text);
        }

        if (!mustHaveExpression) {
          var compute = function(values) {
            for(var i = 0, ii = expressions.length; i < ii; i++) {
              if (allOrNothing && angular.isUndefined(values[i])) {
                return;
              }
              expressions[i] = values[i];
            }
            return expressions.join('');
          };

          return angular.extend(function interpolationFn(context) {
              var i = 0;
              var ii = expressions.length;
              var values = new Array(ii);

              try {
                if (ii && !parseFns.length) {
                  return expressions[0];
                } else {
                  for (; i < ii; i++) {
                    values[i] = parseFns[i](context);
                  }
                  return compute(values);
                }
              } catch(err) {
                console.err(err.toString());
              }

            }, {
            exp: text,
            expressions: expressions,
            $$watchDelegate: function (scope, listener, objectEquality) {
              var lastValue;
              return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) {
                var currValue = compute(values);
                if (angular.isFunction(listener)) {
                  listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
                }
                lastValue = currValue;
              }, objectEquality);
            }
          });
        }
      }

      return $interpolate;
    }];
  }
]);

---

你能澄清一下你的问题吗？你的意思是你想在实际解析myVar之前知道它的值吗？或者你的意思是你想解析表达式{{myVar}}，看看它是否有值？你能创建一个你想如何使用这个模板的链接吗？如果在模板中执行此操作，foo.x将生成字符串“{{myVar}”。我无法想象你想用这个做什么。

        if (!expressions.length && !text.contains(startSymbol) && !text.contains(endSymbol)) {
          expressions.push(text);
        }

                if (ii && !parseFns.length) {
                  return expressions[0];
                } else {