Ich suche auch nach Best Practices, um meine Apps durch eine gut durchdachte Architektur zu verbessern und zu skalieren. Alle oben genannten Vorgehensweisen funktionieren für kleine bis mittlere Apps, schlagen jedoch fehl, wenn Sie in einem größeren Team arbeiten. Ich habe verschiedene Möglichkeiten ausprobiert:
1) Ich habe diese Strategie verfolgt: https://github.com/aldeed/meteor-autoform , um Vorlagen zu skalieren und wiederzuverwenden. Der Autor hat eine sehr gute Idee zum Komponenten- und Felddesign. Ich implementiere es derzeit, weil die Community 36 Pakete entwickelt hat, die fast jeden Fall abdecken, und ich TypeScript verwenden kann , um während der Entwicklungsphase typsicher zu sein.
<template name="autoForm">
{{#unless afDestroyUpdateForm this.id}}
{{! afDestroyUpdateForm is a workaround for sticky input attributes}}
{{! See https://github.com/meteor/meteor/issues/2431 }}
<form {{atts}}>
{{> Template.contentBlock ..}}
</form>
{{/unless}}
</template>
Hier ist ein guter Blog-Beitrag dazu: http://blog.east5th.co/2015/01/13/custom-block-helpers-and-meteor-composability/ sowie hier: http: // meteorpedia .com / read / Blaze_Notes
2) Dieser sieht so vielversprechend aus, wurde aber in letzter Zeit nicht aktualisiert. Es ist ein in Kaffeeskript geschriebenes Paket namens. Blaze-Komponenten ( https://github.com/peerlibrary/meteor-blaze-components ) für Meteor sind ein System zur einfachen Entwicklung komplexer Benutzeroberflächenelemente, die rund um Ihre Meteor-App wiederverwendet werden müssen. Sie können sie in CoffeeScript, Vanilla JavaScript und ES6 verwenden. Das Beste ist, Komponenten sind OOP. Hier ist eines ihrer Beispiele:
class ExampleComponent extends BlazeComponent {
onCreated() {
this.counter = new ReactiveVar(0);
}
events() {
return [{
'click .increment': this.onClick
}];
}
onClick(event) {
this.counter.set(this.counter.get() + 1);
}
customHelper() {
if (this.counter.get() > 10) {
return "Too many times";
}
else if (this.counter.get() === 10) {
return "Just enough";
}
else {
return "Click more";
}
}
}
ExampleComponent.register('ExampleComponent');
{{> ExampleComponent }}
3) Ich mag Typen und Transpiler, die mir sagen, wo und wann etwas schief gehen wird. Ich verwende TypeScript für die Arbeit mit Meteor und habe das folgende Repository gefunden: https://github.com/dataflows/meteor-typescript-utils Es scheint, als hätte der Ersteller versucht, einen MVC-Ansatz zu erreichen.
class MainTemplateContext extends MainTemplateData {
@MeteorTemplate.event("click #heybutton")
buttonClick(event: Meteor.Event, template: Blaze.Template): void {
// ...
}
@MeteorTemplate.helper
clicksCount(): number {
// ...
}
}
class MainTemplate extends MeteorTemplate.Base<MainTemplateData> {
constructor() {
super("MainTemplate", new MainTemplateContext());
}
rendered(): void {
// ...
}
}
MeteorTemplate.register(new MainTemplate());
<template name="MainTemplate">
<p>
<input type="text" placeholder="Say your name..." id="name">
<input type="button" value="Hey!" id="heybutton">
</p>
<p>
Clicks count: {{ clicksCount }}
</p>
<p>
<ul>
{{#each clicks }}
<li> {{ name }} at <a href="{{pathFor 'SingleClick' clickId=_id}}">{{ time }}</a></li>
{{/each}}
</ul>
</p>
</template>
Leider wird dieses Projekt nicht gepflegt oder aktiv weiterentwickelt.
4) und ich denke das wurde schon erwähnt, man kann mit paketen skalieren. Das erfordert eine gute abstrakte Denkweise. Es scheint für Telescope zu funktionieren: https://github.com/TelescopeJS/Telescope
5) Meteor-Template-Erweiterung - bietet verschiedene Möglichkeiten zum Kopieren von Vorlagen-Helfern, Ereignishandlern und Hooks zwischen Vorlagen, um die Wiederverwendung von Code zu ermöglichen. Ein Nachteil ist, dass das Kopieren häufig von einem Entwickler durchgeführt werden muss, was immer wieder problematisch wird, wenn die Codebasis wächst. Darüber hinaus können ohne eine klar definierte API-Community keine Komponenten erstellt und gemeinsam genutzt werden
6) Flusskomponenten - Flusskomponenten sind im API-Design näher an Reagieren, während Blaze-Komponenten vertraute Konzepte wie Datenkontexte und Vorlagenhelfer beibehalten. Flow-Komponenten hingegen verwenden weiterhin vorlagenbasierte Ereignishandler, während Blaze-Komponenten sie zu Klassenmethoden machen, damit sie durch Vererbung einfacher erweitert oder überschrieben werden können. Im Allgemeinen scheint Blaze Components eher OOP-orientiert zu sein. Flow-Komponenten sind noch nicht offiziell freigegeben ( Text-Credits für # 5 und # 6 https://github.com/peerlibrary/meteor-blaze-components#javascript-and-es6-support )
Nummer 2 und 3 müssen ebenfalls gewöhnungsbedürftig sein, aber mit der Zeit gewinnen Sie an Entwicklungsgeschwindigkeit. Mit Nummer vier können Sie Komponenten erstellen und testen, um Ihren Code stabiler zu machen. Nummer drei bietet den Vorteil der vollständigen Typensicherheit von Typescript. Dies ist ein großes Plus, wenn Sie in einem Team mit schlechter Dokumentation entwickeln. Derzeit portiere ich jedoch Nummer zwei auf TypeScript, da ich mich sehr wohl fühle, damit zu arbeiten, und ich das Compiler-Paket nicht zwitschern muss, damit es mit Meteor funktioniert, wenn ich Gulp nicht verwende.
Es ist immer noch schwierig, den richtigen Weg zu finden, um mit Meteor zu arbeiten. Sie müssen es selbst herausfinden, sonst erhalten Sie eine übersichtliche Ordnerstruktur, aber Sie haben keine Ahnung, wo sich alles befindet. Viel Spaß beim Codieren.
