Operador lógico en un manillar.js {{#if}} condicional

Question

¿Hay alguna manera en el manillar JS para incorporar operadores lógicos en el operador condicional de manillars.js estándar? Algo como esto:

{{#if section1 || section2}}
.. content
{{/if}}

Sé que podría escribir mi propio ayudante, pero primero me gustaría asegurarme de no reinventar la rueda.

Answer 1

Esto es posible 'engañando' con un ayudante de bloque. Esto probablemente va en contra de la ideología de las personas que desarrollaron manillares.

Handlebars.registerHelper('ifCond', function(v1, v2, options) {
  if(v1 === v2) {
    return options.fn(this);
  }
  return options.inverse(this);
});

Entonces puedes llamar al ayudante en la plantilla como esta

{{#ifCond v1 v2}}
    {{v1}} is equal to {{v2}}
{{else}}
    {{v1}} is not equal to {{v2}}
{{/ifCond}}

Answer 2

Llevando la solución un paso más allá. Esto agrega el operador de comparación.

Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {

    switch (operator) {
        case '==':
            return (v1 == v2) ? options.fn(this) : options.inverse(this);
        case '===':
            return (v1 === v2) ? options.fn(this) : options.inverse(this);
        case '!=':
            return (v1 != v2) ? options.fn(this) : options.inverse(this);
        case '!==':
            return (v1 !== v2) ? options.fn(this) : options.inverse(this);
        case '<':
            return (v1 < v2) ? options.fn(this) : options.inverse(this);
        case '<=':
            return (v1 <= v2) ? options.fn(this) : options.inverse(this);
        case '>':
            return (v1 > v2) ? options.fn(this) : options.inverse(this);
        case '>=':
            return (v1 >= v2) ? options.fn(this) : options.inverse(this);
        case '&&':
            return (v1 && v2) ? options.fn(this) : options.inverse(this);
        case '||':
            return (v1 || v2) ? options.fn(this) : options.inverse(this);
        default:
            return options.inverse(this);
    }
});

Úselo en una plantilla como esta:

{{#ifCond var1 '==' var2}}

Versión de guión de café

Handlebars.registerHelper 'ifCond', (v1, operator, v2, options) ->
    switch operator
        when '==', '===', 'is'
            return if v1 is v2 then options.fn this else options.inverse this
        when '!=', '!=='
            return if v1 != v2 then options.fn this else options.inverse this
        when '<'
            return if v1 < v2 then options.fn this else options.inverse this
        when '<='
            return if v1 <= v2 then options.fn this else options.inverse this
        when '>'
            return if v1 > v2 then options.fn this else options.inverse this
        when '>='
            return if v1 >= v2 then options.fn this else options.inverse this
        when '&&', 'and'
            return if v1 and v2 then options.fn this else options.inverse this
        when '||', 'or'
            return if v1 or v2 then options.fn this else options.inverse this
        else
            return options.inverse this

Answer 3

Manillars admite operaciones anidadas. Esto proporciona mucha flexibilidad (y código más limpio) si escribimos nuestra lógica un poco diferente.

{{#if (or section1 section2)}}
.. content
{{/if}}

De hecho, podemos agregar todo tipo de lógica:

{{#if (or 
        (eq section1 "foo")
        (ne section2 "bar"))}}
.. content
{{/if}}

Solo registra estos ayudantes:

Handlebars.registerHelper({
    eq: function (v1, v2) {
        return v1 === v2;
    },
    ne: function (v1, v2) {
        return v1 !== v2;
    },
    lt: function (v1, v2) {
        return v1 < v2;
    },
    gt: function (v1, v2) {
        return v1 > v2;
    },
    lte: function (v1, v2) {
        return v1 <= v2;
    },
    gte: function (v1, v2) {
        return v1 >= v2;
    },
    and: function () {
        return Array.prototype.slice.call(arguments).every(Boolean);
    },
    or: function () {
        return Array.prototype.slice.call(arguments, 0, -1).some(Boolean);
    }
});

Answer 4

Tomando este en un nivel superior, para aquellos de ustedes que viven al límite.

esencia: https://gist.github.com/akhoury/9118682 Manifestación: Fragmento de código a continuación

Helper de manillar: {{#xif EXPRESSION}} {{else}} {{/xif}}

un ayudante para ejecutar una declaración IF con cualquier expresión

1. La expresión es una cadena escapada correctamente
2. sí tú NECESITAR Para escapar correctamente de los literales de cadena o simplemente alternar cotizaciones individuales y dobles
3. Puede acceder a cualquier función o propiedad global, es decir encodeURIComponent(property)
4. Este ejemplo supone que pasó este contexto a su manillar. template( {name: 'Sam', age: '20' } ), aviso age es un string, solo para que pueda demostrar parseInt() Más adelante en esta publicación

Uso:

<p>
 {{#xif " name == 'Sam' && age === '12' " }}
   BOOM
 {{else}}
   BAMM
 {{/xif}}
</p>

Producción

<p>
  BOOM
</p>

JavaScript: (Depende de otro ayudante: sigue leyendo)

 Handlebars.registerHelper("xif", function (expression, options) {
    return Handlebars.helpers["x"].apply(this, [expression, options]) ? options.fn(this) : options.inverse(this);
  });

Helper de manillar: {{x EXPRESSION}}

Un ayudante para ejecutar expresiones de JavaScript

1. La expresión es una cadena escapada correctamente
2. sí tú NECESITAR Para escapar correctamente de los literales de cadena o simplemente alternar cotizaciones individuales y dobles
3. Puede acceder a cualquier función o propiedad global, es decir parseInt(property)
4. Este ejemplo supone que pasó este contexto a su manillar. template( {name: 'Sam', age: '20' } ), age es un string Para fines de demostración, puede ser cualquier cosa ...

Uso:

<p>Url: {{x "'hi' + name + ', ' + window.location.href + ' <---- this is your href,' + ' your Age is:' + parseInt(this.age, 10)"}}</p>

Producción:

<p>Url: hi Sam, http://example.com <---- this is your href, your Age is: 20</p>

JavaScript:

Esto se ve un poco grande porque expandí la sintaxis y comenté en casi cada línea con fines de claridad.

Handlebars.registerHelper("x", function(expression, options) {
  var result;

  // you can change the context, or merge it with options.data, options.hash
  var context = this;

  // yup, i use 'with' here to expose the context's properties as block variables
  // you don't need to do {{x 'this.age + 2'}}
  // but you can also do {{x 'age + 2'}}
  // HOWEVER including an UNINITIALIZED var in a expression will return undefined as the result.
  with(context) {
    result = (function() {
      try {
        return eval(expression);
      } catch (e) {
        console.warn('•Expression: {{x \'' + expression + '\'}}\n•JS-Error: ', e, '\n•Context: ', context);
      }
    }).call(context); // to make eval's lexical this=context
  }
  return result;
});

Handlebars.registerHelper("xif", function(expression, options) {
  return Handlebars.helpers["x"].apply(this, [expression, options]) ? options.fn(this) : options.inverse(this);
});

var data = [{
  firstName: 'Joan',
  age: '21',
  email: 'joan@aaa.bbb'
}, {
  firstName: 'Sam',
  age: '18',
  email: 'sam@aaa.bbb'
}, {
  firstName: 'Perter',
  lastName: 'Smith',
  age: '25',
  email: 'joseph@aaa.bbb'
}];

var source = $("#template").html();
var template = Handlebars.compile(source);
$("#main").html(template(data));

h1 {
  font-size: large;
}
.content {
  padding: 10px;
}
.person {
  padding: 5px;
  margin: 5px;
  border: 1px solid grey;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script src="http://cdnjs.cloudflare.com/ajax/libs/handlebars.js/1.0.0/handlebars.min.js"></script>

<script id="template" type="text/x-handlebars-template">
  <div class="content">
    {{#each this}}
    <div class="person">
      <h1>{{x  "'Hi ' + firstName"}}, {{x 'lastName'}}</h1>
      <div>{{x '"you were born in " + ((new Date()).getFullYear() - parseInt(this.age, 10)) '}}</div>
      {{#xif 'parseInt(age) >= 21'}} login here:
      <a href="http://foo.bar?email={{x 'encodeURIComponent(email)'}}">
        	http://foo.bar?email={{x 'encodeURIComponent(email)'}}
        </a>
      {{else}} Please go back when you grow up. {{/xif}}
    </div>
    {{/each}}
  </div>
</script>

<div id="main"></div>

Moar

Si desea acceder al alcance de nivel superior, este es ligeramente diferente, la expresión es la unión de todos los argumentos, uso: digamos que los datos de contexto se ven así:

// data
{name: 'Sam', age: '20', address: { city: 'yomomaz' } }

// in template
// notice how the expression wrap all the string with quotes, and even the variables
// as they will become strings by the time they hit the helper
// play with it, you will immediately see the errored expressions and figure it out

{{#with address}}
    {{z '"hi " + "' ../this.name '" + " you live with " + "' city '"' }}
{{/with}}

JavaScript:

Handlebars.registerHelper("z", function () {
    var options = arguments[arguments.length - 1]
    delete arguments[arguments.length - 1];
    return Handlebars.helpers["x"].apply(this, [Array.prototype.slice.call(arguments, 0).join(''), options]);
});

Handlebars.registerHelper("zif", function () {
    var options = arguments[arguments.length - 1]
    delete arguments[arguments.length - 1];
    return Handlebars.helpers["x"].apply(this, [Array.prototype.slice.call(arguments, 0).join(''), options]) ? options.fn(this) : options.inverse(this);
});

Answer 5

Hay una manera simple de hacer esto sin escribir una función de ayudante ... se puede hacer dentro de la plantilla por completo.

{{#if cond1}}   
  {{#if con2}}   
    <div> and condition completed</div>  
  {{/if}}
{{else}}   
  <div> both conditions weren't true</div>  
{{/if}}

EDITAR: Por el contrario, puede hacer o haciendo esto:

{{#if cond1}}  
  <div> or condition completed</div>    
{{else}}   
  {{#if cond2}}  
    <div> or condition completed</div>  
  {{else}}      
    <div> neither of the conditions were true</div>    
  {{/if}}  
{{/if}}

Editar/Nota: Desde el sitio web del manillar: Hanyebarsjs.com Aquí están los valores falsos:

Puede usar el ayudante if para renderizar condicionalmente un bloque. Si su argumento devuelve falso, indefinido, nulo, "" o [] (un valor "falso"), entonces cualquier 'cond' (como cond1 o cond2) no se contará como verdadero.

Answer 6

Un problema con todas las respuestas publicadas aquí es que no funcionan con las propiedades vinculadas, es decir, la condición IF no se reevalúa cuando las propiedades involucradas cambian. Aquí hay una versión un poco más avanzada del ayudante que soporta las enlaces. Usa el unir función de la fuente Ember, que también se utiliza para implementar la Ember normal #if ayudante.

Esta se limita a una sola propiedad límite en el lado izquierdo, en comparación con una constante en el lado derecho, que creo que es lo suficientemente bueno para la mayoría de los fines prácticos. Si necesita algo más avanzado que una comparación simple, entonces tal vez sería bueno comenzar a declarar algunas propiedades calculadas y usar lo normal #if Ayudante en su lugar.

Ember.Handlebars.registerHelper('ifeq', function(a, b, options) {
  return Ember.Handlebars.bind.call(options.contexts[0], a, options, true, function(result) {
    return result === b;
  });
});

Puedes usarlo así:

{{#ifeq obj.some.property "something"}}
  They are equal!
{{/ifeq}}

Answer 7

Solución mejorada que básicamente funcione con cualquier operador binario (al menos números, las cadenas no funcionan bien con Eval, se ocupe de una posible inyección de script si usa un operador no definido con entradas del usuario):

Handlebars.registerHelper("ifCond",function(v1,operator,v2,options) {
    switch (operator)
    {
        case "==":
            return (v1==v2)?options.fn(this):options.inverse(this);

        case "!=":
            return (v1!=v2)?options.fn(this):options.inverse(this);

        case "===":
            return (v1===v2)?options.fn(this):options.inverse(this);

        case "!==":
            return (v1!==v2)?options.fn(this):options.inverse(this);

        case "&&":
            return (v1&&v2)?options.fn(this):options.inverse(this);

        case "||":
            return (v1||v2)?options.fn(this):options.inverse(this);

        case "<":
            return (v1<v2)?options.fn(this):options.inverse(this);

        case "<=":
            return (v1<=v2)?options.fn(this):options.inverse(this);

        case ">":
            return (v1>v2)?options.fn(this):options.inverse(this);

        case ">=":
         return (v1>=v2)?options.fn(this):options.inverse(this);

        default:
            return eval(""+v1+operator+v2)?options.fn(this):options.inverse(this);
    }
});

Answer 8

Aquí hay un enlace al ayudante de bloque que uso: Bloque de comparación ayudante. Admite todos los operadores estándar y le permite escribir código como se muestra a continuación. Es realmente bastante útil.

{{#compare Database.Tables.Count ">" 5}}
There are more than 5 tables
{{/compare}}

Answer 9

Aquí hay una solución si desea verificar múltiples condiciones:

/* Handler to check multiple conditions
   */
  Handlebars.registerHelper('checkIf', function (v1,o1,v2,mainOperator,v3,o2,v4,options) {
      var operators = {
           '==': function(a, b){ return a==b},
           '===': function(a, b){ return a===b},
           '!=': function(a, b){ return a!=b},
           '!==': function(a, b){ return a!==b},
           '<': function(a, b){ return a<b},
           '<=': function(a, b){ return a<=b},
           '>': function(a, b){ return a>b},
           '>=': function(a, b){ return a>=b},
           '&&': function(a, b){ return a&&b},
           '||': function(a, b){ return a||b},
        }
      var a1 = operators[o1](v1,v2);
      var a2 = operators[o2](v3,v4);
      var isTrue = operators[mainOperator](a1, a2);
      return isTrue ? options.fn(this) : options.inverse(this);
  });

Uso:

/* if(list.length>0 && public){}*/

{{#checkIf list.length '>' 0 '&&' public '==' true}} <p>condition satisfied</p>{{/checkIf}}

Answer 10

Similar a la respuesta de Jim, pero usando un poco de creatividad, también podríamos hacer algo como esto:

Handlebars.registerHelper( "compare", function( v1, op, v2, options ) {

  var c = {
    "eq": function( v1, v2 ) {
      return v1 == v2;
    },
    "neq": function( v1, v2 ) {
      return v1 != v2;
    },
    ...
  }

  if( Object.prototype.hasOwnProperty.call( c, op ) ) {
    return c[ op ].call( this, v1, v2 ) ? options.fn( this ) : options.inverse( this );
  }
  return options.inverse( this );
} );

Luego, para usarlo, obtenemos algo como:

{{#compare numberone "eq" numbretwo}}
  do something
{{else}}
  do something else
{{/compare}}

Sugeriría sacar el objeto de la función para un mejor rendimiento, pero de lo contrario puede agregar cualquier función de comparación que desee, incluidas "y" y "o".

Answer 11

Otra alternativa es usar el nombre de la función en #if. los #if detectará si el parámetro es funcional y si lo es, lo llamará y usará su devolución para la verificación de verdad. Debajo de MyFunction obtiene el contexto actual como this.

{{#if myFunction}}
  I'm Happy!
{{/if}}

Answer 12

Instalar Ayudantes de la verdad de Ember complemento ejecutando el siguiente comando

Ember Instale Ember-Truth-Helpers

Puede comenzar a usar la mayoría de los operadores lógicos (EQ, Not-EQ, no, y, o, GT, GTE, LT, LTE, XOR).

{{#if (or section1 section2)}}  
...content  
{{/if}}

Incluso puede incluir la subexpresión para ir más allá,

{{#if (or (eq section1 "section1") (eq section2 "section2") ) }}  
...content  
{{/if}}

Answer 13

Desafortunadamente, ninguna de estas soluciones resuelve el problema de "o" operador "cond1 || cond2".

1. Compruebe si el primer valor es verdadero

2. Use "^" (o) y verifique si lo contrario es cierto

   {{#if cond1}} Do la acción {{^}} {{#if cond2}} Do la acción {{/if}} {{/if}}

Rompe la regla seca. Entonces, ¿por qué no usar parcial para hacerlo menos desordenado?

{{#if cond1}}
    {{> subTemplate}}
{{^}}
    {{#if cond2}}
        {{> subTemplate}}
    {{/if}}
{{/if}}

Answer 14

Puedo entender por qué desea crear un ayudante para situaciones en las que tenga una gran cantidad de comparaciones variadas para realizar dentro de su plantilla, pero para un número relativamente pequeño de comparaciones (o incluso una, que fue lo que me trajo a esta página en el primer lugar), probablemente sería más fácil definir una nueva variable de manillar en su llamada de función de renderizado de vistas, como:

Pase al manillar en el render:

var context= {
    'section1' : section1,
    'section2' : section2,
    'section1or2' : (section1)||(section2)
};

y luego dentro de la plantilla de manillares:

{{#if section1or2}}
    .. content
{{/if}}

Menciono esto por el bien de la simplicidad, y también porque es una respuesta que puede ser rápida y útil mientras cumple con la naturaleza sin lógica de los manillares.

Answer 15

He encontrado un paquete de NPM hecho con cafés que tiene muchos ayudantes útiles increíbles para el manillar. Eche un vistazo a la documentación en la siguiente URL:

https://npmjs.org/package/handlebars-helpers

Puedes hacer un wget http://registry.npmjs.org/handlebars-helpers/-/handlebars-helpers-0.2.6.tgz Para descargarlos y ver el contenido del paquete.

Te va a aclarar hacer cosas como {{#is number 5}} o {{formatDate date "%m/%d/%Y"}}

Answer 16

Si solo desea verificar si uno u otro elemento está presente, puede usar este ayudante personalizado

Handlebars.registerHelper('if_or', function(elem1, elem2, options) {
  if (Handlebars.Utils.isEmpty(elem1) && Handlebars.Utils.isEmpty(elem2)) {
    return options.inverse(this);
  } else {
    return options.fn(this);
  }
});

como esto

{{#if_or elem1 elem2}}
  {{elem1}} or {{elem2}} are present
{{else}}
  not present
{{/if_or}}

Si también necesita poder tener un "o" para compararValores de retorno de la funciónPrefiero agregar otra propiedad que devuelva el resultado deseado.

¡Las plantillas deben no tener lógica después de todo!

Answer 17

Para aquellos que tienen problemas para comparar las propiedades del objeto, dentro del ayudante agregue esta solución

Ember.js helper no reconoce correctamente un parámetro

Answer 18

Acabo de llegar a esta publicación desde una búsqueda en Google sobre cómo verificar si una cadena es igual a otra cadena.

Utilizo manillarsjs en el lado del servidor de NodeJS, pero también uso los mismos archivos de plantilla en el front-end usando la versión del navegador de HanyebARSJS para analizarlo. Esto significaba que si quería un ayudante personalizado, tendría que definirlo en 2 lugares separados, o asignar una función al objeto en cuestión: ¡demasiado esfuerzo!

Lo que la gente olvida es que ciertos objetos tienen funciones heredadas que se pueden usar en la plantilla de bigote. En el caso de una cadena:

https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/string/match

An Array containing the entire match result and any parentheses-captured matched results; null if there were no matches.

Podemos usar este método para devolver una matriz de coincidencias o null Si no se encontraron coincidencias. Esto es perfecto, porque mirando la documentación del manillarsjs http://handlebarsjs.com/builtin_helpers.html

You can use the if helper to conditionally render a block. If its argument returns false, undefined, null, "", 0, or [], Handlebars will not render the block.

Asi que...

{{#if your_string.match "what_youre_looking_for"}} 
String found :)
{{else}}
No match found :(
{{/if}}

ACTUALIZAR:

Después de probar en todos los navegadores, Esto no funciona en Firefox. HanyebARSJS pasa otros argumentos a una llamada de función, lo que significa que cuando se llama String.Prototype.Match, el segundo argumento (es decir, los indicadores de regexp para la llamada de función de coincidencia según la documentación anterior) parece estar aprobada. Firefox ve esto como un uso desagradable de String.Prototype.Match, y así se rompe.

Una solución es declarar un nuevo prototipo funcional para el objeto String JS, y usa eso en su lugar:

if(typeof String.includes !== 'function') {
    String.prototype.includes = function(str) {
        if(!(str instanceof RegExp))
            str = new RegExp((str+'').escapeRegExp(),'g');
        return str.test(this);
    }
}

Asegúrese de que este código JS esté incluido antes de Ejecuta su función HandleBars.compile (), luego en su plantilla ...

{{#your_string}}
    {{#if (includes "what_youre_looking_for")}} 
        String found :)
    {{else}}
        No match found :(
    {{/if}}
{{/your_string}}

Answer 19

Aquí tenemos manillares de vainilla para múltiples lógicos && y || (y o):

Handlebars.registerHelper("and",function() {
    var args = Array.prototype.slice.call(arguments);
    var options = args[args.length-1];

    for(var i=0; i<args.length-1; i++){
        if( !args[i] ){
            return options.inverse(this);
        }
    }

    return options.fn(this);
});


Handlebars.registerHelper("or",function() {
    var args = Array.prototype.slice.call(arguments);
    var options = args[args.length-1];

    for(var i=0; i<args.length-1; i++){
        if( args[i] ){
            return options.fn(this);
        }
    }

    return options.inverse(this);
}

// Results
// {{#and foo bar sally bob}} yup {{else}} nope {{/and}} // yup
// {{#or foo bar "" sally bob}} yup {{else}} nope {{/or}} // yup

// {{#and foo bar "" sally bob}} yup {{else}} nope {{/and}} // nope
// {{#or "" "" "" "" ""}} yup {{else}} nope {{/or}} // nope

¿No está tan seguro de si es "seguro" usar "y" y "o" ... ¿tal vez cambiar a algo como "OP_And" y "Op_or"?

Answer 20

Solución correcta para y/o

Handlebars.registerHelper('and', function () {
    // Get function args and remove last one (function name)
    return Array.prototype.slice.call(arguments, 0, arguments.length - 1).every(Boolean);
});
Handlebars.registerHelper('or', function () {
    // Get function args and remove last one (function name)
    return Array.prototype.slice.call(arguments, 0, arguments.length - 1).some(Boolean);
}); 

Luego llame de la siguiente manera

{{#if (or (eq questionType 'STARTTIME') (eq questionType 'ENDTIME') (..) ) }}

Por cierto: Tenga en cuenta que la solución dada aquí es incorrecta, no está restando el último argumento, que es el nombre de la función.https://stackoverflow.com/a/31632215/1005607

Su original y/o se basó en la lista completa de argumentos

   and: function () {
        return Array.prototype.slice.call(arguments).every(Boolean);
    },
    or: function () {
        return Array.prototype.slice.call(arguments).some(Boolean);
    }

¿Alguien puede cambiar esa respuesta? Acabo de desperdiciar una hora tratando de arreglar algo en una respuesta recomendada por 86 personas. La solución es Filtrar el último argumento que es el nombre de la función. Array.prototype.slice.call(arguments, 0, arguments.length - 1)

Answer 21

Otra solución torcida para un ayudante ternario:

'?:' ( condition, first, second ) {
  return condition ? first : second;
}

<span>{{?: fooExists 'found it' 'nope, sorry'}}</span>

O un simple ayudante de Coalesce:

'??' ( first, second ) {
  return first ? first : second;
}

<span>{{?? foo bar}}</span>

Dado que estos personajes no tienen un significado especial en el marcado de Handlebars, eres libre de usarlos para nombres de ayuda.

Answer 22

Siguiendo estas 2 guías Los usuarios de los usuarios A-way-to-define y Ayudantes de encuadernación personalizada Pude ajustar mis vistas compartidas en esta publicación en desbordamiento de pila para usar esto en lugar de la declaración #IF estándar. Esto debería ser más seguro que simplemente tirar un #if allí.

Los ayudantes personalizados en esa esencia son sobresalientes.

<li>
    <a href="{{unbound view.varProductSocialBlog}}">
        {{#if-equal view.showDiv "true"}}<div>{{/if-equal}}<i class="fa fa-rss-square"></i>{{#if-equal view.showDiv "true"}}</div>{{/if-equal}}
        {{#if-equal view.showTitle "true"}}Blog{{/if-equal}}
    </a>
</li>

Estoy usando el Ember CLI Proyecto para construir mi aplicación Ember.

Configuración actual en el momento de esta publicación:

DEBUG: -------------------------------
DEBUG: Ember      : 1.5.1
DEBUG: Ember Data : 1.0.0-beta.7+canary.b45e23ba
DEBUG: Handlebars : 1.3.0
DEBUG: jQuery     : 2.1.1
DEBUG: -------------------------------

Answer 23

En Ember.js puedes usar en línea si ayuda en If Block Helper. Puede reemplazar || Operador lógico, por ejemplo:

{{#if (if firstCondition firstCondition secondCondition)}}
  (firstCondition || (or) secondCondition) === true
{{/if}}

Answer 24

Puede hacerlo simplemente usando el operador lógico como este a continuación:

{{#if (or(eq firstValue 'String_to_compare_value') (eq secondValue 'String_to_compare_value'))}}business logic goes here{{/if}}

{{#if (and(eq firstValue 'String_to_compare_value') (eq secondValue 'String_to_compare_value'))}}business logic goes here{{/if}}

Antes de cerrar si puede escribir su lógica comercial

Answer 25

Aquí hay un enfoque que estoy usando para Ember 1.10 y Ember-Cli 2.0.

// app/helpers/js-x.js
export default Ember.HTMLBars.makeBoundHelper(function (params) {
  var paramNames = params.slice(1).map(function(val, idx) { return "p" + idx; });
  var func = Function.apply(this, paramNames.concat("return " + params[0] + ";"))
  return func.apply(params[1] === undefined ? this : params[1], params.slice(1));
});

Entonces puedes usarlo en tus plantillas como esta:

// used as sub-expression
{{#each item in model}}
  {{#if (js-x "this.section1 || this.section2" item)}}
  {{/if}}
{{/each}}

// used normally
{{js-x "p0 || p1" model.name model.offer.name}}

Donde los argumentos a la expresión se pasan como p0,p1,p2 etc y p0 También se puede referenciar como this.