Nos experts ont rassemblé ces QCM Meteor - JavaScript Web Framework grâce à des recherches. Nous espérons qu'en répondant à ces questions à choix multiples, vous pourrez tester vos connaissances sur Meteor - JavaScript Web Framework.
Faites défiler vers le bas pour commencer maintenant !
A. if (meteor.isserver) {Meteor.invoke («SampleMethod»); }
B. if (meteor.islient) {meteor.invoke («samplemethod»); }
C. if (meteor.isserver) {meteor.call («sampleMethod»); }
D. if (meteor.islient) {Meteor.Call («SampleMethod»); }
A. accès
B. refuser
C. permettre
D. Permet -Sworng andS
A. ID de l'utilisateur
B. nom d'utilisateur
C. ConnectionId
D. ClientAddress
A. Router.Route ('/ files /: name_of_file', function () {// action}, {run: 'server'});
B. Router.Route ('/ files /: name_of_file', function () {// action}, {where: 'server'});
C. Router.Route ('/ files /: name_of_file', function () {// action}, {Route: 'server'});
D. Router.Route ('/ files /: name_of_file', function () {// action}, {at: 'server'});
A. modèle name = "home"> {{#markdown}} ## Bienvenue sur mon site {{/ markdown}} </ template>
B. modèle name = "home"> {{markdown}} ## Bienvenue sur mon site {{/ markdown}} </ template>
C. modèle name = "home"> {markdown} ## Bienvenue sur mon site {/ markdown} </ template>
A. créé
B. surnommé
C. aigu
D. Rendu
A. Tracker.computation.stop ();
B. Tracker.autorun.stop ();
C. Tracker.computation.halt ();
D. Tracker.autorun.end ();
A. METEOR Ajouter un mot de passe de comptes de comptes
B. Meteor Ajouter un mot de passe des comptes d'utilisateurs
C. Meteor Ajouter des comptes-UI Accoutes-Password
D. Meteor Ajouter un mot de passe utilisateur utilisateur
A. réactif-json
B. dict réactif
C. réactif-var
D. Tous ces. -Wrong Ans
A. chargé
B. Rendu
C. prêt
D. init
A. Http.post («http: // someurl», postdata,…);
B. Http.get («http: // someurl»,…);
C. Http.Request ("get", "http: // someUrl",…);
D. Http.call ("get", "http: // someUrl",…);
A. La recherche d'expression régulière est en temps réel
B. La recherche d'expression régulière peut correspondre aux mots partiels
C. La recherche d'expression régulière est très efficace
D. La recherche d'expression régulière ne prend pas en charge
A. Inscription des utilisateurs
B. Vérification de l'E-mail
C. Réinitialiser le mot de passe
D. Tous ces.
A. {{> LoginButtons}}
B. {{> logindropdown}}
C. {{> Login}}
D. {{> Loginform}}
A. forme de connexion
B. comptes
C. Accounts-Ui-unstyled
D. Accounts-Ui -Wrong Ans
A. db.leaderboard.enSureIndex ({point: 1})
B. db.leaderboard.enSureIndex ({mois: 1})
C. db.leaderboard.enSureIndex ({fullname: 1})
D. db.leaderboard.enSureIndex ({année: 1})
A. répéter
B. chaque
C. pour chaque
D. map --wrong et
A. Meteor Add #markdown
B. Meteor Ajouter Markdown
C. Modèle de marque d'ajout de météore
D. Modèle d'ajout de météore: Markdown
A. Return template.instance (). Couter.get ();
B. Renvoie ce.counter.get ();
C. Return template.currentData (). Couter.get ();
D. Return template.instance (). Data.counter.get ();
A. {{#avec}}
B. {{#contexte}}
C. {{avec}}
D. {{contexte}}
A. endent
B. créé
C. Rendu
D. ondestroyed -wrong Ans
A. Todos.find ({tri: {date: -1}}, {limite: 10})
B. Todos.find ({}, {limite: 10, tri: {date: -1}})
C. Todos.find ({}, {limite: 10, tri: 1})
D. Todos.find ({}, {limite: 10, tri: -1})
A. Meteor.publish ('getCollaborators', function (appid) {return users.find ({collaborateurs: appid});});
B. Meteor.publish ('getCollaborators', function (appid) {return users.find ({apps: appid});});
C. Meteor.publish ('getCollaborators', function (appid) {var app = apps.findOne ({_ id: appid}); if (app) {return users.find ({_ id: {$ in: app.collaborators}}) ;} else {this.ready ();}});
D. Meteor.publish ('getCollaborators', function (appid) {var app = apps.findOne ({_ id: appid}); return users.find ({_ id: {$ in: app.collaborators}});});
A. JSON
B. ensemble
C. Ejson
D. obtenir
A. $ set
B. $ Inc
C. trouver
D. Trouver tout
A. Meteor.account.allow ()
B. Meteor.permission.allow ()
C. Meteor.roles.allow ()
D. Meteor.users.allow ()
A. forme de connexion
B. comptes
C. Accounts-Ui-unstyled
D. Accounts-Ui -Wrong Ans
A. Comptes.config ({closeClientAccountCreation: true});
B. Comptes.config ({interdictiondAccountCreation: true});
C. Accounts.Config ({ForbidClientAccountCreation: true});
D. Comptes.config ({closeAccountCreation: true});
A. satelizer
B. comptes-base
C. authentique
D. auto-base
A. Deux applications: A et B
B. Une collection partagée: publications
C. Une base de données partagée via Mongo_url
D. Tout ce qui précède
A. Tableau
B. Base de données
C. Modèle
D. Données
A. comme s'assurer que les bonnes clés sont utilisées
B. s'assurer que nos noms d'équipe sont uniques
C. définir une limite de caractère maximum pour que nos noms d'équipe ne soient pas trop longs
D. Tout ce qui précède
A. if (meteor.islient) {Meteor.Methods ({'SampleMethod': function () {console.log ("Hello World");}}); }
B. if (meteor.isserver) {Meteor.Methods ({'SampleMethod': function () {console.log ("Hello World");}}); }
C. if (meteor.islient) {Meteor.Methods ({fonction SampleMethod () {console.log ("Hello World");}}); }
D. if (meteor.isserver) {Meteor.Methods ({fonction SampleMethod () {console.log ("Hello World");}}); }
A. {{-> mytemplate}}
B. {{<myTemplate}}
C. {{> mytemplate}}
D. {{mytemplate}}
A. réactif-json
B. dict réactif
C. réactif-var
D. Tous ces. Mauvais Ans
A. réactif-json
B. dict réactif
C. réactif-var
D. Tout ce qui précède
A. var mydate = ejson.parse (myjsondate);
B. var mydate = json.fromjsonValue (myjSondate);
C. var mydate = meteor.fromjsonValue (myjSondate);
D. var mydate = json.parse (myjSondate);
A. .première exécution
B. .dernier tour
C. .première fois
D. .issirst
A. PatternMatch (MyVar, String);
B. test (myvar, string);
C. match (myvar, string);
D. Vérifier (MyVar, String);
A. Il y aura beaucoup d'abonnements "getcomments" juste après avoir ajouté un commentaire
B. Il y aura beaucoup d'abonnements "getcomments" juste après le chargement de la page
C. Il y aura beaucoup d'abonnements "GetUser" juste après avoir ajouté un commentaire
D. Il y aura beaucoup d'abonnements "getuser" juste après le chargement de la page
A. Template.Template_Containing_aceTexteditor.Configuration = function () {return function (editor) {if (session.get ('text') == "quelque chose") // Je veux que ce soit réactif {// faire quelque chose à chaque fois ' ' changements } } }
B. Tracker.autorun (function () {if (session.get ('text') == "quelque chose") // cela s'exécutera chaque fois *
C. Les deux ci-dessus
D. Aucune de ces réponses
A. Données sur le fil via le protocole de données distribué (DDP)
B. Compensation de latence avec mini bases de données
C. Réactivité complète de la pile avec l'incendie et le tracker
D. Tout ce qui précède
A. Tracker.reactive ()
B. Template.autorun ()
C. Tracker.autorun ()
D. Template.execute ()
A. {{#if currentUser}} <Button id = "soumid-btn"> Cliquez sur moi </ bouton> {{else}} <p id = "soumi-text"> Veuillez vous connecter pour soumettre {{/ if}} * **
B. Template.newPost.rendered = function () {if (meteor.user ()) {$ ('# soumi-btn'). Show (); $ ('# soumi-text'). hide (); } else {$ ('# soumi-btn'). hide (); $ ('# soumi-text'). show (); }}
C. Template.newPost.rendered = function () {if (meteor.user ()) {$ ('# soumi-btn'). Show (); $ ('# soumi-text'). hide (); }}
D. Tout ce qui précède
A. Session.set («compteur», 0); Template.simple.counter = function () {return session.get ('counter'); } Template.simple.events ({'click bouton': function () {session.set ('counter', session.get ('compter') + 1);}});
B. Template.set ('compteur', 0); Template.simple.counter = function () {return session.get ('counter'); } Template.simple.events ({'click bouton': function () {template.set ('counter', template.get ('counter') + 1);}});
C. Template.get ('compteur', 0); Template.simple.counter = function () {return session.set ('counter'); } Template.simple.events ({'click bouton': function () {session.set ('counter', session.get ('compter') + 1);}});
D. Tout ce qui précède
A. Ejson
B. Json
C. Variable
D. Tout ce qui précède
A. Meteor Créer MyApp
B. Application Meteor MyApp
C. Meteor -Create MyApp
D. Meteor -App MyApp
A. $ meteorutils.autorun ($ scope, function () {$ meteorsubscribe.subscribe ('apublication', $ scope.getReactively ('paramètre')) .Then (function () {alert ("vous vous êtes abonné!");}); });
B. Meteor.publish ("apublication", function (paramètre) {acollection.find ({'apploperty': 'paramètre'}) $ abonne "Vous avez abonné!");});
C. Les deux ci-dessus
D. Aucune de ces réponses
A. Il y a un bogue dans le code client.
B. Lorsqu'un nouvel utilisateur a ajouté un commentaire, ses informations d'utilisateur n'ont pas été envoyées au client.
C. La publication indiquée ci-dessus n'envoie jamais d'informations utilisateur au client.
D. La publication indiquée ci-dessus est erronée
A. réactif-var
B. réactif
C. vars réactifs
D. réactif
A. Template.template_name.created = function () {}; Template.template_name.rendered = function () {};
B. Template.template_name.new = function () {}; Template.template_name.rendered = function () {};
C. Template.template_name.active = function () {}; Template.template_name.rendered = function () {};
D. Template.template_name.created = function () {}; Template.template_name.active = function () {};
A. Utilisez SQL SINTAX à côté du client: débarrassez-vous des limitations minimongo du regroupement et des syndicats. Utilisez Alasql sur le client et normalisez les collections Mongo.
B. Utilisez un connecteur SQL: essayez les connecteurs MySQL et PG de Numltel ou le connecteur PG Meteor-Stream. L'inconvénient est qu'ils cassent les déploiements en météore.
C. Utilisez Mongo comme esclave pour la base de données relationnelle, en les gardant en synchronisation. MySQL Shadow utilise ceci. Vous voudrez peut-être regarder Symmetric.DS pour définir la réplication bidirectionnelle de Mongo avec beaucoup de moteurs SQL.
D. Tout ce qui précède
A. Meteor.settings.facebook.token
B. Meteor.settings.public.token
C. Meteor.public.facebook.token
D. Meteor.settings.public.facebook.token
A. accès
B. refuser
C. permettre
D. permet
A. this.Userid;
B. this.Userid;
C. this.loggedUserid;
D. this.loggedUseid;
A. répéter
B. chaque
C. pour chaque
D. carte
A. $ groupe
B. $ out
C. $ projet
D. $ Puck
E. $ se dérouler
A. MyCollection = new db.collection («échantillons»)
B. MyCollection = nouvelle collection («échantillons»)
C. MyCollection = new Mongo.collection («échantillons»)
D. MyCollection = new MongoDB.collection («échantillons»)
A. if (meteor.islient) {template.home.events ({"cliquez. $ inc: {clics: 1}}); else compter.insert ({clics: 1});}}); Template.home.helpers ({clics: function () {var Counterdoc = Counter.FindOne (); return Counterdoc? CounterDoc.Clicks: "0";}}); }
B. <template name = "home"> {{clics}} <br/> <Button type = "Button" class = "incrément"> incrément </ bouton> </ template>
C. Compter = new Mongo.collection ('compteur'); Counter.Attachschema (new Simpleschema ({clics: {type: numéro}, créé: {type: date, denyupdate: true, autovalue: function () {if (this.isinsert) renvoie une nouvelle date; else if (this.isupsert) return {$ setoninsert: new Date}; else this.unset ();}}}));
D. Tout ce qui précède
A. Template.layout.helper ({foohelper: function () {return 'foo string';}});
B. Template.layout.helpers ({foohelper: function () {return 'foo string';}});
C. Template.layout ({foohelper: fonction helper () {return 'foo string';}});
D. Template.layout.helpers ({fonction foohelper () {return 'foo string';}});
A. myMethod: function () {console.log (this.Userid); fonction innerFunction () {console.log (this.userid); } innerfunction.bind (this); }
B. myMethod: function () {console.log (this.Userid); fonction innerFunction () {console.log (this.userid); }; innerfonction.Apply (this); }
C. myMethod: function () {var that = this; console.log (this.Userid); fonction innerFunction () {console.log (that.userid); } innerFunction (); }
D. myMethod: function () {var userId = this.UserId; console.log (this.Userid); fonction innerFunction (userId) {console.log (userId); innerfonction (); }
E. Tout ce qui précède
A. Meteor.clientcall.methods ({'consolelog': fonction (message) {console.log (message);},});
B. DepS.autorun (function () {meteor.clientcall.setClientId (Meteor.Userrid ());});
C. Meteor.clientcall.apply (utilisateur, «consolelog», [«ce message devrait apparaître dans la console client»]);
D. Tout ce qui précède
A. Template.footemplate.helpers ({myHelper: function (myString) {Output = myString;}});
B. Template.footemplate.helpers ({myHelper: function (paramètres) {output = paramètres.hash.mystring}});
C. Template.footemplate.helpers ({myHelper: function (paramètres) {output = paramètres.mystring}});
A. Router.route = {registre: 'registre'}
B. Router.route («registre»);
C. Router.route ('/ registre');
D. Router.route ('/ &? Registre');
A. Meteor.function ('pack.add', texte);
B. Meteor.apply ('pack.add', texte);
C. Meteor.call ('pack.add', texte);
D. Tout ce qui précède
A. Poster.update ('post_id', {set: {title: 'nouveau titre de post!'}});
B. Poster.update ('post_id', {$ set: {title: 'nouveau titre de post!'}});
C. Post.update ('post_id', {mise à jour: {title: 'nouveau titre de POST!'}});
D. Post.update ('post_id', {$ set {title: 'nouveau titre de POST!'}});
A. var AnswersByQuiz1 = Answers.find ({'Quiz._id': 1}). fetch ();
B. var réponses = réponses.find ({'Quiz._id': {$ in: [1,2,3,4,5,6,7]}}). fetch ();
C. _.groupBy (réponses, fonction (réponse) {return réponse.quiz._id;});
D. Tout ce qui précède
A. Meteor.Publish ('Posts', posts.find ({auteur: auteur}));
B. Meteor.Publish ('Posts', fonction (auteur) {return Posts.Publish ({auteur: auteur});});
C. Meteor.Publish ('Posts', fonction (auteur) {return Posts.Find ({auteur: auteur});});
D. Meteor.find ('Posts', function (auteur) {return posts.publish ({auteur: auteur});});
A. var sélectionné = [{objet}, {objet}]; var selectedId = Tips.Find (). fetch ();
B. var selectedIdS = _.Pluck (sélectionné, _id); var articles = Tips.find ({_ id: {$ nin: selectedID}});
C. var sélectionné = [{objet}, {objet}]; var selectedId = Tips.Find ({_ id: {$ nin: selectedID}});
D. Tout ce qui précède
A. Posts = new Mongo.Collection ('Posts);
B. Posts = new Mongo.Collection ('Posts);
C. Posts = new Mongo.Collection ('Posts);
D. Posts = new Mongo.Collections ('Posts);
A. Meteor Ajouter sécurisé
B. Meteor Ajouter un mot de passe
C. Meteor supprimer l'insécurité
D. Meteor Ajouter une stratégie
A. Targets = new Meteor.Collection ("Targets", {transform: function (doc) {doc.title = function () {if (false) {console.log ("true"); return 'le commençant';} else { console.log ("false"); return 'le debut';} return doc}}});
B. Cibles = new Meteor.Collection ("cibles"); Targets.insert ({id: 0, title: function () {if (false) {console.log ("true"); return 'le commençant';} else {console.log ("false"); return 'le Début ';}}, texte:' Lorem ipsum Dolor. ',}); `
C. Templates.Content.target = function () {var currentPosition = Meteor.User (). Profil.Position; return Targets.FindOne ({id: parseInt (currentPosition)}); };
D. Tout ce qui précède
A. Template.example.events ({'cliquer #updatethis': function (e, t) {var newValue = t. $ ('. NewValue'). Val (); // prendre la valeur de la collection d'entrée aléatoire.update ({_ id : this._id}, {$ set: {value: newValue}}, fonction (erreur, résultat) {if (error) {console.log (error.reason)} else {console.log ("belle mise à jour")} })}})
B. Template.example.event ({'cliquez #updateThis': fonction (e, t) {var newValue = t. $ ('. NewValue'). Val (); // prendre la valeur de la collection d'entrée aléatoire.update ({_ id : this._id}, {$ set: {value: newValue}}, fonction (erreur, résultat) {if (error) {console.log (error.reason)} else {console.log ("belle mise à jour")} })}})
C. Template.example.events ({'dbclick #updatethis': function (e, t) {var newValue = t. $ ('. NewValue'). Val (); // prendre la valeur de la collection d'entrée aléatoire.update ({_ id : this._id}, {$ set: {value: newValue}}, fonction (erreur, résultat) {if (error) {console.log (error.reason)} else {console.log ("belle mise à jour")} })}})
D. Tout ce qui précède
A. Folder in / serveur Ajouter un fichier .js contenant: meteor.publish ('poteaux', function () {return posts.find ();}); Folder dans / client Ajouter un fichier .js contenant: meteor.subscribe ('Posts');
B. Folder dans / client Ajouter un fichier .js contenant: meteor.publish ('poteaux', function () {return posts.find ();}); Folder in / serveur Ajouter un fichier .js contenant: meteor.subscribe ('Posts');
C. Folder in / serveur Ajouter un fichier .js contenant: meteor.Subscribe ('Posts', function () {return posts.find ();}); Folder dans / client Ajouter un fichier .js contenant: meteor.posts («publications»);
D. Folder in / serveur Ajouter un fichier .js contenant: meteor.publish ('poteaux', function () {return posts.find ();}); Folder dans / client Ajouter un fichier .js contenant: meteor.subscribe ('Posts');
A. Meteor.publish ('poteaux', function () {return posts.find ({}, {champs: {title: true}});});
B. Meteor.publish ('poteaux', function () {return posts.find ({}, {fields: {title: 1}});});
C. Meteor.publish ('poteaux', function () {return posts.find ({}, {field: {title: 1}});});
D. Meteor.publish ('poteaux', function () {return Posts.Find ({}, champs: {title: 1});});
A. {"_id": "W78123BYUXEDW"}
B. {"id": "W78123BYUXEDW"}
C. {"Id": "W78123BYUXEDW"}
D. {"Key": "W78123BYUXEDW"}
A. MyCollection.Find ();
B. MyCollection.fetch ();
C. MyCollection.Search ();
D. MyCollection.get ();
A. Il est impossible de rendre un seul chemin ou une partie de celui-ci.
B. Il est difficile d'envoyer un sous-ensemble de l'arbre au client.
C. Il n'y a aucun problème avec ce modèle.
D. DDP n'a aucun support pour ce modèle.
A. Template.example.helpers ({PostsList: function () {return Posts.Find ({}, {tri: {timePublished: 1}});}});
B. Template.example.helpers ({PostsList: function () {return Posts.Find ({}, {Sort: {timePublished: 0}});}});
C. Template.example.helpers ({PostsList: function () {return Posts.Find ({}, {tri: {timePublished: 'desc'}});}});
D. Template.example.helpers ({PostsList: function () {return Posts.Find ({}, {tri: {timePublished: -1}});}});
A. CurrentPath ()
B. getQueryParam ()
C. getCurrentRouteParam ()
D. getRoutename ()
A. 1
B. 2
C. 3
D. Infini
A. forme de connexion
B. comptes
C. Accounts-Ui-unstyled
D. Accounts-Ui
A. Template.myTemplate.Events ({'cliquez sur #mybutton': function () {..},});
B. Template.myTemplate.Events ({'cliquez sur $ myButton': function () {..},});
C. Template.myTemplate.Events ({'cliquez.
D. Template.myTemplate.Events ({'cliquez sur MyButton': function () {..},});
A. Hands.gegisthelper ('ifRouteis', function (routename) {return meteor.router.page () === routename;});
B. Handlebars.RegisterHelper ('ifRouteis', fonction (routename, options) {if (meteor.router.page () === Routename) {return options.fn (this);} return options.inverse (this);});
C. Handlebars.registerhelper.helper ('ifRouteis', function (routename, options) {if (meteor.router.page () === Routename) {return options.fn (this);} return options.inverse (this);} ));
D. Tout ce qui précède
A. var loginrun; Template.bar.rendered = function () {LoginRun = Deps.autorun (function () {if (meteor.user ()) {// des trucs à exécuter lorsqu'ils sont connectés dans}}); } Template.bar.destRoyed = function () {loginrun.stop (); }
B. var loginrun; Templates.bar.rendered = function () {LoginRun = Deps.autorun (function () {if (meteor.user ()) {// des trucs à exécuter lorsqu'ils sont connectés dans}}} template.bar.destroyed = fonction () { Loginrun.stop ();}
C. var loginrun; LoginRun = Deps.autorun (function () {if (meteor.user ()) {// des trucs à exécuter lorsqu'ils sont connectés}}); Template.bar.destRoyed = function () {loginrun.stop (); }
D. Tout ce qui précède
A. Console et type Chrome ou ouverts simples: meteor.release (), vous pouvez également l'utiliser dans le code.
B. Console et type Chrome ou ouverts simples: meteor.update (), vous pouvez également l'utiliser dans le code.
C. Console et type Chrome ou ouverts simples: meteor.soin (), vous pouvez également l'utiliser dans le code.
D. Tout ce qui précède
A. Meteor.users.add (utilisateur, {$ set: {rôles: {admin: true},}});
B. Meteor.users.create (userId, {$ set: {rôles: {admin: true},}});
C. Meteor.users.update (userId, {$ set: {rôles: {admin: true},}});
D. Meteor.users.permission (userId, {$ set: {rôles: {admin: true},}});
A. Comptes.ui.config ({nom d'utilisateur: true, e-mail: false});
B. Comptes.ui.config ({mot de passe-SignUpFields: 'username_only',});
C. Comptes.ui.config ({userNameOnly: true});
D. Comptes.ui.config ({email: false});
A. Comptes.ValidateLoginAttempt
B. Comptes.Validatelogin
C. Comptes.loginATTempt
D. Comptes.validateloginattempts
A. UI optimiste
B. Optimiser la page
C. modèle de rendu
D. Aucune de ces réponses
A. Meteor.router.add ({'/ home / tools': function () {session.set ("hometemplate", "tools"); return 'home';}, '/ home / admin': function () {session .set ("hometemplate", "admin"); return 'home';}});
B. Template.home.hometemplatetools = function () {return session.equal ("hometemplate", "outils"); }; Template.home.hometemplatEadmin = function () {return session.equal ("hometemplate", "admin"); };
C. <template name = "home"> {{#if isadmin}} <h1> étudiant </h1> {{/ if}} <div id = "inner_home"> {{#if homeTemplateols}} {{> HoMetools}} {{/ if}} {{#if hometemplateadmin}} {{> homeadmin}} {{/ if}} </ template>
D. Tout ce qui précède
A. fermé
B. fini
C. partir
D. détruit
A. {{#if}} .. {{/ if}} {{#Ultil}} .. {{/ Till}} {{#with} .. {{/ avec}} {{#each}} .. {{ {/chaque}}
B. {{#if}} .. {{/ if}} {{#unless}} .. {{/ sauf si {/alors que}}
C. {{#if}} .. {{/ if}} {{#unless}} .. {{/ sauf si}} {{#With} .. {{/ avec}} {{#each}} .. {{ {/chaque}}
A. {{#if Layout.RendersideBar}} {{> SideBaradminnav}} {{/ if}} {{> rendement}}
B. {{#if adminroute}} {{> SidebarAdminnav}} {{> yeld}} {{else}} {{> yeld}} {{/ if}
C. {{#if userRoute}} {{> SidebarAdminnav}} {{> yeld}} {{else}} {{> yeld}} {{/ if}
D. Tout ce qui précède
A. ondered
B. créé
C. rendu
D. ondestroyed
A. Template.heloworld.helpers ({txt: function () {return template.instance (). Myasyncvalue.get ();}}); Template.heloworld.add = function () {var self = this; self.myasyncValue = new ReactiveVar ("En attente de réponse du serveur ..."); Meteor.call ('getasyncvalue', fonction (err, asyncValue) {if (err) console.log (err); else self.myasyncvalue.set (asyncValue);}); }
B. Template.heloworld.helpers ({txt: function () {return template.instance (). Myasyncvalue.get ();}}); Template.heloworld.created = function () {var self = this; self.myasyncValue = new ReactiveVar ("En attente de réponse du serveur ..."); Meteor.call ('getasyncvalue', fonction (err, asyncValue) {if (err) console.log (err); else self.myasyncvalue.set (asyncValue);}); }
C. Les deux ci-dessus
D. Aucune de ces réponses
A. Template.registerGlobalHelper () {... un code ...});
B. Template.registerHelper () {... un code ...});
C. Template.globalhelper () {... un code ...});
D. Aucune de ces réponses
A. Session.define ('variable_name', 5);
B. Session.create ('variable_name', 5);
C. Session.new ('variable_name', 5);
D. Session.set ('variable_name', 5);
A. Router.map (function () {this.router ('home', {Route: '/' modèle: 'home'});});
B. Router.mapper (function () {this.router ('home', {path: '/', modèle: 'home'});});
C. Router.map (function () {this.Route ('home', {path: '/', modèle: 'home'});});
A. DefaultNotfound
B. iSTEmplate
C. pas trouvé
D. NotfoundTemplate