我永远安装并使用它，发现它非常有趣。

但我意识到日志被放置在其他地方。 有什么提示吗？

我们正在开发一个使用新的firebase云功能的应用程序。 目前正在发生的事情是将事务放入队列节点。 然后该函数删除该节点并将其放入正确的节点。 由于能够脱机工作，因此已实施。

我们目前的问题是功能的速度。 该功能本身需要大约400毫秒，所以没关系。 但有时功能需要很长时间（大约8秒），而条目已经添加到队列中。

我们怀疑服务器需要时间来启动，因为当我们在第一次执行后再次执行操作时。 它花费的时间更少。

有什么方法可以解决这个问题吗？ 在这里，我添加了我们的功能代码。 我们怀疑它没有任何问题，但我们添加它以防万一。

const functions = require('firebase-functions');
const admin = require('firebase-admin');
const database = admin.database();

exports.insertTransaction = functions.database
    .ref('/userPlacePromotionTransactionsQueue/{userKey}/{placeKey}/{promotionKey}/{transactionKey}')
    .onWrite(event => {
        if (event.data.val() == null) return null;

        // get keys
        const userKey = event.params.userKey;
        const placeKey = event.params.placeKey;
        const promotionKey = event.params.promotionKey;
        const transactionKey = event.params.transactionKey;

        // init update object
        const data = {};

        // get the transaction
        const transaction = event.data.val();

        // transfer transaction
        saveTransaction(data, transaction, userKey, placeKey, promotionKey, transactionKey);
        // remove from queue
        data[`/userPlacePromotionTransactionsQueue/${userKey}/${placeKey}/${promotionKey}/${transactionKey}`] = null;

        // fetch promotion
        database.ref(`promotions/${promotionKey}`).once('value', (snapshot) => {
            // Check if the promotion exists.
            if (!snapshot.exists()) {
                return null;
            }

            const promotion = snapshot.val();

            // fetch the current stamp count
            database.ref(`userPromotionStampCount/${userKey}/${promotionKey}`).once('value', (snapshot) => {
                let currentStampCount = 0;
                if (snapshot.exists()) currentStampCount = parseInt(snapshot.val());

                data[`userPromotionStampCount/${userKey}/${promotionKey}`] = currentStampCount + transaction.amount;

                // determines if there are new full cards
                const currentFullcards = Math.floor(currentStampCount > 0 ? currentStampCount / promotion.stamps : 0);
                const newStamps = currentStampCount + transaction.amount;
                const newFullcards = Math.floor(newStamps / promotion.stamps);

                if (newFullcards > currentFullcards) {
                    for (let i = 0; i < (newFullcards - currentFullcards); i++) {
                        const cardTransaction = {
                            action: "pending",
                            promotion_id: promotionKey,
                            user_id: userKey,
                            amount: 0,
                            type: "stamp",
                            date: transaction.date,
                            is_reversed: false
                        };

                        saveTransaction(data, cardTransaction, userKey, placeKey, promotionKey);

                        const completedPromotion = {
                            promotion_id: promotionKey,
                            user_id: userKey,
                            has_used: false,
                            date: admin.database.ServerValue.TIMESTAMP
                        };

                        const promotionPushKey = database
                            .ref()
                            .child(`userPlaceCompletedPromotions/${userKey}/${placeKey}`)
                            .push()
                            .key;

                        data[`userPlaceCompletedPromotions/${userKey}/${placeKey}/${promotionPushKey}`] = completedPromotion;
                        data[`userCompletedPromotions/${userKey}/${promotionPushKey}`] = completedPromotion;
                    }
                }

                return database.ref().update(data);
            }, (error) => {
                // Log to the console if an error happened.
                console.log('The read failed: ' + error.code);
                return null;
            });

        }, (error) => {
            // Log to the console if an error happened.
            console.log('The read failed: ' + error.code);
            return null;
        });
    });

function saveTransaction(data, transaction, userKey, placeKey, promotionKey, transactionKey) {
    if (!transactionKey) {
        transactionKey = database.ref('transactions').push().key;
    }

    data[`transactions/${transactionKey}`] = transaction;
    data[`placeTransactions/${placeKey}/${transactionKey}`] = transaction;
    data[`userPlacePromotionTransactions/${userKey}/${placeKey}/${promotionKey}/${transactionKey}`] = transaction;
}

如果使用类似的东西，如何批量插入mySQL[https://github.com/felixge/node-mysql]

如何让node.js服务器在输入无效网址时将用户重定向到404.html页面？

我做了一些搜索，看起来大多数结果都是针对Express，但我想在纯node.js中编写我的服务器。

我已经和Node.js一起工作了一段时间，并认为自己对Java很好。 但我刚发现Akka，并立即对其演员模式感兴趣（据我了解）。

现在，假设我的JavaScript技能与我的Scala / Java技能相当，我想专注于任一系统的实用性。 特别是在Web服务方面。

据我所知，Node非常适合处理许多并发操作。 我想资产管理系统的一个好的Node Web服务可以很好地处理许多同时提交更改的用户（在大型，繁忙的流量应用程序中）。

但是在阅读了Akka中的演员之后，它会在同样的事情上表现出色。 我喜欢将工作量减少到一口大小的想法。 此外，多年前我涉足Erlang并爱上了它使用的消息传递系统。

我处理许多处理复杂业务逻辑的应用程序，并且我认为现在是时候把它们加入到一个或另一个中。 特别是升级传统的Struts和C＃应用程序。

无论如何，避免神圣的战争，两个系统如何根本不同？ 它们似乎都面向同一个目标。 也许Akka＆＃34;自我修复＆＃34; 建筑有一个优势。

编辑

看起来我正在接近投票。 请不要将此问题视为＆＃34;哪个更好，是节点还是akka？＆＃34;。 我正在寻找的是事件驱动库（如Node和基于演员的库，如Akka）的根本区别。

我正在Node.js和Mongoose中准备数据库创建脚本。如何检查数据库是否已存在，如果是，请使用Mongoose删除（删除）它？

我找不到用Mongoose放弃它的方法。

我试图将gulp.src传递给我想要它处理的文件数组。 这是阵列的原样。

['bower_components/jquery/jquery.js',
 'bower_components/superscrollorama/js/greensock/TweenMax.min.js',
 'bower_components/superscrollorama/jquery.superscrollorama.js' ]

我发现虽然gulp.src看起来并不喜欢这样，但第三个元素并没有通过最终目的地。

当我介绍一些像这样的通配符时，我发现一切正常：

['bower_components/**/jquery.js',
 'bower_components/**/js/greensock/TweenMax.min.js',
 'bower_components/**/jquery.superscrollorama.js' ]

但为什么？ 与globbing的工作方式有关吗？ 我用谷歌搜索但无法找到答案。

也许这不是全球化的预期目的，但对我来说它应该以这种方式起作用并不合理。 任何人都能解释一下吗？

我使用快递框架。 我想从socket.io访问会话数据。 我尝试使用client.listener.server.dynamicViewHelpers数据表达dynamicHelpers，但我无法获取会话数据。 有一个简单的方法吗？ 请参阅代码

app.listen(3000);

var io = require('socket.io');
var io = io.listen(app);

io.on('connection', function(client){
    // I want to use session data here
    client.on('message', function(message){
        // or here
    });
    client.on('disconnect', function(){
        // or here
    }); 
});

如何在使用带有Node.JS的Express时摆脱Jade？ 我想只使用普通的HTML。 在其他文章中我看到人们推荐的app.register（）现在已在最新版本中弃用。

我最近通过我的ubuntu 16.04中的节点版本，当使用node -v命令时它显示我的版本6.9.1但是当它使用nodejs -v之前它显示6.9.2之前使用了这个命令npm update命令。

现在node -v和nodejs -v的差异是什么？ 以及如何更新到节点/ nodejs的最新LTS版本？

ES6在Node 4中完全可用。我想知道它是否包含定义方法合同的接口概念，如MyClass implements MyInterface。

我用谷歌搜索找不到多少，但也许有一个很好的技巧或解决方法可用。

我正在使用Passport.js使用简易节点身份验证：安装和本地教程构建身份验证系统。

我对express.session()的作用感到困惑。

在使用不同的中间件后，我开始明白express.session()是通过cookie向客户端发送会话ID的内容，但我对passport.session()做了什么以及除了express.session()之外还需要它的原因感到困惑。

以下是我设置应用程序的方法：

// Server.js配置应用程序并设置Web服务器

//importing our modules
var express = require('express');
var app = express();
var port = process.env.PORT || 8080;
var mongoose = require('mongoose');
var passport = require('passport');
var flash = require('connect-flash');

var configDB = require('./config/database.js');

//Configuration of Databse and App

mongoose.connect(configDB.url); //connect to our database

require('./config/passport')(passport); //pass passport for configuration

app.configure(function() {

    //set up our express application

    app.use(express.logger('dev')); //log every request to the console
    app.use(express.cookieParser()); //read cookies (needed for auth)
    app.use(express.bodyParser()); //get info from html forms

    app.set('view engine', 'ejs'); //set up ejs for templating

    //configuration for passport
    app.use(express.session({ secret: 'olhosvermelhoseasenhaclassica', maxAge:null })); //session secret
    app.use(passport.initialize());
    app.use(passport.session()); //persistent login session
    app.use(flash()); //use connect-flash for flash messages stored in session

});

//Set up routes
require('./app/routes.js')(app, passport);

//launch
app.listen(port);
console.log("Server listening on port" + port);

我有一个关于模块缓存的node.js文档的问题：

模块在第一次加载后进行缓存。 这意味着   （除此之外）每次调用require（'foo'）都会得到   返回完全相同的对象，如果它将解析为相同   文件。

多次调用require（'foo'）可能不会导致模块代码   多次执行。 这是一个重要的特征。 用它，   可以返回“部分完成”的对象，从而允许传递   即使它们会导致循环，也要加载依赖项。

may是什么意思？

我想知道require是否总是返回相同的对象。 因此，如果我需要app.js中的模块A并在app.js（需要返回的那个）中更改导出对象，之后需要app.js中的模块B本身需要模块A，我是否总是得到该对象的修改版本， 还是新的？

// app.js

var a = require('./a');
a.b = 2;
console.log(a.b); //2

var b = require('./b');
console.log(b.b); //2

// a.js

exports.a = 1;

// b.js

module.exports = require('./a');

我正在使用MongoDB和Node.JS. 我有一个包含日期和其他行的集合。 该日期是一个JavaScript Date对象。

如何按日期对此集合进行排序？

我想使用mongodb数据库，但我注意到有两个不同的数据库，有自己的网站和安装方法：mongodb和mongoose。 所以我想问自己这个问题：＆＃34;我使用哪一个？＆＃34;。

所以为了回答这个问题，我问社区你是否可以解释这两者之间有什么区别？ 如果可能的利弊？ 因为他们看起来和我很相似。

我将我的应用程序（node.js）部署在VPS（linux）上。 我使用git hub作为存储库。 如何在git push上自动部署应用程序？

我刚开始研究ReactJS，发现它为您提供了两种呈现页面的方法：服务器端和客户端。 但是，我无法理解如何一起使用它。 它是构建应用程序的两种不同方式，还是可以一起使用？

如果我们可以一起使用它，怎么做 - 我们是否需要在服务器端和客户端复制相同的元素？ 或者，我们可以在服务器上构建应用程序的静态部分，以及客户端上的动态部分，而不与已经预呈现的服务器端建立任何连接吗？

在早期版本的Mongoose（对于node.js）中，有一个选项可以在不定义模式的情况下使用它

var collection = mongoose.noSchema(db, "User");

但在当前版本中，“noSchema”功能已被删除。 我的模式可能经常更改，并且实际上不适合定义的模式，所以有没有一种在mongoose中使用无模式模型的新方法？

在EJS github页面上，只有一个简单的例子：[https://github.com/visionmedia/ejs]

例

<% if (user) { %>
    <h2><%= user.name %></h2>
<% } %>

这似乎是检查是否存在名为user的变量，如果存在，则执行一些操作。 呃，对吗？

我的问题是，如果用户变量不存在，为什么Node会抛出一个ReferenceError？ 这使得上面的例子变得毫无用处。 检查变量是否存在的合适方法是什么？ 我是否希望使用try / catch机制并获取ReferenceError？

ReferenceError: user is not defined
    at IncomingMessage.anonymous (eval at <anonymous> (/usr/local/lib/node/.npm/ejs/0.3.1/package/lib/ejs.js:140:12))
    at IncomingMessage.<anonymous> (/usr/local/lib/node/.npm/ejs/0.3.1/package/lib/ejs.js:142:15)
    at Object.render (/usr/local/lib/node/.npm/ejs/0.3.1/package/lib/ejs.js:177:13)
    at ServerResponse.render (/usr/local/lib/node/.npm/express/1.0.7/package/lib/express/view.js:334:22)
    at Object.<anonymous> (/Users/me/Dropbox/Projects/myproject/server.js:188:9)
    at param (/usr/local/lib/node/.npm/connect/0.5.10/package/lib/connect/middleware/router.js:146:21)
    at pass (/usr/local/lib/node/.npm/connect/0.5.10/package/lib/connect/middleware/router.js:162:10)
    at /usr/local/lib/node/.npm/connect/0.5.10/package/lib/connect/middleware/router.js:152:27
    at Object.restrict (/Users/me/Dropbox/Projects/myproject/server.js:94:5)
    at param (/usr/local/lib/node/.npm/connect/0.5.10/package/lib/connect/middleware/router.js:146:21)

我明白我可以通过在我的服务器代码中添加一个“用户”局部变量来消除这个错误，但这里的重点是我想在运行时使用你的每天if / else来检查这些变量是否存在 nullcheck类型模式。 不存在的变量的例外对我来说似乎很荒谬。

场景：考虑以下是节点Web应用程序的代码部分。

app.get('/users/:id?', function(req, res, next){
    var id = req.params.id;
    if (id) {
        // do something
    } else {
        next(); //or return next();
    }
});

问题：我正在检查哪一个只有next()或return next()。上面的示例代码对两者都是完全相同的。 没有表现出任何执行上的差异。

问题：有人可以对此有所了解，何时使用next()以及何时使用return next()和一些重要区别？