Nossos especialistas reuniram esses Meteor - JavaScript Web Framework MCQs por meio de pesquisas. Esperamos que, ao responder a essas perguntas de múltipla escolha, você possa testar seus conhecimentos sobre o Meteor - JavaScript Web Framework.
Role para baixo para começar agora!
A. if (meteor.isserver) {meteor.invoke (‘samplemethod '); }
B. if (meteor.isclient) {meteor.invoke (‘samplemethod '); }
C. if (meteor.isserver) {meteor.call (‘samplemethod '); }
D. if (meteor.iscient) {meteor.call (‘samplemethod '); }
A. acesso
B. negar
C. permitir
D. permite -worng ands
A. ID do usuário
B. nome de usuário
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}, {rota: 'server'});
D. Router.Route ('/files/: name_of_file', function () {// action}, {at: 'server'});
A. nome do modelo = "home"> {{#markdown}} ## Bem -vindo ao meu site {{/markdown}} </modemplate>
B. Modelo Nome = "Home"> {{Markdown}} ## Bem -vindo ao meu site {{/Markdown}} </modemplate>
C. nome do modelo = "home"> {markdown} ## bem -vindo ao meu site {/markdown} </modemplate>
A. criada
B. OnCreated
C. OnDestroyed
D. renderizado
A. Rastrear.computation.stop ();
B. Tracker.autorun.stop ();
C. Rastrear.computation.halt ();
D. Tracker.autorun.end ();
A. meteoro Adicionar contas de contas
B. meteoro Adicionar contas de usuário-passanha
C. meteoro Adicionar contas-ui contas-pasassword
D. meteoro Adicionar o usuário-passa-palavra-usuário
A. REATIVA-JSON
B. reativo-dict
C. Reativo-Var
D. Todos esses. -Wrong Ans
A. carregado
B. renderizado
C. preparar
D. iniciar
A. Http.post ("http: // someurl", pós -dados,…);
B. Http.get (“http: // algumurl”,…);
C. Http.request ("Get", "http: // algumurl",…);
D. Http.call ("get", "http: // someurl",…);
A. A pesquisa de expressão regular é em tempo real
B. A pesquisa de expressão regular pode corresponder a palavras parciais
C. A pesquisa de expressão regular é muito eficiente
D. A pesquisa de expressão regular não suporta pesquisas de curinga
A. Inscrição do usuário
B. Verificação de e-mail
C. Redefinir senha
D. Todos esses.
A. {{> loginButtons}}
B. {{> logIndropdown}}
C. {{> login}}
D. {{> loginform}}
A. Formulários de login
B. Formulários de contas
C. contas-ui-instantilled
D. Contas -Ui -Wrong Ans
A. db.leaderboard.ensureIndex ({Point: 1})
B. db.leaderboard.ensureIndex ({mês: 1})
C. db.leaderboard.ensureIndex ({FullName: 1})
D. db.leaderboard.ensureIndex ({ano: 1})
A. repita
B. cada
C. para cada
D. Mapa -wrong Ans
A. Meteor Adicionar #Markdown
B. Meteor Add Markdown
C. Meteor Adicionar modelo de marcação
D. Modelo de adição de meteoro: Markdown
A. Retorno model.instance (). Contador.get ();
B. Return this.counter.get ();
C. Retorno modelo.currentData (). Contador.get ();
D. Retorno model.instance (). Data.counter.get ();
A. {{#com}}
B. {{#contexto}}
C. {{com}}
D. {{contexto}}
A. ONSENDERED
B. criada
C. renderizado
D. OnDestroyed -wrong Ans
A. Todos.find ({Sort: {date: -1}}, {limite: 10})
B. Todos.find ({}, {limite: 10, classificar: {date: -1}})
C. Todos.find ({}, {Limit: 10, Sort: 1})
D. Todos.find ({}, {Limit: 10, Sort: -1})
A. Meteor.publish ('getCollaborators', function (appid) {return users.find ({colaboradores: 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}); retorna usuários.find ({_ id: {$ in: App.collaborators}}});});
A. JSON
B. definir
C. Ejson
D. pegar
A. $ set
B. $ inc
C. encontrar
D. encontrar tudo
A. Meteor.account.allow ()
B. Meteor.permission.allow ()
C. Meteor.roles.allow ()
D. Meteor.users.allow ()
A. Formulários de login
B. Formulários de contas
C. contas-ui-instantilled
D. Contas -Ui -Wrong Ans
A. Conta.config ({ClosClientAccountCreation: true});
B. Conta.config ({probidAccountCreation: true});
C. Conta.config ({probidClientAccountCreation: true});
D. Conta.config ({closeAcCountCreation: true});
A. Satelizador
B. contas-base
C. Auth-Strategy
D. Auth-Base
A. Duas aplicações: A e B
B. Uma coleção compartilhada: postagens
C. Um banco de dados compartilhado via Mongo_url
D. Tudo o que precede
A. Variedade
B. Base de dados
C. Modelo
D. Dados
A. como garantir que as chaves certas sejam usadas
B. certificando -se de que nossos nomes de equipes sejam únicos
C. Definir um limite máximo de caracteres para que os nomes de nossas equipes não sejam muito longos
D. Tudo o que precede
A. if (meteor.isclient) {meteor.methods ({'sampleMethod': function () {console.log ("hello world");}}); }
B. if (meteor.isserver) {meteor.methods ({'sampleMethod': function () {console.log ("hello world");}}); }
C. if (meteor.iscient) {meteor.methods ({function sampleMethod () {console.log ("hello world");}}); }
D. if (meteor.isserver) {meteor.methods ({function sampleMethod () {console.log ("hello world");}}); }
A. {{-> myTemplate}}
B. {{<myTemplate}}
C. {{> myTemplate}}
D. {{myTemplate}}
A. REATIVA-JSON
B. reativo-dict
C. Reativo-Var
D. Todos esses. Ans
A. REATIVA-JSON
B. reativo-dict
C. Reativo-Var
D. Tudo o que precede
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. .Primeira corrida
B. .Última corrida
C. .primeira vez
D. .é primeiro
A. PatternMatch (myvar, string);
B. teste (myvar, string);
C. Match (myvar, string);
D. Verifique (myvar, string);
A. Haverá muitas assinaturas de "getcomments" logo após adicionar um comentário
B. Haverá muitas assinaturas de "getcomments" logo após a carga da página
C. Haverá muitas assinaturas "getuser" logo após adicionar um comentário
D. Haverá muitas assinaturas "getuser" logo após a página carregar
A. Template.template_contening_acetextexeditor.configuration = function () {return function (editor) {if (session.get ('text') == "algo") // aqui quero que seja reativo {// fazer algo todos os tempos 'texto ' mudanças } } }
B. Tracker.autorun (function () {if (session.get ('text') == "algo") // Isso será executado sempre que o texto da sessão muda {// faz algo todas as vezes 'textos' alterações}}) ** *
C. Ambos mencionados acima
D. Nenhuma das acima
A. Dados no fio através do protocolo de dados distribuídos (DDP)
B. Compensação de latência com mini bancos de dados
C. Reatividade completa da pilha com incêndio e rastreador
D. Tudo o que precede
A. Rastrear.Retive ()
B. Template.autorun ()
C. Tracker.autorun ()
D. Template.execute ()
A. {{#if CurrentUser}} <button id = "submit-btn"> clique em mim </butter> {{else}} <p id = "submit-text"> por favor, faça o login para enviar {{/if}} * **
B. Template.newPost.RenderD = function () {if (meteor.user ()) {$ ('#submmit-btn'). Show (); $ ('#envie-text'). hide (); } else {$ ('#submit-btn'). hide (); $ ('#envie-text'). show (); }}
C. Template.newPost.RenderD = function () {if (meteor.user ()) {$ ('#submmit-btn'). Show (); $ ('#envie-text'). hide (); }}
D. Tudo o que precede
A. Session.set ('contador', 0); Template.simple.counter = function () {retorna session.get ('contador'); } Template.simple.events ({'clique no botão': function () {session.set ('contador', session.get ('contador') + 1);}});
B. Template.set ('contador', 0); Template.simple.counter = function () {retorna session.get ('contador'); } Template.simple.events ({'clique no botão': function () {model.set ('contador', model.get.get ('contador') + 1);}});
C. Template.get ('contador', 0); Template.simple.counter = function () {retorna session.set ('contador'); } Template.simple.events ({'clique no botão': function () {session.set ('contador', session.get ('contador') + 1);}});
D. Tudo o que precede
A. Ejson
B. JSON
C. Variável
D. Tudo o que precede
A. Meteor Crie MyApp
B. App Meteor MyApp
C. Meteor -crie MyApp
D. Meteor --pp MyApp
A. $ meteorutils.autorun ($ scope, function () {$ meteorsubscribe.subscribe ('apublication', $ scope.getReactivamente ('parâmetro') .then (function () {alert ("você assinou!");}); });
B. Meteor.publish ("Apublication", function (parâmetro) {acollection.find ({'Apperty': 'Parameter'}) $ subscribe.subScribe ('Apublication', $ scope.parameter) .then (function () {alert ( "Você se inscreveu!");});
C. Ambos mencionados acima
D. Nenhuma das acima
A. Há um bug no código do cliente.
B. Quando um novo usuário adicionou um comentário, suas informações do usuário não foram enviadas ao cliente.
C. A publicação mostrada acima nunca envia informações do usuário ao cliente.
D. A publicação mostrada acima está errada
A. Reativo-Var
B. ReactiveVar
C. Varas reativas
D. reativo
A. Template.template_name.created = function () {}; Template.template_name.RenderD = function () {};
B. Template.template_name.new = function () {}; Template.template_name.RenderD = function () {};
C. Template.template_name.active = function () {}; Template.template_name.RenderD = function () {};
D. Template.template_name.created = function () {}; Template.template_name.active = function () {};
A. Use SQL Sintax no lado do cliente: Livre -se das limitações mínimas no agrupamento e sindicatos. Use Alasql no cliente e normalize as coleções mongas.
B. Use um conector SQL: tente os conectores MySQL e PG da NUMLTEL ou o conector PG de fluxo de meteoros. A desvantagem é que eles quebram as implantações em meteoros.
C. Use Mongo como escravo para o banco de dados relacional, mantendo -os em sincronia. MySQL Shadow usa isso. Além disso, você pode querer olhar para o Symmetric.ds para definir a replicação bidirecional de Mongo com muitos mecanismos SQL.
D. Tudo o que precede
A. Meteor.settings.facebook.token
B. Meteor.settings.public.token
C. Meteor.public.facebook.token
D. Meteor.settings.public.facebook.token
A. acesso
B. negar
C. permitir
D. permite
A. this.UserID;
B. this.UserID;
C. this.LoggedUserID;
D. this.LoggedUseID;
A. repita
B. cada
C. para cada
D. mapa
A. $ grupo
B. $ out
C. $ projeto
D. $ PLUCK
E. $ desenrolar
A. MyCollection = new DB.Collection ("Amostras")
B. MyCollection = New Collection ("Amostras")
C. MyCollection = new Mongo.Collection ("Amostras")
D. MyCollection = new MongoDB.Collection ("Amostras")
A. if (meteor.iscient) {template.home.events ({"click .increment": function () {var contatdoc = contat.findone (); if (contatdoc) contatdate ({_ id: contradoc._id}, {{{{{{{{ $ inc: {cliques: 1}}); else counter.insert ({clicks: 1});}}); Template.home.helpers ({cliques: function () {var contatdoc = contat.findone (); retorna contraDoc? Countsococ.Clicks: "0";}}); }
B. <model name = "home"> {{clicks}} <br/> <button type = "button" class = "increment"> increment </button> </modemplate>
C. Contador = new mongo.collection ('contador'); Contador.attachschema (new SimplesChema ({cliques: {type: number}, criado: {type: date, DenyUpDate: true, autovalue: function () {if (this.isinsert) retorna nova data; else (this.isUpSert) return {$ setoninsert: new Date}; else this.UnSet ();}}}));
D. Tudo o que precede
A. Template.layout.helper ({foohelper: function () {return 'foo string';}});
B. Template.layout.helpers ({foohelper: function () {return 'foo string';}});
C. Template.layout ({foohelper: function helper () {return 'foo string';}});
D. Template.layout.helpers ({function foohelper () {return 'foo string';}});
A. myMethod: function () {console.log (this.UserID); function innerfunction () {console.log (this.UserID); } innerfunction.bind (this); }
B. myMethod: function () {console.log (this.UserID); function innerfunction () {console.log (this.UserID); }; Innerfunction.Apply (this); }
C. myMethod: function () {var que = this; console.log (this.UserID); function innerfunction () {console.log (that.userID); } innerFunction (); }
D. myMethod: function () {var userID = this.UserID; console.log (this.UserID); função innerfunction (userID) {console.log (userID); innerFunction (); }
E. Tudo o que precede
A. Meteor.clientcall.methods ({'consolelog': function (message) {console.log (mensagem);},});
B. Deps.autorun (function () {meteor.clientCall.setClientId (meteor.userId ());});
C. Meteor.clientcall.apply (userID, 'consolelog', ['Esta mensagem deve aparecer no console do cliente']);
D. Tudo o que precede
A. Template.footemplate.helpers ({myHelper: function (myString) {output = myString;}});
B. Template.footemplate.helpers ({myHelper: function (parâmetros) {output = parameters.hash.mystring}});
C. Template.footemplate.helpers ({myHelper: function (parâmetros) {output = parameters.mystring}});
A. Router.Route = {Register: 'Register'}
B. Router.Route ('Register');
C. Router.Route ('/registra');
D. Router.Route ('/&? Register');
A. Meteor.function ('pack.add', texto);
B. Meteor.apply ('pack.add', texto);
C. Meteor.call ('pack.add', texto);
D. Tudo o que precede
A. Post.update ('post_id', {set: {title: 'Novo título do post!'}});
B. Post.update ('post_id', {$ set: {title: 'Novo título do post!'}});
C. Post.update ('post_id', {update: {title: 'Novo título do post!'}});
D. Post.update ('post_id', {$ set {title: 'Novo título do post!'}});
A. var AnswersByQuiz1 = Answers.find ({'Quiz._id': 1}). fetch ();
B. var Answers = Answers.find ({'Quiz._id': {$ in: [1,2,3,4,5,6,7]}}). fetch ();
C. _.groupby (respostas, function (resposta) {return Answer.quiz._id;});
D. Tudo o que precede
A. Meteor.publish ('posts', posta.find ({autor: autor}));
B. Meteor.publish ('posts', function (autor) {return Posts.publish ({Autor: autor});});
C. Meteor.publish ('posts', function (autor) {return posts.find ({autor: autor});});
D. Meteor.find ('Posts', function (autor) {return Posts.publish ({autor: autor});});
A. var selecionado = [{objeto}, {objeto}]; var selectedIDs = tips.find (). fetch ();
B. var selectedIDs = _.pluck (selecionado, _id); var artigos = tips.find ({_ id: {$ nin: selectedids}});
C. var selecionado = [{objeto}, {objeto}]; var selectedIDs = tips.find ({_ id: {$ nin: selectedIds}});
D. Tudo o que precede
A. Postagens = new Mongo.collection ('postagens);
B. Postagens = novo mongo.collection ('postagens);
C. Postagens = novo mongo.collection ('postagens);
D. Postagens = new Mongo.Collections ('postagens);
A. Meteor Adicionar seguro
B. Meteor Adicionar senha
C. Meteor Remover inseguro
D. METEOR ADICIONE POLÍTICA
A. Metas = new meteor.collection ("metas", {transform: function (doc) {doc.title = function () {if (false) {console.log ("true"); return 'le início';} else { console.log ("false"); retornar 'le début';} retornar doc}}});
B. Metas = new meteor.collection ("metas"); Targets.Insert ({id: 0, title: function () {if (false) {console.log ("true"); retornar 'lei início';} else {console.log ("false"); retornar 'le le début ';}}, texto:' Lorem ipsum dolor. ',}); `
C. Modeplates.content.target = function () {var currentPosition = meteor.user (). Perfil.position; retornar os destino.findone ({id: parseint (currentposition)}); };
D. Tudo o que precede
A. Template.example.events ({'clique #UpDatethis': function (e, t) {var newValue = t. $ ('. Newvalue'). : this._id}, {$ set: {value: newValue}}, function (erro, resultado) {if (error) {console.log (error.Reason)} else {console.log ("nice update")} })}})
B. Template.example.event ({'clique #UpDatethis': function (e, t) {var newValue = t. $ ('. Newvalue'). : this._id}, {$ set: {value: newValue}}, function (erro, resultado) {if (error) {console.log (error.Reason)} else {console.log ("nice update")} })}})
C. Template.example.events ({'dbClick #UpDatethis': function (e, t) {var newValue = t. $ ('. Newvalue'). : this._id}, {$ set: {value: newValue}}, function (erro, resultado) {if (error) {console.log (error.Reason)} else {console.log ("nice update")} })}})
D. Tudo o que precede
A. Pasta in /servidor Adicione um arquivo .js contendo: meteor.publish ('postagens', function () {return posts.find ();}); Pasta in /client Adicione um arquivo .js contendo: meteor.subscribe ('postagens');
B. Pasta in /client Adicione um arquivo .js contendo: meteor.publish ('postagens', function () {return posts.find ();}); Pasta in /servidor Adicione um arquivo .js contendo: meteor.subscribe ('postagens');
C. Pasta in /servidor Adicione um arquivo .js contendo: meteor.subscribe ('posts', function () {return posts.find ();}); Pasta in /client Adicione um arquivo .js contendo: meteor.posts ('posts');
D. Pasta in /servidor Adicione um arquivo .js contendo: meteor.publish ('postagens', function () {return posts.find ();}); Pasta in /client Adicione um arquivo .js contendo: meteor.subscribe ('postagens');
A. Meteor.publish ('Posts', function () {return posts.find ({}, {campos: {title: true}});});
B. Meteor.publish ('Posts', function () {return posts.find ({}, {campos: {title: 1}});});
C. Meteor.publish ('posts', function () {return posts.find ({}, {field: {title: 1}});});
D. Meteor.publish ('posts', function () {return posts.find ({}, campos: {title: 1});});
A. {"_id": "w78123byuxzedw"}
B. {"id": "w78123byuxzedw"}
C. {"Id": "w78123byuxzedw"}
D. {"Key": "w78123byuxzedw"}
A. MyCollection.find ();
B. MyCollection.Fetch ();
C. MyCollection.Search ();
D. MyCollection.get ();
A. É impossível renderizar um único caminho ou parte dele.
B. É difícil enviar um subconjunto da árvore para o cliente.
C. Não há problema com este modelo.
D. O DDP não tem suporte para este modelo.
A. Template.example.helpers ({PostList: function () {return posts.find ({}, {sort: {timepublished: 1}});}});
B. Template.example.helpers ({PostList: function () {return posts.find ({}, {sort: {timepublished: 0}});}});
C. Template.example.helpers ({PostList: function () {return posts.find ({}, {sort: {timepublished: 'desc'}});}});
D. Template.example.helpers ({PostList: function () {return posts.find ({}, {sort: {timepublished: -1}});}});
A. caminho atual()
B. getQueryparam ()
C. getCurrentRouteParam ()
D. getRoutEname ()
A. 1
B. 2
C. 3
D. Infinito
A. Formulários de login
B. Formulários de contas
C. contas-ui-instantilled
D. Contas-Ui
A. Template.mytemplate.events ({'clique #mybutton': function () {..},});
B. Template.mytemplate.events ({'clique em $ mybutton': function () {..},});
C. Template.mytemplate.events ({'click .mybutton': function () {..},});
D. Template.mytemplate.events ({'clique em mybutton': function () {..},});
A. Handlebars.registerHelper ('ifrouteis', function (rotename) {return meteor.router.page () === rotename;});
B. Handlebars.registerHelper ('ifrouteis', function (roteName, options) {if (meteor.router.page () === rotename) {retorna opções.fn (this);} opções de retorno.inverse (this);});
C. Handlebars.registerhelper.helper ('ifrouteis', function (rotenename, opções) {if (meteor.router.page () === RoutEname) {retorna opções.fn (this);} opções de retorno.inverse (this);} );
D. Tudo o que precede
A. var LoginRun; Template.bar.renderD = function () {loginrun = deps } Template.bar.destroyed = function () {loginrun.stop (); }
B. var LoginRun; Modeplates.bar.RenderD = function () {loginrun = deps.autorun (function () {if (meteor.user ()) {// coisas para executar quando logado}}} template.bar.destroyed = function () { loginrun.stop ();}
C. var LoginRun; loginrun = deps Template.bar.destroyed = function () {loginrun.stop (); }
D. Tudo o que precede
A. Console e tipo de cromo simples e aberto: meteor.release (), você também pode usá -lo no código.
B. Console e tipo de cromo simples e aberto: meteor.update (), você também pode usá -lo no código.
C. Console e tipo de cromo simples e abertos: meteor.soon (), você também pode usá -lo no código.
D. Tudo o que precede
A. Meteor.users.add (userID, {$ set: {RONS: {admin: true},}});
B. Meteor.users.create (userID, {$ set: {ROUS: {admin: true},}});
C. Meteor.users.update (userID, {$ set: {RONS: {admin: true},}});
D. Meteor.users.permission (userID, {$ set: {Roles: {admin: true},}});
A. Conta.ui.config ({nome de usuário: true, email: false});
B. Accouts.ui.config ({senhaSignUpfields: 'UserName_only',});
C. Accounta.ui.config ({userNameonly: true});
D. Conta.ui.config ({email: false});
A. Conta.Validateloginattempt
B. Accouts.Validatelogin
C. Accouts.Loginattemp
D. Accouts.ValidateLoginattempts
A. Ui otimista
B. Otimizar a página
C. Modelo de renderização
D. Nenhuma das acima
A. Meteor.router.add ({'/home/ferramentas': function () {session.set ("homeTemplate", "ferramentas"); retornar 'home';}, '/home/admin': function () {sessão .set ("hometemplate", "admin"); retornar 'home';}});
B. Template.home.hometemplateTools = function () {retorna session.equal ("hometemplate", "ferramentas"); }; Template.home.hometemplateAdmin = function () {return Session.equal ("HomeTemplate", "Admin"); };
C. <model name = "home"> {{#if isadmin}} <h1> aluno </h1> {{/if}} <div id = "iner_home"> {{#if homeTemplateTeTools}} {{> hometools}}} {{/if}} {{#if HomeTemplateAdmin}} {{> homeadmin}} {{/if}} </modemplate>
D. Tudo o que precede
A. fechado
B. finalizado
C. deixar
D. Destruído
A. {{#if}} .. {{/if}} {{#until}} .. {{/até}} {{#with} .. {{/com}} {{#each}} .. { {/cada}}
B. {{#if}} .. {{/if}} {{#unless}} .. {{/a menos {/enquanto}}
C. {{#if}} .. {{/if}} {{#Unless}} .. {{/a menos {/cada}}
A. {{#if layout.rendersidebar}} {{> latebaradMinnav}} {{/if}} {{> rendimento}}
B. {{#if adminRoute}} {{> lateBaradMinnav}} {{{> yeld}} {{else}} {{> yeld}} {{/if}
C. {{#if userRoute}} {{> latebaradMinnav}} {{> yeld}} {{else}} {{> yeld}} {{/if}
D. Tudo o que precede
A. On -rendered
B. criada
C. renderizado
D. OnDestroyed
A. Template.helloworld.helpers ({txt: function () {return modelo.instance (). Myasyncvalue.get ();}}); Template.helloworld.add = function () {var self = this; self.myasyncvalue = new ReactiveVar ("Aguardando a resposta do servidor ..."); Meteor.call ('getasyncvalue', function (err, asyncvalue) {if (err) console.log (err); else self.myasyncvalue.set (asyncvalue);}); }
B. Template.helloworld.helpers ({txt: function () {return modelo.instance (). Myasyncvalue.get ();}}); Template.helloworld.created = function () {var self = this; self.myasyncvalue = new ReactiveVar ("Aguardando a resposta do servidor ..."); Meteor.call ('getasyncvalue', function (err, asyncvalue) {if (err) console.log (err); else self.myasyncvalue.set (asyncvalue);}); }
C. Ambos mencionados acima
D. Nenhuma das acima
A. Template.registerglobalhelper () {... algum código ...});
B. Template.registerHelper () {... algum código ...});
C. Template.globalhelper () {... algum código ...});
D. Nenhuma das acima
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', {rota: '/' modelo: 'home'});});
B. Router.mapper (function () {this.router ('home', {path: '/', modelo: 'home'});});
C. Router.map (function () {this.Route ('home', {path: '/', modelo: 'home'});});
A. defaultNotfound
B. istemplate
C. não encontrado
D. notfoundtemplate