Intereting Posts

Comment rendre la forme d'onde audio sur la toile HTML5? Numéro d'augmentation automatique HTML et JavaScript Mise en route: Configuration de la base de données pour Node.js Comment puis-je utiliser Javascript en Java? Accès variable à partir du code derrière via javascript Activer les propriétés du parent avec une boucle de Guidons Déplacer les lignes de table vers le haut et vers le bas – Jquery / Javascript JQuery: modifiez le type d'élément de caché à l'entrée Entrée unique en ligne contentement Comment écrire le code javascript dans php Comment appeler un iMacro à partir de JavaScript? Pourquoi JavaScript est-il "bit à bit" ou se comporte-t-il étrangement? Activer / désactiver le zoom sur safari iPhone avec Javascript? Créez un objet JavaScript à utiliser avec jQuery .css () (et les clés en double?) Exporter pour exceller dans jquery ou jqGrid

Les modèles de Moustache peuvent-ils être étendus par un modèle?

Je suis nouveau chez Moustache.

De nombreuses langages de modèles (par exemple, Django / Jinja ) vous permettront d'étendre un modèle "parent" comme ça …

Base.html

<html><head></head> <body> {% block content %}{% endblock %} </body> </html>

Frontpage.html

 {% extends "base.html" %} {% block content %}<h1>Foobar!</h1>{% endblock %}

Rendu Frontpage.html

 <html><head></head> <body> <h1>Foobar!</h1> </body> </html>

Je suis conscient des partitions de Moustache (p. Ex., {{>content}} ), mais celles-ci semblent simplement inclure .

L'extension du modèle existe-t-elle pour Moustache? Ou, à défaut, existe-t-il au moins un motif de conception qui transforme effectivement les éléments en équivalents d'extension de modèle.

Comment capturer un nombre arbitraire de groupes dans JavaScript Regexp?

Je me suis récemment retrouvé dans le même bateau, sauf que je suis venu d'un fond de mako.

La moustache ne permet pas d'extension / héritage de modèle, mais il existe quelques options disponibles pour vous que je connais.

Vous pouvez utiliser des partiels:

 {{>header}} Hello {{name}} {{>footer}}

Vous pouvez injecter des fonctions de prétraitement de modèle dans le contexte pour chaque modèle qui doit hériter d'une autre page:

 {{#extendBase}} Hello {{name}} {{/extendBase}}

Hacher:

 { "name": "Walden", "extendBase": function() { return function(text) { return "<html><head></head>" + render(text) + "</body></html>" } } }

Préparez et ajoutez le HTML souhaité aux pages pertinentes de votre contrôleur.
Avoir un modèle de mise en page ala:
```
 {{>header}} {{{body}}} {{>footer}} 
```
Et rendez le corps dans votre contrôleur, en passant cela au modèle de mise en page en tant que body nommé variable.
Importez l'héritage de modèle, pré-moustache, dans votre code qui charge des modèles.

Cependant, je n'utiliserais pas la triple moustache parce que je ne veux pas que le HTML non imprimé apparaisse partout, il est trop risqué à mon avis.

Si quelqu'un d'autre a une meilleure solution à ce problème, j'aimerais l'entendre aussi, car je n'ai pas encore pris l'envol dans l'une de ces directions.

J'ai proposé cela aux spécifications de Moustache ici:

https://github.com/mustache/spec/issues/38

Actuellement, l'héritage du modèle de support de bigote.java, hogan.js et phly_mustache.

Vous pouvez utiliser des variables contenant du code HTML. Une «triple moustache» comme {{{variable}}} renverra un HTML non modifié. Ce n'est pas exactement le même que les extensions de modèle, mais vous pouvez rendre frontpage-content.html puis mettre sa sortie dans une variable de content qui passe à base.html .

(J'ai ajouté -content au nom de fichier frontpage.html avec l'espoir qu'un tel schéma de nomination aidera à garder les noms de fichiers gérables).

Moustache ne fait pas d'extension de modèle.

Si vous voulez vraiment une extension de modèle, vous voudrez peut-être utiliser un but de bibliothèque construit avec cette fonctionnalité pour votre langue / cadre de choix.

FYI, j'utilise Node.js / Express, alors je vais probablement finir par utiliser https://github.com/fat/stache

Je joue avec ça maintenant en Python (notez que je suis le créateur de Mako), ajoutant dans un contexte dynamique que les sections de captures semblent faire la bonne chose, mais j'aurais besoin de tester cela beaucoup plus.

Fondamentalement, nous utilisons lambdas, où un préfixe "<" indique "hériter de ce modèle" (similaire à la syntaxe discutée à https://github.com/mustache/spec/issues/38 ) et un préfixe "$" indique " C'est une section héritée ".

 import pystache class NameSpace(object): def __init__(self, renderer, vars_={}): self.renderer = renderer self._content = {} self.vars = vars_ def add_content(self, name, value): self._content[name] = value def __getattr__(self, key): if key in self.vars: # regular symbol in the vars dictionary return self.vars[key] elif key.startswith("<"): # an "inherit from this template" directive name = key[1:] return inheritor(self, name) elif key.startswith("$"): # a "here's a replaceable section" directive name = key[1:] if name in self._content: # if we have this section collected, return the rendered # version return sub_renderer(self, name) else: # else render it here and collect it return collector(self, name) else: # unknown key. raise AttributeError(key) def sub_renderer(namespace, key): def go(): def render(nested): return namespace._content[key] return render return go def collector(namespace, key): def go(): def render(nested): content = namespace.renderer.render(nested, namespace) namespace.add_content(key, content) return content return render return go def inheritor(namespace, name): def go(): def render(nested): namespace.renderer.render(nested, namespace) return namespace.renderer.render_name(name, namespace) return render return go

Voici donc quelques modèles. Base.mustache:

 <html> {{#$header}} default header {{/$header}} {{#$body}} default body {{/$body}} {{#$footer}} default footer, using {{local key}} {{/$footer}} </html>

Hello.mustache:

 {{#<base}} {{#$header}} new header {{/$header}} {{#$body}} new body, with {{local key}} {{/$body}} {{/<base}}

Et ensuite jouer avec trois niveaux de profondeur, subhello.mustache:

 {{#<hello}} {{#$footer}} im some new footer {{/$footer}} {{/<hello}}

Rendez hélas.mustache comme ceci:

 renderer = pystache.Renderer(search_dirs=["./templates/"]) print renderer.render_name("hello", NameSpace(renderer, {"local key": "some local key"}))

sortie:

 <html> new header new body, with some local key default footer, using some local key </html>

Rendu subhello.mustache:

 print renderer.render_name("subhello", NameSpace(renderer, {"local key": "some local key"}))

sortie:

 <html> new header new body, with some local key im some new footer </html>

Je viens d'écrire cela en vingt minutes, et je n'ai utilisé que handlebars.js un peu dans le passé et pitchi pour la première fois tout à l'heure, alors l'idée entière de "moustache" n'est pas encore profonde pour moi. Mais cela semble fonctionner?

En moustache php, l'héritage de modèle est pris en charge depuis la version 2.7.0.

https://github.com/bobthecow/mustache.php/wiki/BLOCKS-pragma

Vous pouvez trouver votre version actuelle à partir du fichier Moustache / Engine.php et rechercher la ligne contenant:

 class Mustache_Engine { const VERSION = '2.8.0'; ...

Si vous êtes satisfait d'un code unique sur le côté du serveur, Nun est un système de modélisation en forme de moustache avec des fonctionnalités étendues via sa fonction de "remplacement de modèles" – modelé sur django. Bien que cela fonctionne, il n'est plus conservé par son auteur.

Dans node.js, vous pouvez utiliser express-handlebars ou hogan-express pour avoir des modèles inna moustache, mais la façon dont ils font les choses est différente, dans aucun d'eux vous ne définissez la disposition sur le modèle lui-même, les mises en page sont enregistrées dans votre code d'application .